{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
{-# OPTIONS_GHC -fno-warn-missing-signatures #-}
{-# OPTIONS_GHC -O0 #-} -- speedup compiling…
module Compiling.Functor.Test where

import Test.Tasty

import Data.Proxy (Proxy(..))
import Data.Text (Text)
import Prelude hiding ((&&), not, (||))

import Language.Symantic.Parsing
import Language.Symantic.Typing
import Language.Symantic.Compiling
import Compiling.Term.Test
import Compiling.Bool.Test ()
import Parsing.Test

-- * Tests
type Ifaces =
 [ Proxy (->)
 , Proxy Bool
 , Proxy Maybe
 , Proxy Functor
 ]
(==>) = test_compile (Proxy::Proxy Ifaces)

instance
 ( Inj_Token (Syntax Text) ts Functor
 , Tokenize (Syntax Text) (Syntax Text) ts ) =>
 TokenizeT (Syntax Text) (Syntax Text) ts (Proxy Functor) where
	tokenizeT _t (Syntax "fmap" (ast_f : ast_m : as)) = Just $ do
		f <- tokenize ast_f
		m <- tokenize ast_m
		Right $ (as,) $ EToken $ inj_token (Syntax "fmap" [ast_f, ast_m]) $
			Token_Term_Functor_fmap f m
	tokenizeT _t (Syntax "(<$)" (ast_a : ast_fb : as)) = Just $ do
		a  <- tokenize ast_a
		fb <- tokenize ast_fb
		Right $ (as,) $ EToken $ inj_token (Syntax "fmap" [ast_a, ast_fb]) $
			Token_Term_Functor_ltdollar a fb
	tokenizeT _t _sy = Nothing

tests :: TestTree
tests = testGroup "Functor"
 [ Syntax "fmap"
	 [ syLam "x" (sy @Bool)
		 (Syntax "not" [syVar "x"])
	 , Syntax "Just" [syLit True]
	 ] ==> Right (ty @Maybe :$ ty @Bool, Just False, "fmap (\\x0 -> (\\x1 -> not x1) x0) (Just True)")
 , Syntax "(<$)"
	 [ syLit False
	 , Syntax "Just" [syLit True]
	 ] ==> Right (ty @Maybe :$ ty @Bool, Just False, "False <$ Just True")
 ]