!set match_random := 2 ;;

/*
// sdfsdf 
/* /*
*/

*/

(* 


 *)


1 + 2 ;;

1.0 + 2.0 ;;

1.0 + 3 ;;

false ;;

true ;;

false && true ;;

false || true ;;

1 < 2 ;;

3 >= 1 ;;

10 == 11 ;;

10 != 10 ;;
10 <> 10 ;;
10 ~= 11 ;;

"toto" ;;

"helloworld" ;;

"hello" + "world" ;;

((((4 + 3) + "hello... ") + 4) + 3) ;;

4 + 3 + "hello... " + (4 + 3) ;;

`toto ;;

`roi ;; `dame ;; `valet ;;

`roi == `roi ;;

`dame == `valet ;;

// roi ;;

x := 3 ;;

x ;;

<undef> ;;

x * x ;;

x + 2 ;;

x := 2 ; 

x * x ;;

x ;;

x ** 7 ;;

fun f(a,b) = 2 * a + b ;;

f(3,4) ;;

fun f(a,b) = x * a + b ;;

f(3,4) ;;

x := 3 ;;

f(3,4) ;;



fun fact(n) = if n <= 0 then 1 else n * fact(n-1) fi ;;

fact(5) ;;

fun ite(c,t,e) =
  if c
  then t
  else e fi
;;



f(2)(3) ;;

g := f(2) ;;

g(3) ;;

x := 0 ;;

fun addToX(i) = (
  x := x + i
) ;;

iter(addToX, 10) ;;

x ;;


fun skel(op,n) =
  if n <= 0
  then 1
  else op(n, skel(op,n-1)) fi ;;

fact := skel(mult) ;;

fun fact(x) = skel(mult)(x) ;;

fact := (\x.(skel(mult)(x))) ;;

fact(5) ;;

// http://www.spatial-computing.org/mgs/supmeca


x := 0 ;;


x := 1 ;;

fun s(x) = 1 + x ;;

s := (\x.(1+x)) ;;

(\x.(1+x))(2) ;;
*/



trans T = { x => x + 1 } ;;

trans T = { 0 => 2; 3 => 1; 2 => 0 } ;;

trans T = { 1 => 2;} ;;

trans T = { 3 => 2; 3 => 1 } ;;

trans T = { x / (x % 2 == 0) => x + 1 } ;;

trans T = {

  x / int(x) => x + 1 ;
    
  x / float(x) => x - 2 ;

} ;;

trans T = {
  x => if   int(x)   then x+1
       elif float(x) then x-2 fi
} ;;

trans T = { x:int => x + 1 } ;;

fun test(x) = (x >= 4) ;;
trans T = { x:test => x + 1 } ;;

trans T = { x:test => <undef> } ;;

trans map[f=succ] = { x => f(x) } ;;

s := (3.,2,4.,5,2.,6,4.) ;;

T(s) ;;

fun test(x) = (x % 2 == 0) ;;
T(s) ;;

map[f = mult(10)](s) ;;

map(s) ;;

map[iter=5](s) ;;

trans T = {

  //x:qright / (right(x) % 2 == 0) => x+1;
  x, y => x+1, y+1;

} ;;

s := (3.,2,4.,5,2.,6,4.) ;;

T(s) ;;

trans T = {

  x, y / x > y => y, x;
  
  x, y / x == y => x;

} ;;

T[fixpoint](s) ;;


s ;;

a := [| 3.,2,4.,5,2.,6,4. |] ;;

trans T = {
  x / (x >= 4) => <undef>
} ;;

T(s) ;;
T(a) ;;

map[f=(\x.(<undef>))]((1,2,3)) ;;