; cases are processed sequentially
!(assertEqual
   (+ 1 (superpose (1 2 3)))
   (+ 1 (superpose (1 2 3))))


!(assertEqual
   (+ 1 (superpose (1 2 3)))
   (+ 1 (superpose (1 (superpose (2 3))))))

!(assertEqual
   ((superpose (1 2 3)))
   ((superpose (1 (superpose ((+ 1 1) 3))))))



; cases are processed sequentially
!(assertEqual
(case (+ 1 5)
  ((5 Error)
   (6 OK)
   (6 Error)))
 OK)


; we can use variables as cases
!(assertEqual
 (case (+ 1 5)
   (($x (+ 1 $x))))
 7)


; cases are not necessarily exhaustive,
; and the result can be empty
!(assertEqual
    (case 5
	((6 OK)))
  (superpose ()))


; it is non-deterministic: each value is matched against all cases
!(assertEqual
 (case (+ 1 (superpose (1 2 3)))
  ((3 OK-3)
   (4 OK-4)))
 (superpose (OK-3 OK-4)))


; one case can produce multiple results
!(assertEqual
  (case (+ 1 (superpose (1 2 3)))
     (($x (+ 1 $x))))
  (superpose (3 4 5)))

!(assertEqualToResult (superpose ()) ())

!(assertEqualToResult (collapse (superpose ())) (()))

!(assertEqualToResult (superpose ((nop 1))) ())

!(assertEqualToResult (collapse (superpose ((nop 1)))) (()))

(= (Rel-P P P P) 10)

(Rel-P A B)
(Rel-Q A C)

!(match &self $1 $1)

!(get-atoms &self)


!(assertEqual (match &self $1 $1)  (get-atoms &self))


;;l !(repl!)

!(assertEqualToResult
  (match &self
    ($Rel A $X)
    ($Rel A $X))
  ((Rel-P A B)
   (Rel-Q A C)))


!(assertEqualToResult
  (superpose ((Rel-P B) (Rel-Q C)))
  ((Rel-P B) (Rel-Q C)))


; Basic Match
!(assertEqual
   (match &self ($rel A $x) ($rel $x))
   (superpose ((Rel-P B) (Rel-Q C))))


; cases can be used for deconstruction
!(assertEqual
  (superpose ((P B) (Q C)))
  (case
   (match &self ($rel A $x) ($rel $x))
    (((Rel-P $y) (P $y))
     ((Rel-Q $y) (Q $y)))))


; %void% can be used to capture empty results
!(assertEqual
  (case
    (match &self ($rel B $x) ($rel $x))
    (  ((Rel-P $y) (P $y))
       ((Rel-Q $y) (Q $y))
       (%void% no-match
     )))
     no-match )