{-# LANGUAGE NoMonomorphismRestriction #-} -- 
{-# LANGUAGE FlexibleContexts #-} -- 
{-# LANGUAGE TupleSections #-} -- Convenience
{-# LANGUAGE AllowAmbiguousTypes #-} -- For using reifyImplicit
{-# LANGUAGE TypeApplications #-} -- For using reifyImplicit
{-# LANGUAGE TemplateHaskell #-} -- For using reifyTH
module Tests where

import qualified Examples
import Reify
import SemanticAlp as Alp
import SemanticSplice
import SemanticEval

-- * Reifying 'Examples.e0'
e0_ReprExplicit = reify (base-->base-->base-->base) Examples.e0
e0_ReprImplicit = reifyImplicit Examples.e0
e0_ReprTemplate = $(reifyTH 'Examples.e0)
-- e0_ReprExplicit, e0_ReprImplicit, e0_ReprTemplate ::
--   (Syntax.Abstractable repr, Fractional (repr o2)) =>
--   repr (o2 -> o2 -> o2 -> o2)
-- Note: @repr@ is polymorphic, hence those representations
-- can be instantiated to many syntaxes.

-- ** First syntax
e0_ExprExplicit = Alp.compile e0_ReprExplicit
-- | 'inferRR' can't infer that the last polymorphic type
-- must not be the arrow-type.
-- | 'inferRR' can't infer that 'o2' is not the arrow type.
e0_ExprImplicit = Alp.compile @(_ -> _ -> _ -> Float) e0_ReprImplicit
-- | But 'reifyTH' can.
e0_ExprTemplate = Alp.compile e0_ReprTemplate

-- ** Second syntax
e0_EvalExplicit = eval e0_ReprExplicit
e0_EvalImplicit = eval @(_ -> _ -> _ -> Float) e0_ReprImplicit
e0_EvalTemplate = eval e0_ReprTemplate

-- ** Third syntax
e0_SpliceExplicit = splice e0_ReprExplicit
e0_SpliceImplicit = splice @(_ -> _ -> _ -> Float) e0_ReprImplicit
e0_SpliceTemplate = splice e0_ReprTemplate

print_e0 = do
  print ("e0_ExprExplicit", e0_ExprExplicit)
  print ("e0_ExprImplicit", e0_ExprImplicit)
  print ("e0_ExprTemplate", e0_ExprTemplate)
  print ("e0_EvalExplicit 1 2 3", e0_EvalExplicit 1 2 3)
  print ("e0_EvalImplicit 1 2 3", e0_EvalImplicit 1 2 3)
  print ("e0_EvalTemplate 1 2 3", e0_EvalTemplate 1 2 3)
  print =<< ("e0_SpliceExplicit",) <$> e0_SpliceExplicit
  print =<< ("e0_SpliceImplicit",) <$> e0_SpliceImplicit
  print =<< ("e0_SpliceTemplate",) <$> e0_SpliceTemplate

-- * Reifying 'Examples.e1'
e1_ReprExplicit = reify ((base-->base)-->base-->base) Examples.e1
e1_ReprImplicit = reifyImplicit Examples.e1
e1_ReprTemplate = $(reifyTH 'Examples.e1)
-- e1_ReprExplicit, e1_ReprImplicit, e1_ReprTemplate ::
--   Syntax.Abstractable repr =>
--   repr ((o1 -> o2) -> o1 -> o2)

-- ** First syntax
e1_ExprExplicit = Alp.compile e1_ReprExplicit
-- | 'inferRR' can't infer 'o1' and 'o2' aren't the arrow type.
e1_ExprImplicit = Alp.compile @((_ -> _) -> Float -> Float) e1_ReprImplicit
-- | But 'reifyTH' can.
e1_ExprTemplate = Alp.compile e1_ReprTemplate

-- ** Second syntax
e1_EvalExplicit = eval e1_ReprExplicit
-- | 'inferRR' can't keep the function polymorphic.
e1_EvalImplicit = eval @((_ -> _) -> Float -> Float) e1_ReprImplicit
-- | But 'reifyTH' can.
e1_EvalTemplate = eval e1_ReprTemplate

-- ** Third syntax
e1_SpliceExplicit = splice e1_ReprExplicit
e1_SpliceImplicit = splice @((_ -> _) -> Float -> Float) e1_ReprImplicit
e1_SpliceTemplate = splice e1_ReprTemplate

print_e1 = do
  print ("e1_ExprExplicit", e1_ExprExplicit)
  print ("e1_ExprImplicit", e1_ExprImplicit)
  print ("e1_ExprTemplate", e1_ExprTemplate)
  print ("e1_EvalExplicit id 42", e1_EvalExplicit id 42) -- 42
  print ("e1_EvalImplicit id 42", e1_EvalImplicit id 42) -- 42.0
  print ("e1_EvalTemplate id 42", e1_EvalTemplate id 42) -- 42
  print =<< ("e1_SpliceExplicit",) <$> e1_SpliceExplicit
  print =<< ("e1_SpliceImplicit",) <$> e1_SpliceImplicit
  print =<< ("e1_SpliceTemplate",) <$> e1_SpliceTemplate