MaplePrimes - answers and comments on Question, Objects in Maple 16

Objects in Maple

dohashi — Tue, 15 May 2012 22:03:46 Z

1. This is how you initialize the newly created object. See the ?ModuleCopy help page.

2. Maple allows objects to override existing global routines, so you could write an object that has its own "sin" routine. That routine will be called when the object is passed as an argument to the global routine.

> o := module()
>     option object;
>
>     export sin::static;
>
>     sin := proc() print( "method override" ); end;
> end;
                              o := Object<<47288987569152>>

>
> sin( o );
                                    "method override"

See ?object,methods for more information

Darin

-- Kernel Developer Maplesoft

Two arguments

John May — Tue, 15 May 2012 22:22:36 Z

In (1), ModuleApply appear to be passing two arguments, but in fact it is passing all of the arguments it received via the special variable _passed (aka args).

(**) foo := proc() print(_passed); end proc: # foo passes all its arguments to print
(**) foo(1,2,3,4);
                                  1, 2, 3, 4
(**) foo(blah);
                                     blah

John

Method name lookup in Maple16

gwpatrick — Tue, 15 May 2012 23:48:00 Z

>See ?object,methods for more information

What it says:

>To call a method that is exported by an object, use the standard
>function calling syntax with the object as an argument. When
>evaluating the function call, Maple will search the arguments, left to
>right, for an object that exports a method with the same name as the
>specified function. The first object found with a matching method
>will have its method called with the given arguments.

What it might better say:

>To call a method that is exported by an object,
** you can use the name qualified by that object and :-, as in obj:-method.
** If you omit the obj:- qualifier, then Maple will resolve the call as
** follows: first,
> Maple will search the arguments, left to
>right, for an object that exports a method with the same name as the
>specified function. The first object found with a matching method
>will have its method called with the given arguments.
** If no such method is found, then Maple will search for a global
** procedure with the same name.

This is consistent with:

module AAAA() option object;
export foo := proc() print("AAAA foo") end proc; end module;
module BBBB() option object;
export foo := proc() print("BBBB foo") end proc; end module;
foo:=proc() print("GLOBAL foo") end proc;

foo(AAAA);                      #"AAAA foo"
foo(BBBB);                      #"BBBB foo"
foo();                          #"GLOBAL foo"
foo(AAAA,BBBB);                 #"AAAA foo"
foo(BBBB,AAAA);                 #"BBBB foo"
AAAA:-foo(BBBB);                #"AAAA foo"
BBBB:-foo(AAAA);                #"BBBB foo"
foo(AAAA,BBBB);                 #"AAAA foo"
foo(BBBB,AAAA);                 #"BBBB foo"
foo(1,2,3,AAAA);                #"AAAA foo"
BBBB:-foo(1,2,3,AAAA);          #"BBBB foo"

A question is, in the case of nested classes where the method is
called unqualified, what does Maple do? Search from the innermost
outward (an enclosing class could have foo, and there could be a
global foo)? Also, can one partially qualify a name and then it stops
the search at the partial qualification?

BTW, in ?:= it says

>The ":-" operator can also be used as a unary, prefix operator, whose
>sole operand is a symbol. The expression :-sym evaluates to the
>global instance of sym, even if there is a local binding for sym in
>scope.

but

:=foo(AAAA) #"AAAA foo"

and it didn't get the global one as apparently promised by ?:=

There is a difference between calling a method

dohashi — Wed, 16 May 2012 17:24:11 Z

There is a difference between calling a method using the standard function call syntax and using :-.

> module A() option object;
>     export foo::static := proc() print( 'procname'( _passed ) ) end proc;
>     export ModulePrint := proc() 'A' end;
> end module:
>
> module B() option object;
>     export foo::static := proc() print( 'procname'( _passed ) ) end proc;
>     export ModulePrint := proc() 'B' end;
> end module:
>
> foo := proc() print( 'procname'( _passed ) ) end proc:
>
> foo( A );
                                        A:-foo(A)

> foo( B );
                                        B:-foo(B)

> foo( A, B );
                                      A:-foo(A, B)

> foo( B, A );
                                      B:-foo(B, A)

Notice how the following two calling sequences differ:

> foo( A, B );
A:-foo(A, B)

> A:-foo(B);

A:-foo(B)

In the first case, the object A is passed as a parameter into A:-foo, in the second case it is not. With objects, methods are generally declared static. Thus if the methods are going to modify the object (A in this case), it needs to be passed in as a parameter.

So foo( A, B ) and A:-foo( B ) are very different.

I'm not sure what you mean by "nested objects". When scanning a parameter sequence, Maple is looking for objects, anything else (like a list containing objects) is not an object.

With respect to :-, ( I think you accidently wrote := ), :- is used to specify which package a name is found in. When used as a unary prefix operator, it specifies the global, top level name. This is generally used when there exists a module or package procedure that would be used if the :- was not present. For an object method, the global name is the name that is mapped to the object method, so :-foo( A ) and foo( A ) are the same, assuming foo is not overloaded. When foo is overloaded, then :- can be used to access the global foo, which is the foo that maps onto the object method.

> module A() option object;
>     export foo := proc() print( 'procname'( _passed ) ) end proc;
>     export ModulePrint := proc() 'A' end;
> end module:
>
> module fooExporter()
>     option package;
>
>     export foo := proc() print( 'procname'( _passed ) ) end proc;
> end:
>
> foo( A );
                                        A:-foo(A)

> :-foo( A );
                                        A:-foo(A)

>
> fooExporter:-foo( A );
                                   fooExporter:-foo(A)

> with( fooExporter );
                                          [foo]

>
> foo( A );
                                   fooExporter:-foo(A)

> :-foo( A );

A:-foo(A)

Darin

-- Kernel Developer Maplesoft