This example separates the implementation of list-append and Array-append:

append := overload(
    [
        proc( l::list, e::anything ) option overload;
            [ op(l), e ];
        end,

        proc( a::Array(1..-1), e::anything ) option overload;
            a(numelems(a)+1) := e;
        end
    ]
):

$\mathrm{append}\left(\left[1\,2\right]\,3\right)$

$\left[1\,2\,3\right]$

$\mathrm{append}\left(\mathrm{Array}\left(\left[77\,88\right]\right)\,99\right)$

$\left[\begin{array}{ccc}77& 88& 99\end{array}\right]$

Extend the above example with a common helper function to do additional argument checking.  In this case use option overload(callseq_only) so that invalid-input exceptions from inside the helper function are raised to the top.

VerifyUnique := proc( a, e )
    if member(e,a) then
        error "invalid input: %1 already exists in the collection",e;
    end if;
end proc:

AppendUnique := overload(
    [   
        proc( l::list, e::anything ) option overload(callseq_only);
            VerifyUnique(l,e);
            [ op(l), e ];
        end,

        proc( a::Array(1..-1), e::anything ) option overload(callseq_only);
            VerifyUnique(a,e);
            a(numelems(a)+1) := e;
        end
    ]
):

$a≔\mathrm{AppendUnique}\left(\left[1\,2\right]\,3\right)$

$a≔\left[1\,2\,3\right]$

$a≔\mathrm{AppendUnique}\left(a\,3\right)$

Error, (in VerifyUnique) invalid input: 3 already exists in the collection

The error raised above is expected -- the given list already contains `a`, so our overload is rejecting the attempt to append it again.

In this example we will look at redefining the definition of `+` and `-` for sets to mean union and difference.  

SetOperations := module() option package;  export `+`;
    `+` := proc(a::set, b::set) option overload;
        a union b;
    end proc;
end module:

$\mathrm{with}\left(\mathrm{SetOperations}\right)$

$\left[\mathrm{`+`}\right]$

$\left\{1\,2\,3\right\}+\left\{3\,4\right\}$

$\left\{1\,2\,3\,4\right\}$

Note that the overload applies only to operations on sets because of the argument type checks in the definition of `+` and `-`. Using `+` with other data types does not invoke this method.

$1+1$

$2$

The `-` operator in Maple is interpreted as a unary operator.  Subtraction must be handled as the compound operation, a - b  =  `+`(a,`-`(b)).

SetOperations := module() option package;  export `+`, `-`;
    `+` := overload( [
        proc(a::set, b::set) option overload;
        a union b;
    end proc,
        proc(a::set, b::`MINUS`(set)) option overload;
            a minus op(b);
        end,
        proc(a::`MINUS`(set), b::set) option overload;
            b minus op(a);
        end
    ]);
    `-` := proc(a::set) option overload;
        MINUS(a);
    end proc;
end module:

$\mathrm{with}\left(\mathrm{SetOperations}\right)$

$\left[\mathrm{`+`}\,\mathrm{`-`}\right]$

$\left\{1\,2\,3\right\}+\left\{3\,4\right\}$

$\left\{1\,2\,3\,4\right\}$

$\left\{1\,2\,3\right\}-\left\{3\,4\right\}$

$\left\{1\,2\right\}$

$1+1$

$2$

$3-2$

$1$

Indexing can be overloading by defining a procedure named `?[]`.  For clarity we will separate the select and assignment operations in this example.  Both are dispatched to from the main `?[]` procedure. Note that proper assignment requires the "var" argument to be ::uneval.  Evaluation must be done by calling eval();

