// arithmetic expression

12*34+56*78 ;

// rule definitions

f() => [];
f(X) => X*X;
f(X, Y) => X*Y;
f(X, Y, Z) => X*Y+Z;

g(X) => 2*X;
h(X) => X/2. ;

// function applications

f();
f(123);
f(123, 456);
f(123, 456, 789);
f(g(h(123)));

// if-then-else

123<=456 ? 789*12.34 : 1/32.1e-1 ;


// rule definitions with matching

F(X, Y)=>[X, Y];

F([X, Y]) => [Y, X];
F([X, Y| Z]) => list(X, Y, Z);
F([X | Y]) => list(X, Y);
F(X) => [[X]];

F("foo", "bar");

F([1]);
F([1, 2]);
F([1, 2, 3]);

// anonymous functions

(X) => 5 ;

(X, Y) => X+Y;

(X) => (Y) => X+Y;


((X) => 5)(99);

((X, Y) => X+Y)(4, 5);

((X) => ((Y) => X+Y))(4)(5);


// rules with guards

gcd(0, y) => y;
gcd(x, y) => x <= y ? gcd(y-x, x);
gcd(x, y) => gcd(y, x);

gcd(54, 81);

sum2([], _) => [];
sum2(_, []) => [];
sum2([a|x],[b|y])=> [a+b | sum2(x, y)];

sum2([3, 4, 5], [6, 7, 8]);


filter([], _) => [];

filter([B | X], A) =>
    divides(A, B)?
	     filter(X, A)
      : [B |$ filter(X, A)];

filter([2, 3, 4, 5, 6], 3);


zip([], Y) => Y;

zip(X, []) => X;

zip([A | X], [B | Y]) => [ A |$ [B |$ zip(X, Y)]];

zip([0, 2, 4, 6, 8], [1, 3, 5]);


n = from(0), prefix(24, zip(n, n));


unzip(X) => [every(2, X, 0), every(2, X, 1)];
 
unzip(range(1, 20));


// equational guards

X=3, X*X;

X=3, Y=4, X*Y;

X=3, Y=X*X, X+Y;

X=3, X=X+1, X*X;

f(X)=X*X, f(5);

f(X)=X*X, g(F)=F(F(4)), g(f);

f(X)=X*X, double(g)=(X)=>g(g(X)), double(f)(5);

[x, y | z] = quote(a, b, c, d), z;

f(X)= ([Y|Z]=X, rest(Z)), f([1,2,3]);

j(X) => [Y | Z] = X, j(Z);

j([])=>0;

j([1,2,3]);


// cyclic equation

fibs = [1, 1 |$ map(+, fibs, rest(fibs))];

prefix(20, fibs);


// recursive groups (letrec's) defining cyclic equations

{
a = 5;
b = 6; 
a+b} + 7;

prefix(24, 
  {
  a = [1 |$ b];
  b = [2 |$ a];
  a
  }
);

prefix(24, 
  {
  a = [1 |$ b];
  b = [2 |$ c];
  c = [3 |$ a];
  a
  }
);

prefix(24, 
  {
  f(X) = [1 |$ g(X)];
  g(X) = [2 |$ h(X)];
  h(X) = [3 |$ f(X)];
  f([])
  }
);