let imply v = match v with 
     (true,true)   -> true
   | (true,false)  -> false
   | (false,true)  -> true
   | (false,false) -> true;;

let imply v = match v with 
     (true,x)  -> x
   | (false,x) -> true;;

let equal c = match c with 
    (x,x) -> true
  | (x,y) -> false;;

let is_a_vowel c = match c with 
    'a' | 'e' | 'i' | 'o' | 'u' | 'y' -> true 
  | _ -> false ;;

let rec fib = function
    (0 | 1) as i -> i
  | i -> fib (i - 1) + fib (i - 2);;

match: func [block body]

; l'exemple est tiré de http://www.brool.com/index.php/pattern-matching-in-clojure et est très orienté lisp
compute: func [expr /local a b][ ; TODO: devrait forcer toute les vr en locales
	match expr [
		[a] [a]
		["add" a b] [(compute a) + (compute b)]
		["sub" a b] [(compute a) - (compute b)]
		["mul" a b] [(compute a) * (compute b)]
		["div" a b] [(compute a) / (compute b)]
	]
]
compute [3]
>> 3

compute ["add" 5 4]
>> 9

compute ["sub" ["add" ["mul" 6 7] 8] 5]
>> 45



imply: func [expr][
	match expr [
		[true x] [x]
		[false x] [true]
	]
]

imply [true false]
>> false
imply [true true]
>> true
imply [false false]
>> true
imply [false true]
>> true
imply [true 4]
>> 4

ident: func [expr][
	match expr [
		[x] ["one element"]
		[x x] ["identical"] ;;FIXME: si cette regle est placée apres la regle [x y] ca ne fonctionne plus!!!! 
		[x y] ["two different element"]
		[] ["empty"]
	]
]

ident [1 1]
>> "identical"
ident ["1" "1"]
>> "identical"
ident [1 2]
>> "two different element"
ident [0]
>> "one element"

factorial: func [expr][
	match expr [
		[0] [1]
		[x] [x * factorial x - 1]
	]
]

# let rec d(f, x) =
    match f with
    | Var y when x=y -> Int 1
    | Int _ | Var _ -> Int 0
    | Add(f, g) -> Add(d(f, x), d(g, x))
    | Mul(f, g) -> Add(Mul(f, d(g, x)), Mul(g, d(f, x)));;
val d : expr * string -> expr = <fun>
For example, the derivative of ax 2 +bx+c is:

# let a, b, c, x = Var "a", Var "b", Var "c", Var "x";;
val a : expr = Var "a"
val b : expr = Var "b"
val c : expr = Var "c"
val x : expr = Var "x"
# let f = Add(Add(Mul(Mul(a, x), x), Mul(b, x)), c);;
val f : expr =
  Add (Add (Mul (Mul (Var "a", Var "x"), Var "x"), Mul (Var "b", Var "x")),
   Var "c")
# d(f, "x");;
- : expr =
  Add
   (Add
     (Add (Mul (Mul (Var "a", Var "x"), Int 1),
       Mul (Var "x", Add (Mul (Var "a", Int 1), Mul (Var "x", Int 0)))),
     Add (Mul (Var "b", Int 1), Mul (Var "x", Int 0))),
   Int 0)

pattern-to-rule: func [block pattern action /local rule] [
	rule: copy []
	if (length? block) = (length? pattern) [
		forall block [
			index: index? block
			either (type? first block) = string! [append rule reduce [pattern/:index]] 
			[append rule reduce ['set pattern/:index type? first block]]
		]
		append rule reduce [to-paren action]
	]
	;probe rule
	rule
]

;version où match appelle parse avec une seule règle qui contient l'ensemble des patterns
match: func [block body /local rule res][
	rule: copy []
	foreach [pattern action] body [
		append rule pattern-to-rule block pattern append append copy [] [res:] action
		append rule '|
	]
	remove back tail rule
	print [">" mold block "match with" mold rule]
	probe parse block rule
	probe res
	return res
]
;version où match parse chaque pattern indivuellement
match: func [block body /local rule res ok?][
	rule: copy []
	block: to-block block
	foreach [pattern action] body [
		rule: pattern-to-rule block pattern append append copy [] [res:] action
		print [">" mold block "match with" mold rule]
		probe parse block rule
		;if ok? [print [">" mold block "match with" mold rule]]
	]
	return res
]

probe pattern-to-rule ["add" 5 4] [a] [a]
>> []
probe pattern-to-rule ["add" 5 4] ["add" a b] [print a + b]
>> ["add" set a integer! set b integer! (print a + b)]
probe pattern-to-rule["add" ["add" 1 1] 4] ["add" a b] [print a + b]
>> ["add" set a block! set b integer! (print a + b)]
probe pattern-to-rule [4] [a] [a]
>> [set a integer! (a)]

ident: func [expr][
	match expr [
		[x] ["one element"]
		[x x] ["identical"] 
		[x y] ["two different element"]
		[] ["empty"]
	]
]
ident [1 2]