Sollya User's Manual

Name:

proc defines a Sollya procedure

Usage:

proc(formal parameter1, formal parameter2,..., formal parameter n) { procedure body } : void -> procedure proc(formal parameter1, formal parameter2,..., formal parameter n) { procedure body return expression; } : void -> procedure proc(formal list parameter = ...) { procedure body } : void -> procedure proc(formal list parameter = ...) { procedure body return expression; } : void -> procedure

Parameters:

formal parameter1, formal parameter2 through formal parameter n represent identifiers used as formal parameters
formal list parameter represents an identifier used as a formal parameter for the list of an arbitrary number of parameters
procedure body represents the imperative statements in the body of the procedure
expression represents the expression proc shall evaluate to

Description:

The proc keyword allows for defining procedures in the Sollya language. These procedures are common Sollya objects that can be applied to actual parameters after definition. Upon such an application, the Sollya interpreter applies the actual parameters to the formal parameters formal parameter1 through formal parameter n (resp. builds up the list of arguments and applies it to the list formal list parameter) and executes the procedure body. The procedure applied to actual parameters evaluates then to the expression expression in the return statement after the procedure body or to void, if no return statement is given (i.e. a return void statement is implicitly given).
Sollya procedures defined by proc have no name. They can be bound to an identifier by assigning the procedure object a proc expression produces to an identifier. However, it is possible to use procedures without giving them any name. For instance, Sollya procedures, i.e. procedure objects, can be elements of lists. They can even be given as an argument to other internal Sollya procedures. See also procedure on this subject.
Upon definition of a Sollya procedure using proc, no type check is performed. More precisely, the statements in procedure body are merely parsed but not interpreted upon procedure definition with proc. Type checks are performed once the procedure is applied to actual parameters or to void. At this time, if the procedure was defined using several different formal parameters formal parameter 1 through formal parameter n, it is checked whether the number of actual parameters corresponds to the number of formal parameters. If the procedure was defined using the syntax for a procedure with an arbitrary number of parameters by giving a formal list parameter, the number of actual arguments is not checked but only a list formal list parameter of appropriate length is built up. Type checks are further performed upon execution of each statement in procedure body and upon evaluation of the expression expression to be returned.

Procedures defined by proc containing a quit or restart command cannot be executed (i.e. applied). Upon application of a procedure, the Sollya interpreter checks beforehand for such a statement. If one is found, the application of the procedure to its arguments evaluates to error. A warning is displayed. Remark that in contrast to other type or semantic correctness checks, this check is really performed before interpreting any other statement in the body of the procedure.
Through the var keyword it is possible to declare local variables and thus to have full support of recursive procedures. This means a procedure defined using proc may contain in its procedure body an application of itself to some actual parameters: it suffices to assign the procedure (object) to an identifier with an appropriate name.
Sollya procedures defined using proc may return other procedures. Further procedure body may contain assignments of locally defined procedure objects to identifiers. See var for the particular behaviour of local and global variables.
The expression expression returned by a procedure is evaluated with regard to Sollya commands, procedures and external procedures. Simplification may be performed. However, an application of a procedure defined by proc to actual parameters evaluates to the expression expression that may contain the free global variable or that may be composed.

Example 1:

   > succ = proc(n) { return n + 1; };
   > succ(5);
   6
   > 3 + succ(0);
   4
   > succ;
   proc(n)
   {
   nop;
   return (n) + (1);
   }

Example 2:

   > add = proc(m,n) { var res; res := m + n; return res; };
   > add(5,6);
   11
   > add;
   proc(m, n)
   {
   var res;
   res := (m) + (n);
   return res;
   }
   > verbosity = 1!;
   > add(3);
   Warning: at least one of the given expressions or a subexpression is not correctly typed
   or its evaluation has failed because of some error on a side-effect.
   error
   > add(true,false);
   Warning: at least one of the given expressions or a subexpression is not correctly typed
   or its evaluation has failed because of some error on a side-effect.
   Warning: the given expression or command could not be handled.
   error

Example 3:

   > succ = proc(n) { return n + 1; };
   > succ(5);
   6
   > succ(x);
   1 + x

Example 4:

   > hey = proc() { print("Hello world."); };
   > hey();
   Hello world.
   > print(hey());
   Hello world.
   void
   > hey;
   proc()
   {
   print("Hello world.");
   return void;
   }

Example 5:

   > fac = proc(n) { var res; if (n == 0) then res := 1 else res := n * fac(n - 1); return res; };
   > fac(5);
   120
   > fac(11);
   39916800
   > fac;
   proc(n)
   {
   var res;
   if (n) == (0) then
   res := 1
   else
   res := (n) * (fac((n) - (1)));
   return res;
   }

Example 6:

   > myprocs = [| proc(m,n) { return m + n; }, proc(m,n) { return m - n; } |];
   > (myprocs[0])(5,6);
   11
   > (myprocs[1])(5,6);
   -1
   > succ = proc(n) { return n + 1; };
   > pred = proc(n) { return n - 1; };
   > applier = proc(p,n) { return p(n); };
   > applier(succ,5);
   6
   > applier(pred,5);
   4

Example 7:

   > verbosity = 1!;
   > myquit = proc(n) { print(n); quit; };
   > myquit;
   proc(n)
   {
   print(n);
   quit;
   return void;
   }
   > myquit(5);
   Warning: a quit or restart command may not be part of a procedure body.
   The procedure will not be executed.
   Warning: an error occurred while executing a procedure.
   Warning: the given expression or command could not be handled.
   error

Example 8:

   > printsucc = proc(n) { var succ; succ = proc(n) { return n + 1; }; print("Successor of",n,"is",succ(n)); };
   > printsucc(5);
   Successor of 5 is 6

Example 9:

   > makeadd = proc(n) { var add; print("n =",n); add = proc(m,n) { return n + m; }; return add; };
   > makeadd(4);
   n = 4
   proc(m, n)
   {
   nop;
   return (n) + (m);
   }
   > (makeadd(4))(5,6);
   n = 4
   11

Example 10:

   > sumall = proc(L = ...) { var acc, i; acc = 0; for i in L do acc = acc + i; return acc; };
   > sumall;
   proc(L = ...)
   {
   var acc, i;
   acc = 0;
   for i in L do
   acc = (acc) + (i);
   return acc;
   }
   > sumall();
   0
   > sumall(2);
   2
   > sumall(2,5);
   7
   > sumall(2,5,7,9,16);
   39
   > sumall @ [|1,...,10|];
   55

See also: return, externalproc, void, quit, restart, var, @, bind, getbacktrace, error

Go back to the list of commands