Quaternion := module()
    option package;
    export `?[]`, `*`, `+`, `-`:
    local `?[assign]`, `?[select]`, ModuleLoad, ModuleApply:

    ModuleApply := proc( h, i, j, k )
       QUATERNION(h,i,j,k);
    end proc:

    ModuleLoad := proc()
        global `print/QUATERNION`;
        `print/QUATERNION` := proc(h,i,j,k)
         h + `i `*i + `j `*j + `k `*k;
        end proc:

        TypeTools[AddType]( tQuaternion, t->evalb(op(0,t) = 'QUATERNION') );
    end proc:
    ModuleLoad();

    `+` := proc(a::tQuaternion, b::tQuaternion)
        option overload:
        QUATERNION(op(1,a)+op(1,b), op(2,a)+op(2,b),
                   op(3,a)+op(3,b), op(4,a)+op(4,b));
    end proc;

    `-` := proc(a::tQuaternion)
        option overload:
        QUATERNION(-op(1,a), -op(2,a), -op(3,a), -op(4,a));
    end proc;

    `*` := proc(a::tQuaternion, b::tQuaternion)
        option overload:
        local A, B;
        A := [op(a)]:  B := [op(b)]:
        QUATERNION(A[1]*B[1] - A[2]*B[2] - A[3]*B[3] - A[4]*B[4],
           A[1]*B[2] + A[2]*B[1] + A[3]*B[4] - A[4]*B[3],
           A[1]*B[3] - A[2]*B[4] + A[3]*B[1] + A[4]*B[2],
           A[1]*B[4] + A[2]*B[3] - A[3]*B[2] + A[4]*B[1]);
    end proc;

    `?[]` := proc(q::uneval, index::[{1,2,3,4}], val)
        option overload:
        if nargs = 2 then
            `?[select]`(eval(q),op(index));
        else
            `?[assign]`(q,eval(q),op(index),op(val));
        end if;
    end proc:

    `?[select]` := proc(q::tQuaternion, index::{1,2,3,4} )
    op(index, q)
    end proc:

    `?[assign]` := proc(var::uneval, q::tQuaternion, index::{1,2,3,4},
                        val::integer )
    var := subsop(index = val, q);
    end proc:
end module:

$\mathrm{with}\left(\mathrm{Quaternion}\right)$

$\left[\mathrm{`*`}\,\mathrm{`+`}\,\mathrm{`-`}\,\mathrm{?[]}\right]$

$a≔\mathrm{Quaternion}\left(5\,6\,7\,8\right)$

$a≔5+6i+7j+8k$

$b≔\mathrm{Quaternion}\left(1\,2\,3\,4\right)$

$b≔1+2i+3j+4k$

$c≔a+b$

$c≔6+8i+10j+12k$

$c\left[2\right]≔7$

$6+7i+10j+12k$

$c$

$6+7i+10j+12k$

$ab$

$-60+20i+14j+32k$

$ba$

$-60+12i+30j+24k$

When procedures with option overload are called directly, bypassing the with() bindings, or implicitly inside a package module, they behave as if they were ordinary procedures, and do not attempt to call another implementation in light of a type mismatch.  Consider the following example.

FloatTools := module()
  option package;
  export rhs, decimalpart, alt_decimalpart;
  local RHS;

  rhs := proc(f::float)
    option overload;
    f-trunc(f);
  end proc:

  decimalpart := proc(f)
    rhs(f);
  end proc;

  RHS := overload( [rhs, :-rhs ] );

  alt_decimalpart := proc(f)
    RHS(f);
  end proc;

end module:

After loading the package declared above, the 'rhs' function will work in the new way on float types, while calls to 'rhs' with other data continue to work as usual.

$\mathrm{with}\left(\mathrm{FloatTools}\right)$

$\left[\mathrm{alt\_decimalpart}\,\mathrm{decimalpart}\,\mathrm{rhs}\right]$

$\mathrm{rhs}\left(3.14\right)$

$0.14$

$\mathrm{rhs}\left(x^2-1=y^2\right)$

$y^2$

The function 'decimalpart' is similar to 'rhs' except it effectively calls FloatTools:-rhs directly, therefore bypassing the overload mechanism.  The second call to 'decimalpart below' will raise a type-mismatch error.

$\mathrm{decimalpart}\left(3.14\right)$

