FL is a pure functional language based on combinatorial logic.

The
language introduces an algebra over programs (a set of algebraic
identities between functional expressions) for reasoning formally about
programs, so that one may find simpler equivalent programs (both at
design and at compile times); programs are easily combined, so that new
programs are obtained in a simple and elegant way; great advantages in
style and efficiency of program development are achieved.

**Primitive objects
**
characters, numbers and truth values

**Expressions
**
primitive objects, functions, applications and sequences

**Sequences**

expressions separated by commas and contained within a pair of
angle brackets: <5, fun>

**The application expression
**exp1:exp2 applies the function resulting from
the evaluation of exp1 on the argument resulting from the evaluation of
exp2.

**
Binary functions
**
can also be used in infix form: +:<1,3> = 1 + 3 =
4

**Application associates to left:
**
f:g:h = (f:g):h

**Application binds stronger than composition:
**
f:g ~ h = (f:g) ~ h

**FL combining forms and functions:
The construction combining form CONS
allows to apply a sequence of functions to an argument producing the
sequence of applications:
CONS:< f1,...,fn >:x = [f1,...,fn]:x = <
f1:x,...,fn:x >**

E.g. CONS:<+,->, written also [+,-], when applied to the
argument <3,2> gives the sequence of applications:

[+,-]:<3,2> =
<+:<3,2>,-:<3,2>> = <5,1>;

**The apply-to-all combining form AA
**applies a
function to a sequence of arguments giving a sequence of applications:
AA:f:< x1,...,xn > = < f:x1,...,f:xn >;

**The identity function ID
**returns
its argument unchanged: ID:x = x;

**The constant function K
**is evaluated,
for whatever x2, as: K:x1:x2 = x1;

**Binary composition ~ of functions
**is
defined as (f ~ g):x = f:(g:x);

**N-ary composition COMP of functions
**is
also allowed: COMP:< f,h,g >:x = (f ~ h ~ g):x = f:(h:(g:x));

**The conditional form
**IF:< p,f,g >:x is evaluated as follows:

IF:< p,f,g >:x = f:x if p:x = TRUE g:x if p:x = FALSE

**The insert right and insert left combining forms (INSR and INSL)
**allow
to apply a binary function on a sequence of arguments of any length:
INSR:f:< x1,x2,...,xn > = f:< x1, INSR:f:< x2,...,xn > >

INSL:f:< x1,...,xn-1,xn > = f:< INSL:f:< x1,...,xn-1 >, xn >,

where INSR:f:< x > = INSL:f:< x > = x

**The catenate function CAT
**appends any number of input sequences creating
a single output sequence: CAT:<< a,b,c >,< d,e >,...,< x,y,z >> = <
a,b,c,d,e,...,x,y,z >

**The distribute right and distribute left functions
(DISTR, DISTL)
**generate a sequence of pairs:

DISTR:<< a,b,c >, x> = << a,x >, < b,x >, < c,x >>

DISTL:< x,< a,b,c >> = << x,a >, < x,b >, < x,c >>