index<--

# Bee Functions

Bee is a functional programming language. Bee enable functional programming using lambda expressions. These are arithmetic expressions that can make a computation and return a result.

## Lambda expressions

A lambda expressions can have parameters and results. Lamda expressions can be used to create functions. Lamda expressions do not have a local scope.

#### Syntax:

``````# declaration of Lambda expressns
new name := λ(p1 ∈ Type,...) => (expression) ∈ ResultType;
``````

#### Example:

``````** define lambda expression
new exp := λ(x,y ∈ Z) => x^y ∈ Z;

** use introspection
print type(exp); -- L

** use the lambda expression
new z := 2 * exp(2,3);

** verify the result
expect z = 16; -- will pass
print z;
``````

#### Properties:

Lambda Expressions...

• are similar to mathematical functions;
• can be used in other expressions;
• can be used as arguments for call-back;
• can be created from a rule as a result;
• can be assigned to variables of type: L

restrictions:

• have no internal states;
• have deterministic result;
• do not have side-effects;
• do not modify external states;

result:

• lambda expressions can produce one single result;
• result type must be specified but not the result name;
• result is temporary and can be used in other expressions;

## Lambda type

Lambda expressions have a special type: "L", that is a reference. This type can be used to define variables, collection elements or parameters that require a lambda expression;

#### Demo use-case

In next example we create a dictionary of expressions then we call every expression in the dictionary by string ID. This is a trick useful to parse a specific formula that comes as a string. You can use this trick for example to implement custom domain specific expressions.

``````
** instantiate 3 Lambda expressions
new gt := λ(x, y ∈ Z) => (x > y) ∈ L;
new lt := λ(x, y ∈ Z) => (x < y) ∈ L;
new eq := λ(x, y ∈ Z) => (x = y) ∈ L;

** define a sub-type, dictionary of rules
type Dic: {[A]:L} <: Map;

** define a hash map of expressions
new dic := {'gt':gt,'lt':lt,'eq':eq} ∈ Dic;
** call 3 rules in very unusual way
print dic['gt'](3,1); -- 1
print dic['lt'](1,2); -- 1
print dic['eq'](2,2); -- 1
``````

## Call-back functions

Lambda expressions become call-back functions when used as arguments for specific rules that require lambda expressions. The function is executed later in the rule. Lambda function signature is required to define the parameter.

#### Example

``````
rule foo(a1, a2 ∈ N, xp: λ(x,y ∈ N) => R) => (r ∈ Type):
** prepare the result
let r := xp(a1,a2);
return;

rule main:
** call foo using anonymous expression
print foo(2,3,(x,y)=> x^y); -- 8.0
print foo(2,3,(x,y)=> x*y); -- 6.0
print foo(2,3,(x,y)=> x/y); -- 1.5
return
``````