Sollya User's Manual

Name:

bind partially applies a procedure to an argument, returning a procedure with one argument less

Usage:

bind(proc, ident, obj) : (procedure, identifier type, any type) -> procedure

Parameters:

proc is a procedure to be partially applied to an argument
ident is one of the formal arguments of proc
obj is any Sollya object ident is to be bound to

Description:

bind allows a formal parameter ident of a procedure proc to be bound to an object obj, hence proc to be partially applied. The result of this curryfied application, returned by bind, is a procedure with one argument less. This way, bind permits specialization of a generic procedure, parameterized e.g. by a function or range.
In the case when proc does not have a formal parameter named ident, bind prints a warning and returns the procedure proc unmodified.
bind always returns a procedure, even if proc only has one argument, which gets bound to ident. In this case, bind returns a procedure which does not take any argument. Hence evaluation, which might provoke side effects, is only performed once the procedure gets used.
If bind is used on a procedure with an arbitrary number of arguments, no check is performed whether the procedure actually has a parameter of name ident. bind returns a procedure with an arbitrary number of arguments whose argument has the same name as the original procedure proc. That returned procedure binds ident to obj and then runs proc within this context, applying it to its original argument. The execution of bind fails for procedures with an arbitrary number of arguments if the original procedure's argument has the same name as ident. In this case, the procedure is returned unmodified.

Example 1:

   > procedure add(X,Y) { return X + Y; };
   > succ = bind(add,X,1);
   > succ(5);
   6
   > succ;
   proc(Y)
   {
   nop;
   return (proc(X, Y)
   {
   nop;
   return (X) + (Y);
   })(1, Y);
   }

Example 2:

   > procedure add(X,Y) { return X + Y; };
   > succ = bind(add,X,1);
   > five = bind(succ,Y,4);
   > five();
   5
   > five;
   proc()
   {
   nop;
   return (proc(Y)
   {
   nop;
   return (proc(X, Y)
   {
   nop;
   return (X) + (Y);
   })(1, Y);
   })(4);
   }

Example 3:

   > verbosity = 1!;
   > procedure add(X,Y) { return X + Y; };
   > foo = bind(add,R,1);
   Warning: the given procedure has no argument named "R". The procedure is returned unchanged.
   > foo;
   proc(X, Y)
   {
   nop;
   return (X) + (Y);
   }

Example 4:

   > procedure sum_times(l=...) { var s, i; s = 0; for i in l do s = s + i; return c * s; };
   > foo = bind(sum_times, c, 17);
   > foo;
   proc(l = ...)
   {
   var c;
   c = 17;
   return (proc(l = ...)
   {
   var s, i;
   s = 0;
   for i in l do
   s = (s) + (i);
   return (c) * (s);
   }) @ (l);
   }
   > foo(1, 2, 3);
   102