The :- Operator - Maple Programming Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Programming : Modules : colondash

The :- Operator

 

Calling Sequence

Description

Examples

Calling Sequence

m:-e

:-e

Description

• 

The binary member selection operator, :, is used to name module exports outside the scope in which they are defined. It is a non-commutative, left-associative operator. The first (left) operand is evaluated and must evaluate to a module. The second (right) operand is not evaluated and must be a symbol exported by the module to which the first operand evaluates.

  

Important: It is a syntax error for the second operand of the : operator to be other than a symbol. It is a runtime error for the first operand of the : operator to evaluate to anything other than a module.

• 

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.

• 

The fact that the second operand of the : operator is not evaluated can be problematic when you want to construct the member selection expression dynamically using an export name that is provided at runtime. For this reason, the indexing operation () has been overloaded in such a way that, for a module m, the expression m[e] evaluates to the member selection expression m:f after first evaluating the expression e, resulting in f.

• 

Since the subexpression e in m[e] is evaluated, it is often necessary to use unevaluation (right) quotes when accessing module members using this syntax, with e a name. Moreover, if a local name with the same external representation is in scope, the unary prefix form of the : operator must be used (assuming that the index is supposed to be a global name). For example, to call the exported procedure order of the numtheory package, use numtheory[':-order']. (Since the numtheory package is implemented as a module, you could equally use numtheory:-order, but the latter syntax works only with module-based packages.)

Examples

mmoduleexporte;e2end module:

m:-e

2

(1)

Since numeric constants are not symbols, the command m:-3; would give a syntax error. Similarly, an error results from the following, since m does not export the symbol f.

m:-f

Error, module does not export `f`

StringTools:-Reverseabc

cba

(2)

SSimpleStacka,b,c:

S:-pop;S:-pop;S:-pop

c

b

a

(3)

In the following example, to call the exported procedure order from the numtheory package, you must use the unary prefix form of the  : operator.

withnumtheory:

orderseriesⅇs,s

Error, invalid input: numtheory:-order expects its 1st argument, n, to be of type integer, but received series(1+1*s+1/2*s^2+1/6*s^3+1/24*s^4+1/120*s^5+O(s^6),s,6)

:-orderseriesⅇs,s

6

(4)

rRecord'a'=2,'b'=3,'c'=4:

r:-a,r:-b,r:-c

2,3,4

(5)

slotsseqre,e=a,b,c

slots:=2,3,4

(6)

Prefix form of :- for writing an export that uses and shadows a pre-defined global symbol. Note its use on both QUAT and `+`.

Q := module()
 export    `+`;
 `+` := proc( a, b )
    local    answer;
    if andmap(type,[a,b],'specfunc( algebraic, :-QUAT )' )
     and map( nops, [ a, b ] ) = [ 4, 4 ] then
      answer := ':-QUAT'( seq( op( i, a ) + op( i, b ), i = 1 .. 4 ) );
      if andmap( Testzero, [op]( 2 .. 4, answer ) ) then
        op( 1, answer )
      else
        answer
      end if
    elif type(a,'specfunc( algebraic, :-QUAT )' ) then
      procname( a, ':-QUAT'( b, 0, 0, 0 ) )
    elif type(b,'specfunc( algebraic, :-QUAT )' ) then
      procname( ':-QUAT'( a, 0, 0, 0 ), b )
    else
      # Call the global `+`
      :-`+`( a, b )
    end if;
  end proc;
end module:

useQin'QUAT'1,2,3,4+'QUAT'1,2,3,4+x;'QUAT'1,2,3,4+'QUAT'1,2,4,3y+x;2x+yend use

2x+y

(7)

These examples illustrate the need to use unevaluation quotes and the prefix form of the :- operator when accessing package exports. The quotes are always necessary, since you have no control over what is assigned at the top level. The use of a :- prefix is needed only when there is a local name that provides a conflicting binding.

midpoint2:

p1 := proc(a, b)
    local    midpoint;
    midpoint := 3;
    2 * student[ ':-midpoint' ]( a, b ) / midpoint
end proc:

p2 := proc(a, b)
    local    midpoint;
    midpoint := 3;
    2 * student[ 'midpoint' ]( a, b ) / midpoint
end proc:

p3 := proc(a, b)
    local    midpoint;
    midpoint := 3;
    2 * student[ :-midpoint ]( a, b ) / midpoint
end proc:

Of these three routines, only p1 operates correctly.

p11,2,3,4

43,2

(8)

p21,2,3,4

23studentmidpoint1,2,3,4

(9)

p31,2,3,4

23student21,2,3,4

(10)

See Also

global

local

module

module[export]

procedure

use

uses

with

 


Download Help Document

Was this information helpful?



Please add your Comment (Optional)
E-mail Address (Optional)
What is ? This question helps us to combat spam