Function Objects

The type core.Fn<R, ...> represents a pointer to a function, optionally with a bound first parameter. Basic Storm has custom syntax for this type.

The parameters to the type dictate the signature of the function to be called. The first parameter is the return value of the function (which may be void). Any remaining parameters are the types of the formal parameters to the function. These may not be void. Below are a few examples to illustrate the idea:

  1. core.Fn<void> denotes a pointer to a function with zero parameters that returns nothing.
  2. core.Fn<core.Str, core.Nat> denotes a pointer to a function that accepts a core.Nat and returns a core.Str.
  3. core.Fn<void, core.Nat, core.Int> denotes a pointer to a function that accepts a core.Nat and a core.Int and returns nothing.

The member call is used to invoke the function pointed to. The signature of the call member thus corresponds to the parameters to the type. In the examples above, the call has the following signatures (the this parameter is omitted for clarity):

  1. void call()
  2. core.Str call(core.Nat)
  3. void call(core.Nat, core.Int)

The Fn type may also contain a pointer to a class or an actor that should be used as the first parameter of the call. Because of this, the signature of the class that is pointed to differ from the signature of the call function. For example, the function pointer in case 1 above may call a function that accepts a Str as a formal parameter, but the Str is stored inside the Fn object itself.

Even though the Fn type is limited to binding classes or actors as the first parameter, this is enough to implement function objects with arbitrarily complex state. This is, for example, done to implement lambda functions in Basic Storm.

The Fn type does not have a constructor. Rather, it needs to be created by the language in use, or from the member pointer in core.lang.Function.