(define $seq-pat (pattern-function [$pat1 $pat2] (|. <cons pat (seq-pat pat1 pat2)> pat2)))

> (test (match-all {1 2 3 1 2 1 1} (multiset integer)
             [(seq-pat ,1 $xs) xs]))
{{2 3 2}}
> (test (match-all {1 2 3 1 2 1 1} (multiset integer)
             [(seq-pat ,1 <cons $x _>) x]))
{2 3 2}

boolean?
integer?
float?
char?
collection?
array?
hash?

(define $conss
  (pattern-function [$pat1 $pat2 $pat3]
    (loop $i [1 pat1] <cons pat2_i ...> pat3)))

(test (match-all {1 2 3 4 5} (list integer) [(conss $n $a _) [n a]]))

(test (match-all {1 2 3} (multiset something)
    [<cons $m
               <cons $n
                     $rest>>
         [m n rest]]))

{[1 2 {3}] [1 3 {2}] [2 1 {3 1 2}] [2 3 {1}] [3 1 {3 1 2 1 2}] [3 3 {1 1 2}] [3 1 {1 3 2}] [3 2 {1 3 1}]}

> (define $f (pattern-function [$xs] xs))
> (test (f $x))
(lambda [#1] ...)
> (test ((f $x) $x))
(lambda [#1] ...)
> (test (((f $x) $x) $x))
(lambda [#1] ...)

> (test +f)
Parse error at: "egison" (line 1, column 8):
unexpected "f"
expecting "_" or ")"
> (test -f)
Parse error at: "egison" (line 1, column 8):
unexpected "f"
expecting "_" or ")"
> (test *f)
#<primitive>
> (test /f)
#<primitive>

> (test [1 2 
  3])
[1 2 3]
> (test {1 2
  3})
{1 2 3}
> (test (+ 1 
  2))
3
> (test [| 1 2
Parse error at: "egison" (line 1, column 8):
unexpected "|"
expecting expression or "]"

> (test (generate-array [$x] [5] x))
[|1 2 3 4 5|]
> (test (generate-array $x [5] x))
[|1 2 3 4 5|]
> (test (generate-array $x 5 x))
Error: invalid generate-array expression
> (test (generate-array [$x] 5 x))
Error: invalid generate-array expression
> (test (generate-array [$x] [[5]] x))
[|1 2 3 4 5|]

(loop $i [1 {2 3 4} $n] ... _)
(loop $i [1 {3} _] ... _)
(loop $i [1 nats $n] ..._)

(loop $i [1 3] ... _) => (loop $i [1 {3} _] ... _)
(loop $i [1 $n] ..._) => (loop $i [1 (from (- 1 1)) $n] ..._)

(define $b-tree
  (lambda [$a]
    (algebraic-data-matcher
      {<leaf> <Node a [$left (b-tree a)] [$right (b-tree a)]>})))

(take 1 (match-all {1 @(map (+ 1 $) (repeat1 1))} (multiset integer) [<cons $n <cons ,n _>> n]))

(pattern-function [$a]
  (pattern-function [$b]
    <cons a b>))

(define $suit
  (algebraic-data-matcher
    (| <spade> <heart> <club> <diamond> )))

(define $suit
  (algebraic-data-matcher
    {<spade> <heart> <club> <diamond>}))

> (array-ref [|1 2 3|] 3)
(\C-c)

(define $str "テスト")

(test str)

> (define $mid-inf (lambda $n {n @(mid-inf (+ n 1)) (neg n)}))
> (define $l (mid-inf 1))
> (test (car (cdr l)))
2
> (test (rac (rdc l)))
-2
> (test (car (cdr l)))
1

> (define $s (pattern-function [$pat] pat))
> (define $t (pattern-function [$pat] pat))
> (test (match-all 1 integer [(s (t ,1)) <OK>]))
Unbound variable: t

$ egison test.egi
{<OK>}
Unbound variable: main

\<cons $x $xs>

(define $hamilton-path
  (pattern-function [$a]
    (& $g
       (let {[$n (size g)]}
         <cons <node (& a_1 $h_1) <cons (& a_2 $h_2) _> _>
               (loop $i (between 3 n)
                 <cons <node ,h_(- i 1) <cons (& a_i $h_i) _> _>
                       ...>
                 <cons <node ,h_n _ _>
                       <nil>>)>)
       )))

(define $hamilton-path
  (pattern-function [$a]
    (& $g
       <cons <node (& a_1 $h_1) <cons (& a_2 $h_2) _> _>
             (loop $i (between 3 (size g))
               <cons <node ,h_(- i 1) <cons (& a_i $h_i) _> _>
                     ...>
               <cons <node ,h_(size g) _ _>
                     <nil>>)>
       )))

(define $edge-table
  (relational-matcher "edge"
    {["from_id" itos stoi]
     ["to_id" itos stoi]}))

(define $edge-table
  (matcher
    {[<cons <edge ,$px ,$py> $> [edge-table]
      ; select * from edge where from_id = px and to_id = py                                                                                                                                                
      {[$tgt (match (pure-mysql (database-name tgt) (simple-select {"from_id to_id"} (table-name tgt) {["from_id" (itos px)] ["to_id" (itos py)]})) (list [integer integer])
               {[<nil> {}]
                [_ {tgt}]})]}]
     [<cons <edge ,$px $> $> [integer edge-table]
      ; select to_id from edge where from_id = px                                                                                                                                                           
      {[$tgt (map (lambda [$x] [(stoi x) tgt]) (pure-mysql (database-name tgt) (simple-select {"to_id"} (table-name tgt) {["from_id" (itos px)]})))]}]
     [<cons <edge $ ,$px> $> [integer edge-table]
      ; select from_id from edge where to_id = px                                                                                                                                                           
      {[$tgt (map (lambda [$x] [(stoi x) tgt]) (pure-mysql (database-name tgt) (simple-select {"from_id"} (table-name tgt) {["to_id" (itos px)]})))]}]
     [$ [something]
      {[$tgt {tgt}]}]
     }))

(take 1 (match-all {1 2 @(map (+ $ 1) nats)} (multiset integer) [<cons $n <cons ,n _>> n]))

type MatchClause = (EgisonExpr, EgisonExpr)
data EgisonPattern =
    WildCard
  | PatVar String
  | ValuePat EgisonExpr
  | PredPat EgisonExpr
  | CutPat EgisonExpr
  | NotPat EgisonExpr
  | AndPat [EgisonExpr]
  | ...
data MatchingTree =
    MAtom EgisonExpr ObjectRef WHNFData
  | MNode [PatternBinding] MatchingState

type PatternBinding = (Var, EgisonExpr)

type MatchClause = (EgisonPat, EgisonExpr)
data EgisonPattern =
    WildCard
  | PatVar String
  | ValuePat EgisonExpr
  | PredPat EgisonExpr
  | CutPat EgisonPat
  | NotPat EgisonPat
  | AndPat [EgisonPat]
  | ...
data MatchingTree =
    MAtom EgisonPat ObjectRef WHNFData
  | MNode [PatternBinding] MatchingState

type PatternBinding = (Var, EgisonPat)