{-# LANGUAGE GADTs       #-}
{-# LANGUAGE QuasiQuotes #-}

module Spec (spec) where

import           Control.Egison
import           Data.Numbers.Primes
import           Test.Hspec

--
-- Basic list processing functions in pattern-matching-oriented programming style
--

pmap :: (a -> b) -> [a] -> [b]
pmap f xs = matchAll xs (List Something)
             [[mc| join _ (cons $x _) => f x |]]

pmConcat :: [[a]] -> [a]
pmConcat xss = matchAll xss (Multiset (Multiset Something))
                 [[mc| cons (cons $x _) _ => x |]]

spec :: Spec
spec = do
  describe "list and multiset matchers" $ do
    it "cons pattern for list" $
      matchAll [1,2,3] (List Integer) [[mc| cons $x $xs => (x, xs) |]]
      `shouldBe` [(1, [2,3])]

    it "multiset cons pattern" $
      matchAll [1,2,3] (Multiset Integer) [[mc| cons $x $xs => (x, xs) |]]
      `shouldBe` [(1,[2,3]),(2,[1,3]),(3,[1,2])]

    it "join pattern for list matcher" $ length (
      matchAll [1..5] (List Integer)
        [[mc| join $xs $ys => (xs, ys) |]])
      `shouldBe` 6

    it "value pattern for list matcher (1)" $
      match [1,2,3] (List Integer)
        [[mc| #[1,2,3] => "Matched" |],
         [mc| _ => "Not matched" |]]
      `shouldBe` "Matched"

    it "value pattern for list matcher (2)" $
      match [1,2,3] (List Integer)
        [[mc| #[2,1,3] => "Matched" |],
         [mc| _ => "Not matched" |]]
      `shouldBe` "Not matched"

    it "value pattern for multiset matcher" $
      match [1,2,3] (Multiset Integer)
        [[mc| #[2,1,3] => "Matched" |],
         [mc| _ => "Not matched" |]]
      `shouldBe` "Matched"

  describe "match-all with infinitely many results" $ do
    it "Check the order of pattern-matching results" $
      take 10 (matchAll [1..] (Multiset Integer)
                 [[mc| cons $x (cons $y _) => (x, y) |]])
      `shouldBe` [(1,2),(1,3),(2,1),(1,4),(2,3),(3,1),(1,5),(2,4),(3,2),(4,1)]

  describe "built-in pattern constructs" $ do
    it "Predicate patterns" $
      matchAll [1..10] (Multiset Integer)
        [[mc| cons (& (PredicatePat (\x -> mod x 2 == 0)) $x) _ => x |]]
      `shouldBe` [2,4,6,8,10]

  describe "patterns for prime numbers" $ do
    it "twin primes (p, p+2)" $
      take 10 (matchAll primes (List Integer)
                 [[mc| join _ (cons $p (cons #(p+2) _)) => (p, p+2) |]])
      `shouldBe` [(3,5),(5,7),(11,13),(17,19),(29,31),(41,43),(59,61),(71,73),(101,103),(107,109)]

    it "prime pairs whose form is (p, p+6) -- pattern matching with infinitely many results" $
      take 10 (matchAll primes (List Integer)
                 [[mc| join _ (cons $p (join _ (cons #(p+6) _))) => (p, p+6) |]])
      `shouldBe` [(5,11),(7,13),(11,17),(13,19),(17,23),(23,29),(31,37),(37,43),(41,47),(47,53)]

    it "prime triplets -- and-patterns, or-patterns, and not-patterns" $
      take 10 (matchAll primes (List Integer)
                 [[mc| join _ (cons $p (cons (& (| #(p+2) #(p+4)) $m) (cons #(p+6) _))) => (p, m, p+6) |]])
      `shouldBe` [(5,7,11),(7,11,13),(11,13,17),(13,17,19),(17,19,23),(37,41,43),(41,43,47),(67,71,73),(97,101,103),(101,103,107)]

  describe "Basic list processing functions" $ do
    it "map" $
      pmap (+ 10) [1,2,3] `shouldBe` [11, 12, 13]
    it "concat" $
      pmConcat [[1,2], [3], [4, 5]] `shouldBe` [1..5]
    -- it "uniq" $
    --   pmUniq [1,1,2,3,2] `shouldBe` [1,2,3]