If a module has a member named ModuleApply, the module name can be used as if it were a procedure name.  Calling M(args) invokes M:-ModuleApply(args).

There is no difference between making ModuleApply a local or export of the module when calling the procedure as M(args). It often makes more sense to make ModuleApply a local: that reinforces to the user of the module that they should use the M(args) rather than the M:-ModuleApply(args) calling sequence. This, in turn, leaves the programmer free to later change M back into a plain procedure without changing its user-facing behavior.

Maple's module data structure is close to the "class" concept in object oriented programming.  Due to the dynamic nature of Maple, modules can also be used to represent "objects".  One major difference between classes and objects are constructors.  Constructors can be nicely emulated using generated modules. ModuleApply provides the ability to treat a module as a function and make it "apply-able".

m := module() local ModuleApply;
    ModuleApply := proc()
        print("m called with args: ", [args]);
    end proc;
end module;

$m≔\mathbf{module}\left(\right)\mathbf{local}\mathrm{ModuleApply}\;\mathbf{end\; module}$

$m\left(1\,2\right)$

$''m\; called\; with\; args:'',\left[1\,2\right]$

MyEvalf := proc(f)
    if type(f,function) and type(op(0,f),`module`(Evalf)) then
        op(0,f):-Evalf(op(f));
    else
        error "cannot evaluate %1", f;
    end if;
end proc;

$\mathrm{MyEvalf}≔\mathbf{proc}\left(f\right)\mathbf{if}\mathrm{type}\left(f\,\mathrm{function}\right)\mathbf{and}\mathrm{type}\left(\mathrm{op}\left(0\,f\right)\,\mathrm{module}\left(\mathrm{Evalf}\right)\right)\mathbf{then}\mathrm{op}\left(0\,f\right):-\mathrm{Evalf}\left(\mathrm{op}\left(f\right)\right)\mathbf{else}\mathbf{error}''cannot\; evaluate\; \%1''\,f\mathbf{end\; if}\mathbf{end\; proc}$

Sine := module() local ModuleApply; export Evalf;
    ModuleApply := proc(x)
        if type(x,float) then
            sin(x);
        else
            'Sine'(x);
        end if;
    end proc;

    Evalf := proc(x)
        `evalf/sin`(x);
    end proc;
end module;

$\mathrm{Sine}≔\mathbf{module}\left(\right)\mathbf{local}\mathrm{ModuleApply}\;\mathbf{export}\mathrm{Evalf}\;\mathbf{end\; module}$

$\mathrm{Sine}\left(0.3\right)$

$0.2955202067$

$\mathrm{Sine}\left(3\right)$

$\mathrm{Sine}\left(3\right)$

$\mathrm{MyEvalf}\left(\mathrm{Sine}\left(3\right)\right)$

$0.1411200081$

$\mathrm{Cache}\left(128\right)$

$\mathrm{Cache}\left(128\right)$