This is for my understanding (and the proper use of Maple terms)

?simplify refers to them (sqrt in this case) as procedures

simplify[sqrt](16^(3/2));
                               64

`simplify/sqrt`(16^(3/2));
                               64

simplify(16^(3/2), sqrt);
                               64

?combine calls them (this time exp and trig) names of options

combine(exp(sin(a)*cos(b))*exp(cos(a)*sin(b)),[trig,exp]);#why the list?
                        exp(sin(a + b))

combine(exp(sin(a)*cos(b))*exp(cos(a)*sin(b)),trig,exp);#no list
                        exp(sin(a + b))

combine[trig](exp(sin(a)*cos(b))*exp(cos(a)*sin(b)));#no exp required?!?
                        exp(sin(a + b))

(`combine/exp`@`combine/trig`)(exp(sin(a)*cos(b))*exp(cos(a)*sin(b)));
                        exp(sin(a + b))

If the terms command options and command procedures can be used interchangeably, how does evalf[4](...) fit into this scheme? 

Is there a special Maple term for the construct "proc[n]" where proc is a procedure/command name and n is not a name but of type numeric?

I want to make from a procedure call a single argument function that can be used in function composition.

To illustrate this with a simple example, below the function pow[3] performs a cube operation

pow[3]:=x-> `^`(x,3):
(evalf[4]@pow[3]@sin)(Pi/6)
                             0.1250

To make the use of pow a bit more generic, I though about doing definitions for other powers in a loop with an inline assignement

for i from -1/2 to 5 by 1/2 do (power[i]:=x-> `^`(x,i)) end do;

This does not work because the i in the rigthhand side of power[i]:=x-> `^`(x,i) does not evaluate to the acutal value of the loop counter. I tried eval and evaln without success. How do I get full evaluation of the inline assignement?

Both uses of evalf

evalf(Pi, 20);
evalf[20](Pi);

work, but only the latter is documented. Is there a reason behind (maybe historical)? Any reason not to use evalf(...,n) any more? I am also reluctant to update old worksheets if there is no need for the indexed version.

Only for my understanding. In the following I need to use expand to apply division to list elements when the divisor is a name:

Does in this case automatic simplification make a difference between numbers and names? (Probably this is explained somewhere.)

Download div_of_list.mw

I cannot figure out which operand(?) is substituded here

subs(1 = 2, a*b);
                              2  2
                             a  b 

Same for

subs(1 = 3, a + b);
                           3 a + 3 b

but

subs(1 = 2, a/b);
                                2
                               a 
                               --
                               b 

subs(1 = 3, a - b);
                            3 a - b

Is this by design?