$0.14$

$\mathrm{decimalpart}\left(x^2-1=y^2\right)$

Error, (in decimalpart) invalid input: rhs expects its 1st argument, f, to be of type float, but received x^2-1 = y^2

The error above is expected because we are calling the local 'rhs' method, but we actually want the top-level implementation for equations.  To reference the 'rhs' command within the package definition in a way that will do the type matching, use the 'overload' command to define a new function, and use that new function where appropriate. The example above defines 'RHS' to use internally for this reason. The alternate implementation of 'decimalpart', called 'alt_decimalpart', does not raise an exception when given non-float input.

$\mathrm{alt\_decimalpart}\left(3.14\right)$

$0.14$

$\mathrm{alt\_decimalpart}\left(x^2-1=y^2\right)$

$y^2$

In this section we will look at two ways of defining how element-wise operations can work on a given object.

1. Overload the ~ operator:

In this method the object exports a procedure named `~`.  All element-wise operations involving objects of this type will be dispatched through this procedure.  Since the data is a container, the implementation simply unpacks the object data from each of the arguments and then calls the global element-wise operator, :-`~`.

$\mathrm{unprotect}\left('\mathrm{Obj}'\right)$

module Obj() option object;
  export data, `~`;
  data := <1,2;3,4>;
  `~` := proc()
       local newargs, operation, i;
       operation := op(procname);

       newargs := seq(`if`(i::thismodule,i:-data,i),i=args);
       return :-`~`[operation](newargs);
  end;
end module:

$\mathrm{`~`}\left[\mathrm{`+`}\right]\left(\mathrm{Obj}\&comma;\mathrm{`\; \$`}\&comma;⟨⟨1|1⟩\&comma;⟨2|2⟩⟩\right)$

$\left[\begin{array}{cc}2& 3\\ 5& 6\end{array}\right]$

$\mathrm{`~`}\left[\mathrm{`*`}\right]\left(⟨⟨10|10⟩\&comma;⟨10|10⟩⟩\&comma;\mathrm{`\; \$`}\&comma;\mathrm{Obj}\right)$

$\left[\begin{array}{cc}10& 20\\ 30& 40\end{array}\right]$

2. Overload the index operation `?[]`, and the upperbound method:

In this case the data held by the object is a list of vectors.  It is not in a format that is able to be passed to the top-level tilde command.  Rather than overload `~`, and because indexing is already defined for this object via `?[]`, adding `upperbound` allows Maple to query the size of the data so it can properly perform the element-wise operations for the object.

$\mathrm{unprotect}\left('\mathrm{Obj2}'\right)$

module Obj2() option object;
  export `?[]`, upperbound, data;
  data := [<1,2>, <3,4>];
  `?[]` := proc(me,idx::[posint,posint])
       me:-data[idx[1]][idx[2]];
  end proc;
  upperbound := proc(me,dim:=NULL)
      if dim = NULL then
          op(map(:-upperbound,me:-data));
      else
          :-upperbound(me:-data[dim],1);
      end if;
  end proc;
end module:

$\mathrm{Obj2}\left[2,1\right]$

$3$

$\left[\mathrm{upperbound}\left(\mathrm{Obj2}\right)\right]$

$\left[2\&comma;2\right]$

$\mathrm{`~`}\left[\mathrm{`+`}\right]\left(\mathrm{Obj2}\&comma;\mathrm{`\; \$`}\&comma;⟨⟨1|1⟩\&comma;⟨2|2⟩⟩\right)$

$\left[\begin{array}{cc}2& 3\\ 5& 6\end{array}\right]$

$\mathrm{`~`}\left[\mathrm{`*`}\right]\left(⟨⟨10|10⟩\&comma;⟨10|10⟩⟩\&comma;\mathrm{`\; \$`}\&comma;\mathrm{Obj2}\right)$

$\left[\begin{array}{cc}10& 20\\ 30& 40\end{array}\right]$