-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Generic representation and manipulation of abstract syntax
--   
--   The library provides a generic representation of type-indexed abstract
--   syntax trees (or indexed data types in general). It also permits the
--   definition of open syntax trees based on the technique in Data Types à
--   la Carte [1].
--   
--   This package does not work on GHC version 8.2, but works on many
--   earlier and later versions.
--   
--   (Note that the difference between version 2.x and 3.0 is not that big.
--   The bump to 3.0 was done because the modules changed namespace.)
--   
--   For more information, see "A Generic Abstract Syntax Model for
--   Embedded Languages" (ICFP 2012):
--   
--   <ul>
--   <li>Paper:
--   <a>https://emilaxelsson.github.io/documents/axelsson2012generic.pdf</a></li>
--   <li>Slides:
--   <a>https://emilaxelsson.github.io/documents/axelsson2012generic-slides.pdf</a></li>
--   </ul>
--   
--   Example EDSLs can be found in the <tt>examples</tt> folder.
--   
--   &lt;math&gt; W. Swierstra. Data Types à la Carte. <i>Journal of
--   Functional Programming</i>, 18(4):423-436, 2008,
--   <a>http://dx.doi.org/10.1017/S0956796808006758</a>.
@package syntactic
@version 3.8


-- | Generic representation of typed syntax trees
--   
--   For details, see: A Generic Abstract Syntax Model for Embedded
--   Languages (ICFP 2012,
--   <a>https://emilaxelsson.github.io/documents/axelsson2012generic.pdf</a>).
module Language.Syntactic.Syntax

-- | Generic abstract syntax tree, parameterized by a symbol domain
--   
--   <tt>(<a>AST</a> sym (a <a>:-&gt;</a> b))</tt> represents a partially
--   applied (or unapplied) symbol, missing at least one argument, while
--   <tt>(<a>AST</a> sym (<a>Full</a> a))</tt> represents a fully applied
--   symbol, i.e. a complete syntax tree.
data AST sym sig
[Sym] :: sym sig -> AST sym sig
[:$] :: AST sym (a :-> sig) -> AST sym (Full a) -> AST sym sig
infixl 1 :$

-- | Fully applied abstract syntax tree
type ASTF sym a = AST sym (Full a)

-- | Fully applied abstract syntax tree
--   
--   This type is like <a>AST</a>, but being a newtype, it is a proper type
--   constructor that can be partially applied.
newtype ASTFull sym a
ASTFull :: ASTF sym a -> ASTFull sym a
[unASTFull] :: ASTFull sym a -> ASTF sym a

-- | Signature of a fully applied symbol
newtype Full a
Full :: a -> Full a
[result] :: Full a -> a

-- | Signature of a partially applied (or unapplied) symbol
newtype a :-> sig
Partial :: (a -> sig) -> (:->) a sig
infixr 9 :->

-- | Witness of the arity of a symbol signature
data SigRep sig
[SigFull] :: SigRep (Full a)
[SigMore] :: SigRep sig -> SigRep (a :-> sig)

-- | Valid symbol signatures
class Signature sig
signature :: Signature sig => SigRep sig

-- | The result type of a symbol with the given signature
type family DenResult sig

-- | Valid symbols to use in an <a>AST</a>
class Symbol sym

-- | Reify the signature of a symbol
symSig :: Symbol sym => sym sig -> SigRep sig

-- | Count the number of symbols in an <a>AST</a>
size :: AST sym sig -> Int

-- | Maps a symbol signature to the type of the corresponding smart
--   constructor:
--   
--   <pre>
--   SmartFun sym (a :-&gt; b :-&gt; ... :-&gt; Full x) = ASTF sym a -&gt; ASTF sym b -&gt; ... -&gt; ASTF sym x
--   </pre>
type family SmartFun (sym :: * -> *) sig

-- | Maps a smart constructor type to the corresponding symbol signature:
--   
--   <pre>
--   SmartSig (ASTF sym a -&gt; ASTF sym b -&gt; ... -&gt; ASTF sym x) = a :-&gt; b :-&gt; ... :-&gt; Full x
--   </pre>
type family SmartSig f

-- | Returns the symbol in the result of a smart constructor
type family SmartSym f :: * -> *

-- | Make a smart constructor of a symbol. <a>smartSym'</a> has any type of
--   the form:
--   
--   <pre>
--   smartSym'
--       :: sym (a :-&gt; b :-&gt; ... :-&gt; Full x)
--       -&gt; (ASTF sym a -&gt; ASTF sym b -&gt; ... -&gt; ASTF sym x)
--   </pre>
smartSym' :: forall sig f sym. (Signature sig, f ~ SmartFun sym sig, sig ~ SmartSig f, sym ~ SmartSym f) => sym sig -> f

-- | Direct sum of two symbol domains
data ( sym1 :+: sym2 ) sig
[InjL] :: sym1 a -> (sym1 :+: sym2) a
[InjR] :: sym2 a -> (sym1 :+: sym2) a
infixr 9 :+:

-- | Symbol projection
--   
--   The class is defined for <i>all pairs of types</i>, but <a>prj</a> can
--   only succeed if <tt>sup</tt> is of the form <tt>(... <a>:+:</a> sub
--   <a>:+:</a> ...)</tt>.
class Project sub sup

-- | Partial projection from <tt>sup</tt> to <tt>sub</tt>
prj :: Project sub sup => sup a -> Maybe (sub a)

-- | Symbol injection
--   
--   The class includes types <tt>sub</tt> and <tt>sup</tt> where
--   <tt>sup</tt> is of the form <tt>(... <a>:+:</a> sub <a>:+:</a>
--   ...)</tt>.
class Project sub sup => sub :<: sup

-- | Injection from <tt>sub</tt> to <tt>sup</tt>
inj :: (:<:) sub sup => sub a -> sup a

-- | Make a smart constructor of a symbol. <a>smartSym</a> has any type of
--   the form:
--   
--   <pre>
--   smartSym :: (sub :&lt;: AST sup)
--       =&gt; sub (a :-&gt; b :-&gt; ... :-&gt; Full x)
--       -&gt; (ASTF sup a -&gt; ASTF sup b -&gt; ... -&gt; ASTF sup x)
--   </pre>
smartSym :: (Signature sig, f ~ SmartFun sup sig, sig ~ SmartSig f, sup ~ SmartSym f, sub :<: sup) => sub sig -> f

-- | Make a smart constructor of a symbol. <a>smartSymTyped</a> has any
--   type of the form:
--   
--   <pre>
--   smartSymTyped :: (sub :&lt;: AST (Typed sup), Typeable x)
--       =&gt; sub (a :-&gt; b :-&gt; ... :-&gt; Full x)
--       -&gt; (ASTF sup a -&gt; ASTF sup b -&gt; ... -&gt; ASTF sup x)
--   </pre>
smartSymTyped :: (Signature sig, f ~ SmartFun (Typed sup) sig, sig ~ SmartSig f, Typed sup ~ SmartSym f, sub :<: sup, Typeable (DenResult sig)) => sub sig -> f

-- | Empty symbol type
--   
--   Can be used to make uninhabited <a>AST</a> types. It can also be used
--   as a terminator in co-product lists (e.g. to avoid overlapping
--   instances):
--   
--   <pre>
--   (A :+: B :+: Empty)
--   </pre>
data Empty :: * -> *

-- | Existential quantification
data E e
[E] :: e a -> E e
liftE :: (forall a. e a -> b) -> E e -> b
liftE2 :: (forall a b. e a -> e b -> c) -> E e -> E e -> c

-- | Existential quantification of <a>Full</a>-indexed type
data EF e
[EF] :: e (Full a) -> EF e
liftEF :: (forall a. e (Full a) -> b) -> EF e -> b
liftEF2 :: (forall a b. e (Full a) -> e (Full b) -> c) -> EF e -> EF e -> c

-- | "Typed" symbol. Using <tt><a>Typed</a> sym</tt> instead of
--   <tt>sym</tt> gives access to the function <a>castExpr</a> for casting
--   expressions.
data Typed sym sig
[Typed] :: Typeable (DenResult sig) => sym sig -> Typed sym sig

-- | Inject a symbol in an <a>AST</a> with a <a>Typed</a> domain
injT :: (sub :<: sup, Typeable (DenResult sig)) => sub sig -> AST (Typed sup) sig

-- | Type cast an expression
castExpr :: forall sym a b. ASTF (Typed sym) a -> ASTF (Typed sym) b -> Maybe (ASTF (Typed sym) b)

-- | Higher-kinded version of <a>NFData</a>
class NFData1 c

-- | Force a symbol to normal form
rnf1 :: NFData1 c => c a -> ()

-- | Constrain a symbol to a specific type
symType :: Proxy sym -> sym sig -> sym sig

-- | Projection to a specific symbol type
prjP :: Project sub sup => Proxy sub -> sup sig -> Maybe (sub sig)
instance (Data.Traversable.Traversable sym1, Data.Traversable.Traversable sym2) => Data.Traversable.Traversable (sym1 Language.Syntactic.Syntax.:+: sym2)
instance (Data.Foldable.Foldable sym1, Data.Foldable.Foldable sym2) => Data.Foldable.Foldable (sym1 Language.Syntactic.Syntax.:+: sym2)
instance (GHC.Base.Functor sym1, GHC.Base.Functor sym2) => GHC.Base.Functor (sym1 Language.Syntactic.Syntax.:+: sym2)
instance GHC.Base.Functor ((Language.Syntactic.Syntax.:->) a)
instance GHC.Base.Functor Language.Syntactic.Syntax.Full
instance GHC.Show.Show a => GHC.Show.Show (Language.Syntactic.Syntax.Full a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Language.Syntactic.Syntax.Full a)
instance Language.Syntactic.Syntax.NFData1 sym => Control.DeepSeq.NFData (Language.Syntactic.Syntax.AST sym sig)
instance (Language.Syntactic.Syntax.NFData1 sym1, Language.Syntactic.Syntax.NFData1 sym2) => Language.Syntactic.Syntax.NFData1 (sym1 Language.Syntactic.Syntax.:+: sym2)
instance Language.Syntactic.Syntax.Project sub sup => Language.Syntactic.Syntax.Project sub (Language.Syntactic.Syntax.Typed sup)
instance (sub Language.Syntactic.Syntax.:<: sup) => sub Language.Syntactic.Syntax.:<: Language.Syntactic.Syntax.AST sup
instance sym Language.Syntactic.Syntax.:<: sym
instance sym1 Language.Syntactic.Syntax.:<: (sym1 Language.Syntactic.Syntax.:+: sym2)
instance (sym1 Language.Syntactic.Syntax.:<: sym3) => sym1 Language.Syntactic.Syntax.:<: (sym2 Language.Syntactic.Syntax.:+: sym3)
instance Language.Syntactic.Syntax.Project sub sup => Language.Syntactic.Syntax.Project sub (Language.Syntactic.Syntax.AST sup)
instance Language.Syntactic.Syntax.Project sym sym
instance Language.Syntactic.Syntax.Project sym1 (sym1 Language.Syntactic.Syntax.:+: sym2)
instance Language.Syntactic.Syntax.Project sym1 sym3 => Language.Syntactic.Syntax.Project sym1 (sym2 Language.Syntactic.Syntax.:+: sym3)
instance (Language.Syntactic.Syntax.Symbol sym1, Language.Syntactic.Syntax.Symbol sym2) => Language.Syntactic.Syntax.Symbol (sym1 Language.Syntactic.Syntax.:+: sym2)
instance Language.Syntactic.Syntax.Signature (Language.Syntactic.Syntax.Full a)
instance Language.Syntactic.Syntax.Signature sig => Language.Syntactic.Syntax.Signature (a Language.Syntactic.Syntax.:-> sig)
instance GHC.Base.Functor sym => GHC.Base.Functor (Language.Syntactic.Syntax.AST sym)


-- | "Syntactic sugar"
--   
--   For details, see "Combining Deep and Shallow Embedding for EDSL" (TFP
--   2013,
--   <a>https://emilaxelsson.github.io/documents/svenningsson2013combining.pdf</a>).
module Language.Syntactic.Sugar

-- | It is usually assumed that <tt>(<a>desugar</a> (<a>sugar</a> a))</tt>
--   has the same meaning as <tt>a</tt>.
class Syntactic a where {
    type family Domain a :: * -> *;
    type family Internal a;
}
desugar :: Syntactic a => a -> ASTF (Domain a) (Internal a)
sugar :: Syntactic a => ASTF (Domain a) (Internal a) -> a

-- | Syntactic type casting
resugar :: (Syntactic a, Syntactic b, Domain a ~ Domain b, Internal a ~ Internal b) => a -> b

-- | N-ary syntactic functions
--   
--   <a>desugarN</a> has any type of the form:
--   
--   <pre>
--   desugarN ::
--       ( Syntactic a
--       , Syntactic b
--       , ...
--       , Syntactic x
--       , Domain a ~ sym
--       , Domain b ~ sym
--       , ...
--       , Domain x ~ sym
--       ) =&gt; (a -&gt; b -&gt; ... -&gt; x)
--         -&gt; (  ASTF sym (Internal a)
--            -&gt; ASTF sym (Internal b)
--            -&gt; ...
--            -&gt; ASTF sym (Internal x)
--            )
--   </pre>
--   
--   ...and vice versa for <a>sugarN</a>.
class SyntacticN f internal | f -> internal
desugarN :: SyntacticN f internal => f -> internal
sugarN :: SyntacticN f internal => internal -> f

-- | "Sugared" symbol application
--   
--   <a>sugarSym</a> has any type of the form:
--   
--   <pre>
--   sugarSym ::
--       ( sub :&lt;: AST sup
--       , Syntactic a
--       , Syntactic b
--       , ...
--       , Syntactic x
--       , Domain a ~ Domain b ~ ... ~ Domain x
--       ) =&gt; sub (Internal a :-&gt; Internal b :-&gt; ... :-&gt; Full (Internal x))
--         -&gt; (a -&gt; b -&gt; ... -&gt; x)
--   </pre>
sugarSym :: (Signature sig, fi ~ SmartFun sup sig, sig ~ SmartSig fi, sup ~ SmartSym fi, SyntacticN f fi, sub :<: sup) => sub sig -> f

-- | "Sugared" symbol application
--   
--   <a>sugarSymTyped</a> has any type of the form:
--   
--   <pre>
--   sugarSymTyped ::
--       ( sub :&lt;: AST (Typed sup)
--       , Syntactic a
--       , Syntactic b
--       , ...
--       , Syntactic x
--       , Domain a ~ Domain b ~ ... ~ Domain x
--       , Typeable (Internal x)
--       ) =&gt; sub (Internal a :-&gt; Internal b :-&gt; ... :-&gt; Full (Internal x))
--         -&gt; (a -&gt; b -&gt; ... -&gt; x)
--   </pre>
sugarSymTyped :: (Signature sig, fi ~ SmartFun (Typed sup) sig, sig ~ SmartSig fi, Typed sup ~ SmartSym fi, SyntacticN f fi, sub :<: sup, Typeable (DenResult sig)) => sub sig -> f
instance (Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Domain f Data.Type.Equality.~ sym, fi Data.Type.Equality.~ Language.Syntactic.Syntax.AST sym (Language.Syntactic.Syntax.Full (Language.Syntactic.Sugar.Internal f))) => Language.Syntactic.Sugar.SyntacticN f fi
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, ia Data.Type.Equality.~ Language.Syntactic.Sugar.Internal a, Language.Syntactic.Sugar.SyntacticN f fi) => Language.Syntactic.Sugar.SyntacticN (a -> f) (Language.Syntactic.Syntax.AST sym (Language.Syntactic.Syntax.Full ia) -> fi)
instance Language.Syntactic.Sugar.Syntactic (Language.Syntactic.Syntax.ASTF sym a)
instance Language.Syntactic.Sugar.Syntactic (Language.Syntactic.Syntax.ASTFull sym a)


-- | Equality and rendering of <a>AST</a>s
module Language.Syntactic.Interpretation

-- | Higher-kinded equality
class Equality e

-- | Higher-kinded equality
--   
--   Comparing elements of different types is often needed when dealing
--   with expressions with existentially quantified sub-terms.
equal :: Equality e => e a -> e b -> Bool

-- | Higher-kinded equality
--   
--   Comparing elements of different types is often needed when dealing
--   with expressions with existentially quantified sub-terms.
equal :: (Equality e, Render e) => e a -> e b -> Bool

-- | Higher-kinded hashing. Elements that are equal according to
--   <a>equal</a> must result in the same hash:
--   
--   <pre>
--   equal a b  ==&gt;  hash a == hash b
--   </pre>
hash :: Equality e => e a -> Hash

-- | Higher-kinded hashing. Elements that are equal according to
--   <a>equal</a> must result in the same hash:
--   
--   <pre>
--   equal a b  ==&gt;  hash a == hash b
--   </pre>
hash :: (Equality e, Render e) => e a -> Hash

-- | Render a symbol as concrete syntax. A complete instance must define at
--   least the <a>renderSym</a> method.
class Render sym

-- | Show a symbol as a <a>String</a>
renderSym :: Render sym => sym sig -> String

-- | Render a symbol given a list of rendered arguments
renderArgs :: Render sym => [String] -> sym sig -> String

-- | Implementation of <a>renderArgs</a> that handles infix operators
renderArgsSmart :: Render sym => [String] -> sym a -> String

-- | Render an <a>AST</a> as concrete syntax
render :: forall sym a. Render sym => ASTF sym a -> String

-- | Convert a symbol to a <a>Tree</a> of strings
class Render sym => StringTree sym

-- | Convert a symbol to a <a>Tree</a> given a list of argument trees
stringTreeSym :: StringTree sym => [Tree String] -> sym a -> Tree String

-- | Convert an <a>AST</a> to a <a>Tree</a> of strings
stringTree :: forall sym a. StringTree sym => ASTF sym a -> Tree String

-- | Show a syntax tree using ASCII art
showAST :: StringTree sym => ASTF sym a -> String

-- | Print a syntax tree using ASCII art
drawAST :: StringTree sym => ASTF sym a -> IO ()

-- | Write a syntax tree to an HTML file with foldable nodes
writeHtmlAST :: StringTree sym => FilePath -> ASTF sym a -> IO ()

-- | Default implementation of <a>equal</a>
equalDefault :: Render sym => sym a -> sym b -> Bool

-- | Default implementation of <a>hash</a>
hashDefault :: Render sym => sym a -> Hash
instance (Language.Syntactic.Interpretation.StringTree sym1, Language.Syntactic.Interpretation.StringTree sym2) => Language.Syntactic.Interpretation.StringTree (sym1 Language.Syntactic.Syntax.:+: sym2)
instance Language.Syntactic.Interpretation.StringTree Language.Syntactic.Syntax.Empty
instance Language.Syntactic.Interpretation.StringTree sym => Language.Syntactic.Interpretation.StringTree (Language.Syntactic.Syntax.Typed sym)
instance Language.Syntactic.Interpretation.Equality sym => Language.Syntactic.Interpretation.Equality (Language.Syntactic.Syntax.AST sym)
instance Language.Syntactic.Interpretation.Equality sym => GHC.Classes.Eq (Language.Syntactic.Syntax.AST sym a)
instance (Language.Syntactic.Interpretation.Equality sym1, Language.Syntactic.Interpretation.Equality sym2) => Language.Syntactic.Interpretation.Equality (sym1 Language.Syntactic.Syntax.:+: sym2)
instance (Language.Syntactic.Interpretation.Equality sym1, Language.Syntactic.Interpretation.Equality sym2) => GHC.Classes.Eq ((Language.Syntactic.Syntax.:+:) sym1 sym2 a)
instance Language.Syntactic.Interpretation.Equality Language.Syntactic.Syntax.Empty
instance Language.Syntactic.Interpretation.Equality sym => Language.Syntactic.Interpretation.Equality (Language.Syntactic.Syntax.Typed sym)
instance (Language.Syntactic.Interpretation.Render sym1, Language.Syntactic.Interpretation.Render sym2) => Language.Syntactic.Interpretation.Render (sym1 Language.Syntactic.Syntax.:+: sym2)
instance Language.Syntactic.Interpretation.Render Language.Syntactic.Syntax.Empty
instance Language.Syntactic.Interpretation.Render sym => Language.Syntactic.Interpretation.Render (Language.Syntactic.Syntax.Typed sym)
instance Language.Syntactic.Interpretation.Render sym => GHC.Show.Show (Language.Syntactic.Syntax.ASTF sym a)


-- | Generic traversals of <a>AST</a> terms
module Language.Syntactic.Traversal

-- | Map a function over all immediate sub-terms, collecting the results in
--   a list (corresponds to the function with the same name in Scrap Your
--   Boilerplate)
gmapQ :: forall sym b. (forall a. ASTF sym a -> b) -> forall a. ASTF sym a -> [b]

-- | Map a function over all immediate sub-terms (corresponds to the
--   function with the same name in Scrap Your Boilerplate)
gmapT :: forall sym. (forall a. ASTF sym a -> ASTF sym a) -> forall a. ASTF sym a -> ASTF sym a

-- | Apply a transformation bottom-up over an <a>AST</a> (corresponds to
--   <tt>everywhere</tt> in Scrap Your Boilerplate)
everywhereUp :: (forall a. ASTF sym a -> ASTF sym a) -> forall a. ASTF sym a -> ASTF sym a

-- | Apply a transformation top-down over an <a>AST</a> (corresponds to
--   <tt>everywhere'</tt> in Scrap Your Boilerplate)
everywhereDown :: (forall a. ASTF sym a -> ASTF sym a) -> forall a. ASTF sym a -> ASTF sym a

-- | List all sub-terms (corresponds to <tt>universe</tt> in Uniplate)
universe :: ASTF sym a -> [EF (AST sym)]

-- | List of symbol arguments
data Args c sig
[Nil] :: Args c (Full a)
[:*] :: c (Full a) -> Args c sig -> Args c (a :-> sig)
infixr 9 :*

-- | Map a function over an <a>Args</a> list and collect the results in an
--   ordinary list
listArgs :: (forall a. c (Full a) -> b) -> Args c sig -> [b]

-- | Map a function over an <a>Args</a> list
mapArgs :: (forall a. c1 (Full a) -> c2 (Full a)) -> forall sig. Args c1 sig -> Args c2 sig

-- | Map an applicative function over an <a>Args</a> list
mapArgsA :: Applicative f => (forall a. c1 (Full a) -> f (c2 (Full a))) -> forall sig. Args c1 sig -> f (Args c2 sig)

-- | Map a monadic function over an <a>Args</a> list
mapArgsM :: Monad m => (forall a. c1 (Full a) -> m (c2 (Full a))) -> forall sig. Args c1 sig -> m (Args c2 sig)

-- | Right fold for an <a>Args</a> list
foldrArgs :: (forall a. c (Full a) -> b -> b) -> b -> forall sig. Args c sig -> b

-- | Apply a (partially applied) symbol to a list of argument terms
appArgs :: AST sym sig -> Args (AST sym) sig -> ASTF sym (DenResult sig)

-- | Fold an <a>AST</a> using a list to hold the results of sub-terms
listFold :: forall sym b. (forall sig. sym sig -> [b] -> b) -> forall a. ASTF sym a -> b

-- | "Pattern match" on an <a>AST</a> using a function that gets direct
--   access to the top-most symbol and its sub-trees
match :: forall sym a c. (forall sig. a ~ DenResult sig => sym sig -> Args (AST sym) sig -> c (Full a)) -> ASTF sym a -> c (Full a)

-- | A version of <a>match</a> with a simpler result type
simpleMatch :: forall sym a b. (forall sig. a ~ DenResult sig => sym sig -> Args (AST sym) sig -> b) -> ASTF sym a -> b

-- | Fold an <a>AST</a> using an <a>Args</a> list to hold the results of
--   sub-terms
fold :: forall sym c. (forall sig. sym sig -> Args c sig -> c (Full (DenResult sig))) -> forall a. ASTF sym a -> c (Full a)

-- | Simplified version of <a>fold</a> for situations where all
--   intermediate results have the same type
simpleFold :: forall sym b. (forall sig. sym sig -> Args (Const b) sig -> b) -> forall a. ASTF sym a -> b

-- | A version of <a>match</a> where the result is a transformed syntax
--   tree, wrapped in a type constructor <tt>c</tt>
matchTrans :: forall sym sym' c a. (forall sig. a ~ DenResult sig => sym sig -> Args (AST sym) sig -> c (ASTF sym' a)) -> ASTF sym a -> c (ASTF sym' a)

-- | Update the symbols in an AST
mapAST :: (forall sig'. sym1 sig' -> sym2 sig') -> AST sym1 sig -> AST sym2 sig

-- | Can be used to make an arbitrary type constructor indexed by
--   <tt>(<a>Full</a> a)</tt>. This is useful as the type constructor
--   parameter of <a>Args</a>. That is, use
--   
--   <pre>
--   Args (WrapFull c) ...
--   </pre>
--   
--   instead of
--   
--   <pre>
--   Args c ...
--   </pre>
--   
--   if <tt>c</tt> is not indexed by <tt>(<a>Full</a> a)</tt>.
data WrapFull c a
[WrapFull] :: {unwrapFull :: c a} -> WrapFull c (Full a)

-- | Convert an <a>AST</a> to a <a>Tree</a>
toTree :: forall dom a b. (forall sig. dom sig -> b) -> ASTF dom a -> Tree b


-- | Construct for decorating symbols or expressions with additional
--   information
module Language.Syntactic.Decoration

-- | Decorating symbols or expressions with additional information
--   
--   One usage of <a>:&amp;:</a> is to decorate every node of a syntax
--   tree. This is done simply by changing
--   
--   <pre>
--   AST sym sig
--   </pre>
--   
--   to
--   
--   <pre>
--   AST (sym :&amp;: info) sig
--   </pre>
data ( expr :&: info ) sig
[:&:] :: {decorExpr :: expr sig, decorInfo :: info (DenResult sig)} -> (expr :&: info) sig

-- | Map over a decoration
mapDecor :: (sym1 sig -> sym2 sig) -> (info1 (DenResult sig) -> info2 (DenResult sig)) -> (sym1 :&: info1) sig -> (sym2 :&: info2) sig

-- | Get the decoration of the top-level node
getDecor :: AST (sym :&: info) sig -> info (DenResult sig)

-- | Update the decoration of the top-level node
updateDecor :: forall info sym a. (info a -> info a) -> ASTF (sym :&: info) a -> ASTF (sym :&: info) a

-- | Lift a function that operates on expressions with associated
--   information to operate on a <a>:&amp;:</a> expression. This function
--   is convenient to use together with e.g. <tt>queryNodeSimple</tt> when
--   the domain has the form <tt>(sym <a>:&amp;:</a> info)</tt>.
liftDecor :: (expr s -> info (DenResult s) -> b) -> (expr :&: info) s -> b

-- | Strip decorations from an <a>AST</a>
stripDecor :: AST (sym :&: info) sig -> AST sym sig

-- | Rendering of decorated syntax trees
stringTreeDecor :: forall info sym a. StringTree sym => (forall a. info a -> String) -> ASTF (sym :&: info) a -> Tree String

-- | Show an decorated syntax tree using ASCII art
showDecorWith :: StringTree sym => (forall a. info a -> String) -> ASTF (sym :&: info) a -> String

-- | Print an decorated syntax tree using ASCII art
drawDecorWith :: StringTree sym => (forall a. info a -> String) -> ASTF (sym :&: info) a -> IO ()
writeHtmlDecorWith :: forall info sym a. StringTree sym => (forall b. info b -> String) -> FilePath -> ASTF (sym :&: info) a -> IO ()

-- | Make a smart constructor of a symbol. <a>smartSymDecor</a> has any
--   type of the form:
--   
--   <pre>
--   smartSymDecor :: (sub :&lt;: AST (sup :&amp;: info))
--       =&gt; info x
--       -&gt; sub (a :-&gt; b :-&gt; ... :-&gt; Full x)
--       -&gt; (ASTF sup a -&gt; ASTF sup b -&gt; ... -&gt; ASTF sup x)
--   </pre>
smartSymDecor :: (Signature sig, f ~ SmartFun (sup :&: info) sig, sig ~ SmartSig f, (sup :&: info) ~ SmartSym f, sub :<: sup) => info (DenResult sig) -> sub sig -> f

-- | "Sugared" symbol application
--   
--   <a>sugarSymDecor</a> has any type of the form:
--   
--   <pre>
--   sugarSymDecor ::
--       ( sub :&lt;: AST (sup :&amp;: info)
--       , Syntactic a
--       , Syntactic b
--       , ...
--       , Syntactic x
--       , Domain a ~ Domain b ~ ... ~ Domain x
--       ) =&gt; info (Internal x)
--         -&gt; sub (Internal a :-&gt; Internal b :-&gt; ... :-&gt; Full (Internal x))
--         -&gt; (a -&gt; b -&gt; ... -&gt; x)
--   </pre>
sugarSymDecor :: (Signature sig, fi ~ SmartFun (sup :&: info) sig, sig ~ SmartSig fi, (sup :&: info) ~ SmartSym fi, SyntacticN f fi, sub :<: sup) => info (DenResult sig) -> sub sig -> f
instance Language.Syntactic.Syntax.Symbol sym => Language.Syntactic.Syntax.Symbol (sym Language.Syntactic.Decoration.:&: info)
instance (Language.Syntactic.Syntax.NFData1 sym, Language.Syntactic.Syntax.NFData1 info) => Language.Syntactic.Syntax.NFData1 (sym Language.Syntactic.Decoration.:&: info)
instance Language.Syntactic.Syntax.Project sub sup => Language.Syntactic.Syntax.Project sub (sup Language.Syntactic.Decoration.:&: info)
instance Language.Syntactic.Interpretation.Equality expr => Language.Syntactic.Interpretation.Equality (expr Language.Syntactic.Decoration.:&: info)
instance Language.Syntactic.Interpretation.Render expr => Language.Syntactic.Interpretation.Render (expr Language.Syntactic.Decoration.:&: info)
instance Language.Syntactic.Interpretation.StringTree expr => Language.Syntactic.Interpretation.StringTree (expr Language.Syntactic.Decoration.:&: info)


-- | The basic parts of the syntactic library
module Language.Syntactic

module Language.Syntactic.TH

-- | Get the name and arity of a constructor
conName :: Con -> (Name, Int)

-- | Description of class methods
data Method

-- | rhs = lhs
DefaultMethod :: Name -> Name -> Method

-- | <pre>
--   MatchingMethod methodName mkClause extraClauses
--   </pre>
--   
--   <tt>mkClause</tt> takes as arguments (1) a description of the
--   constructor, (2) the constructor's index, (3) the constructor's name,
--   and (4) its arity.
MatchingMethod :: Name -> (Con -> Int -> Name -> Int -> Clause) -> [Clause] -> Method

-- | General method for class deriving
deriveClass :: Cxt -> Name -> Type -> [Method] -> DecsQ

-- | General method for class deriving
deriveClassSimple :: Name -> Name -> [Method] -> DecsQ
varSupply :: [Name]

-- | Derive <a>Symbol</a> instance for a type
deriveSymbol :: Name -> DecsQ

-- | Derive <a>Equality</a> instance for a type
--   
--   <pre>
--   equal Con1 Con1 = True
--   equal (Con2 a1 ... x1) (Con2 a2 ... x2) = and [a1==a2, ... x1==x2]
--   equal _ _ = False
--   </pre>
--   
--   <pre>
--   hash Con1           = hashInt 0
--   hash (Con2 a ... x) = foldr1 combine [hashInt 1, hash a, ... hash x]
--   </pre>
deriveEquality :: Name -> DecsQ

-- | Derive <a>Render</a> instance for a type
--   
--   <pre>
--   renderSym Con1           = "Con1"
--   renderSym (Con2 a ... x) = concat ["(", unwords ["Con2", show a, ... show x], ")"]
--   </pre>
deriveRender :: (String -> String) -> Name -> DecsQ

-- | Construct an instance declaration
instD :: Cxt -> Type -> [Dec] -> Dec

-- | Get the constructors of a data type definition
viewDataDef :: Info -> Maybe [Con]

-- | Portable method for constructing a <a>Pred</a> of the form <tt>(t1 ~
--   t2)</tt>
eqPred :: Type -> Type -> Pred

-- | Portable method for constructing a <a>Pred</a> of the form
--   <tt>SomeClass t1 t2 ...</tt>
classPred :: Name -> (Name -> Type) -> [Type] -> Pred

-- | Portable method for constructing a type synonym instances
tySynInst :: Name -> [Type] -> Type -> Dec

module Data.NestTuple.TH
mkTupT :: [Type] -> Type
mkPairT :: Type -> Type -> Type
mkPairE :: Exp -> Exp -> Exp
mkPairP :: Pat -> Pat -> Pat
data Nest a
Leaf :: a -> Nest a
Pair :: Nest a -> Nest a -> Nest a
foldNest :: (a -> b) -> (b -> b -> b) -> Nest a -> b
toNest :: [a] -> Nest a
mkNestableInstances :: Int -> DecsQ
instance GHC.Base.Functor Data.NestTuple.TH.Nest
instance GHC.Show.Show a => GHC.Show.Show (Data.NestTuple.TH.Nest a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.NestTuple.TH.Nest a)


-- | Conversion between tuples and nested pairs
module Data.NestTuple

-- | Tuples that can be converted to/from nested pairs
class Nestable tup where {
    
    -- | Representation as nested pairs
    type family Nested tup;
}

-- | Convert to nested pairs
nest :: Nestable tup => tup -> Nested tup

-- | Convert from nested pairs
unnest :: Nestable tup => Nested tup -> tup
instance Data.NestTuple.Nestable (a, b)
instance Data.NestTuple.Nestable (a, b, c)
instance Data.NestTuple.Nestable (a, b, c, d)
instance Data.NestTuple.Nestable (a, b, c, d, e)
instance Data.NestTuple.Nestable (a, b, c, d, e, f)
instance Data.NestTuple.Nestable (a, b, c, d, e, f, g)
instance Data.NestTuple.Nestable (a, b, c, d, e, f, g, h)
instance Data.NestTuple.Nestable (a, b, c, d, e, f, g, h, i)
instance Data.NestTuple.Nestable (a, b, c, d, e, f, g, h, i, j)
instance Data.NestTuple.Nestable (a, b, c, d, e, f, g, h, i, j, k)
instance Data.NestTuple.Nestable (a, b, c, d, e, f, g, h, i, j, k, l)
instance Data.NestTuple.Nestable (a, b, c, d, e, f, g, h, i, j, k, l, m)
instance Data.NestTuple.Nestable (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
instance Data.NestTuple.Nestable (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)


-- | Generate <a>Syntactic</a> instances for tuples
module Language.Syntactic.Functional.Tuple.TH
deriveSyntacticForTuples :: (Type -> Cxt) -> (Type -> Type) -> Cxt -> Int -> DecsQ


-- | Basics for implementing functional EDSLs
module Language.Syntactic.Functional

-- | Variable name
newtype Name
Name :: Integer -> Name

-- | Literal
data Literal sig
[Literal] :: Show a => a -> Literal (Full a)

-- | Generic N-ary syntactic construct
--   
--   <a>Construct</a> gives a quick way to introduce a syntactic construct
--   by giving its name and semantic function.
data Construct sig
[Construct] :: Signature sig => String -> Denotation sig -> Construct sig

-- | Variables and binders
data Binding sig
[Var] :: Name -> Binding (Full a)
[Lam] :: Name -> Binding (b :-> Full (a -> b))

-- | Get the highest name bound by the first <a>Lam</a> binders at every
--   path from the root. If the term has <i>ordered binders</i>
--   &lt;math&gt;, <a>maxLam</a> returns the highest name introduced in the
--   whole term.
--   
--   &lt;math&gt; Ordered binders means that the names of <a>Lam</a> nodes
--   are decreasing along every path from the root.
maxLam :: Project Binding s => AST s a -> Name

-- | Higher-order interface for variable binding for domains based on
--   <a>Binding</a>
--   
--   Assumptions:
--   
--   <ul>
--   <li>The body <tt>f</tt> does not inspect its argument.</li>
--   <li>Applying <tt>f</tt> to a term with ordered binders results in a
--   term with <i>ordered binders</i> &lt;math&gt;.</li>
--   </ul>
--   
--   &lt;math&gt; Ordered binders means that the names of <a>Lam</a> nodes
--   are decreasing along every path from the root.
--   
--   See "Using Circular Programs for Higher-Order Syntax" (ICFP 2013,
--   <a>https://emilaxelsson.github.io/documents/axelsson2013using.pdf</a>).
lam_template :: Project Binding sym => (Name -> sym (Full a)) -> (Name -> ASTF sym b -> ASTF sym (a -> b)) -> (ASTF sym a -> ASTF sym b) -> ASTF sym (a -> b)

-- | Higher-order interface for variable binding
--   
--   This function is <a>lamT_template</a> specialized to domains
--   <tt>sym</tt> satisfying <tt>(<a>Binding</a> <a>:&lt;:</a> sym)</tt>.
lam :: Binding :<: sym => (ASTF sym a -> ASTF sym b) -> ASTF sym (a -> b)

-- | Convert from a term with De Bruijn indexes to one with explicit names
--   
--   In the argument term, variable <a>Name</a>s are treated as De Bruijn
--   indexes, and lambda <a>Name</a>s are ignored. (Ideally, one should use
--   a different type for De Bruijn terms.)
fromDeBruijn :: Binding :<: sym => ASTF sym a -> ASTF sym a

-- | Typed variables and binders
data BindingT sig
[VarT] :: Typeable a => Name -> BindingT (Full a)
[LamT] :: Typeable a => Name -> BindingT (b :-> Full (a -> b))

-- | Get the highest name bound by the first <a>LamT</a> binders at every
--   path from the root. If the term has <i>ordered binders</i>
--   &lt;math&gt;, <a>maxLamT</a> returns the highest name introduced in
--   the whole term.
--   
--   &lt;math&gt; Ordered binders means that the names of <a>LamT</a> nodes
--   are decreasing along every path from the root.
maxLamT :: Project BindingT sym => AST sym a -> Name

-- | Higher-order interface for variable binding
--   
--   Assumptions:
--   
--   <ul>
--   <li>The body <tt>f</tt> does not inspect its argument.</li>
--   <li>Applying <tt>f</tt> to a term with ordered binders results in a
--   term with <i>ordered binders</i> &lt;math&gt;.</li>
--   </ul>
--   
--   &lt;math&gt; Ordered binders means that the names of <a>LamT</a> nodes
--   are decreasing along every path from the root.
--   
--   See "Using Circular Programs for Higher-Order Syntax" (ICFP 2013,
--   <a>https://emilaxelsson.github.io/documents/axelsson2013using.pdf</a>).
lamT_template :: Project BindingT sym => (Name -> sym (Full a)) -> (Name -> ASTF sym b -> ASTF sym (a -> b)) -> (ASTF sym a -> ASTF sym b) -> ASTF sym (a -> b)

-- | Higher-order interface for variable binding
--   
--   This function is <a>lamT_template</a> specialized to domains
--   <tt>sym</tt> satisfying <tt>(<a>BindingT</a> <a>:&lt;:</a> sym)</tt>.
lamT :: (BindingT :<: sym, Typeable a) => (ASTF sym a -> ASTF sym b) -> ASTF sym (a -> b)

-- | Higher-order interface for variable binding
--   
--   This function is <a>lamT_template</a> specialized to domains
--   <tt>sym</tt> satisfying <tt>(sym ~ <a>Typed</a> s, <a>BindingT</a>
--   <a>:&lt;:</a> s)</tt>.
lamTyped :: (sym ~ Typed s, BindingT :<: s, Typeable a, Typeable b) => (ASTF sym a -> ASTF sym b) -> ASTF sym (a -> b)

-- | Domains that "might" include variables and binders
class BindingDomain sym
prVar :: BindingDomain sym => sym sig -> Maybe Name
prLam :: BindingDomain sym => sym sig -> Maybe Name

-- | Rename a variable or a lambda (no effect for other symbols)
renameBind :: BindingDomain sym => (Name -> Name) -> sym sig -> sym sig

-- | A symbol for let bindings
--   
--   This symbol is just an application operator. The actual binding has to
--   be done by a lambda that constructs the second argument.
--   
--   The provided string is just a tag and has nothing to do with the name
--   of the variable of the second argument (if that argument happens to be
--   a lambda). However, a back end may use the tag to give a sensible name
--   to the generated variable.
--   
--   The string tag may be empty.
data Let sig
[Let] :: String -> Let (a :-> ((a -> b) :-> Full b))

-- | Monadic constructs
--   
--   See "Generic Monadic Constructs for Embedded Languages" (Persson et
--   al., IFL 2011
--   <a>https://emilaxelsson.github.io/documents/persson2011generic.pdf</a>).
data MONAD m sig
[Return] :: MONAD m (a :-> Full (m a))
[Bind] :: MONAD m (m a :-> ((a -> m b) :-> Full (m b)))

-- | Reifiable monad
--   
--   See "Generic Monadic Constructs for Embedded Languages" (Persson et
--   al., IFL 2011
--   <a>https://emilaxelsson.github.io/documents/persson2011generic.pdf</a>).
--   
--   It is advised to convert to/from <a>Remon</a> using the
--   <a>Syntactic</a> instance provided in the modules
--   <a>Language.Syntactic.Sugar.Monad</a> or
--   <a>Language.Syntactic.Sugar.MonadT</a>.
newtype Remon sym m a
[Remon] :: {unRemon :: forall r. Typeable r => Cont (ASTF sym (m r)) a} -> Remon sym m a

-- | One-layer desugaring of monadic actions
desugarMonad :: (MONAD m :<: sym, Typeable a, Typeable m) => Remon sym m (ASTF sym a) -> ASTF sym (m a)

-- | One-layer desugaring of monadic actions
desugarMonadTyped :: (MONAD m :<: s, sym ~ Typed s, Typeable a, Typeable m) => Remon sym m (ASTF sym a) -> ASTF sym (m a)

-- | Get the set of free variables in an expression
freeVars :: BindingDomain sym => AST sym sig -> Set Name

-- | Get the set of variables (free, bound and introduced by lambdas) in an
--   expression
allVars :: BindingDomain sym => AST sym sig -> Set Name

-- | Rename the bound variables in a term
--   
--   The free variables are left untouched. The bound variables are given
--   unique names using as small names as possible. The first argument is a
--   list of reserved names. Reserved names and names of free variables are
--   not used when renaming bound variables.
renameUnique' :: forall sym a. BindingDomain sym => [Name] -> ASTF sym a -> ASTF sym a

-- | Rename the bound variables in a term
--   
--   The free variables are left untouched. The bound variables are given
--   unique names using as small names as possible. Names of free variables
--   are not used when renaming bound variables.
renameUnique :: BindingDomain sym => ASTF sym a -> ASTF sym a

-- | Environment used by <a>alphaEq'</a>
type AlphaEnv = [(Name, Name)]
alphaEq' :: (Equality sym, BindingDomain sym) => AlphaEnv -> ASTF sym a -> ASTF sym b -> Bool

-- | Alpha-equivalence
alphaEq :: (Equality sym, BindingDomain sym) => ASTF sym a -> ASTF sym b -> Bool

-- | Semantic function type of the given symbol signature
type family Denotation sig
class Eval s
evalSym :: Eval s => s sig -> Denotation sig

-- | Evaluation
evalDen :: Eval s => AST s sig -> Denotation sig

-- | Monadic denotation; mapping from a symbol signature
--   
--   <pre>
--   a :-&gt; b :-&gt; Full c
--   </pre>
--   
--   to
--   
--   <pre>
--   m a -&gt; m b -&gt; m c
--   </pre>
type family DenotationM (m :: * -> *) sig

-- | Lift a <a>Denotation</a> to <a>DenotationM</a>
liftDenotationM :: forall m sig proxy1 proxy2. Monad m => SigRep sig -> proxy1 m -> proxy2 sig -> Denotation sig -> DenotationM m sig

-- | Runtime environment
type RunEnv = [(Name, Dynamic)]

-- | Evaluation
class EvalEnv sym env
compileSym :: EvalEnv sym env => proxy env -> sym sig -> DenotationM (Reader env) sig
compileSym :: (EvalEnv sym env, Symbol sym, Eval sym) => proxy env -> sym sig -> DenotationM (Reader env) sig

-- | Simple implementation of <a>compileSym</a> from a <a>Denotation</a>
compileSymDefault :: forall proxy env sym sig. Eval sym => SigRep sig -> proxy env -> sym sig -> DenotationM (Reader env) sig

-- | Evaluation of open terms
evalOpen :: EvalEnv sym env => env -> ASTF sym a -> a

-- | Evaluation of closed terms where <a>RunEnv</a> is used as the internal
--   environment
--   
--   (Note that there is no guarantee that the term is actually closed.)
evalClosed :: EvalEnv sym RunEnv => ASTF sym a -> a
instance GHC.Base.Functor (Language.Syntactic.Functional.Remon sym m)
instance Control.DeepSeq.NFData Language.Syntactic.Functional.Name
instance GHC.Real.Integral Language.Syntactic.Functional.Name
instance GHC.Real.Real Language.Syntactic.Functional.Name
instance GHC.Enum.Enum Language.Syntactic.Functional.Name
instance GHC.Num.Num Language.Syntactic.Functional.Name
instance GHC.Classes.Ord Language.Syntactic.Functional.Name
instance GHC.Classes.Eq Language.Syntactic.Functional.Name
instance (Language.Syntactic.Functional.EvalEnv sym1 env, Language.Syntactic.Functional.EvalEnv sym2 env) => Language.Syntactic.Functional.EvalEnv (sym1 Language.Syntactic.Syntax.:+: sym2) env
instance Language.Syntactic.Functional.EvalEnv Language.Syntactic.Syntax.Empty env
instance Language.Syntactic.Functional.EvalEnv sym env => Language.Syntactic.Functional.EvalEnv (Language.Syntactic.Syntax.Typed sym) env
instance Language.Syntactic.Functional.EvalEnv sym env => Language.Syntactic.Functional.EvalEnv (sym Language.Syntactic.Decoration.:&: info) env
instance Language.Syntactic.Functional.EvalEnv Language.Syntactic.Functional.Literal env
instance Language.Syntactic.Functional.EvalEnv Language.Syntactic.Functional.Construct env
instance Language.Syntactic.Functional.EvalEnv Language.Syntactic.Functional.Let env
instance GHC.Base.Monad m => Language.Syntactic.Functional.EvalEnv (Language.Syntactic.Functional.MONAD m) env
instance Language.Syntactic.Functional.EvalEnv Language.Syntactic.Functional.BindingT Language.Syntactic.Functional.RunEnv
instance (Language.Syntactic.Functional.Eval s, Language.Syntactic.Functional.Eval t) => Language.Syntactic.Functional.Eval (s Language.Syntactic.Syntax.:+: t)
instance Language.Syntactic.Functional.Eval Language.Syntactic.Syntax.Empty
instance Language.Syntactic.Functional.Eval sym => Language.Syntactic.Functional.Eval (sym Language.Syntactic.Decoration.:&: info)
instance Language.Syntactic.Functional.Eval Language.Syntactic.Functional.Literal
instance Language.Syntactic.Functional.Eval Language.Syntactic.Functional.Construct
instance Language.Syntactic.Functional.Eval Language.Syntactic.Functional.Let
instance GHC.Base.Monad m => Language.Syntactic.Functional.Eval (Language.Syntactic.Functional.MONAD m)
instance Language.Syntactic.Syntax.Symbol Language.Syntactic.Functional.Construct
instance Language.Syntactic.Interpretation.Render Language.Syntactic.Functional.Construct
instance Language.Syntactic.Interpretation.Equality Language.Syntactic.Functional.Construct
instance Language.Syntactic.Interpretation.StringTree Language.Syntactic.Functional.Construct
instance GHC.Base.Applicative (Language.Syntactic.Functional.Remon sym m)
instance GHC.Base.Monad (Language.Syntactic.Functional.Remon dom m)
instance Language.Syntactic.Syntax.Symbol (Language.Syntactic.Functional.MONAD m)
instance Language.Syntactic.Interpretation.Render (Language.Syntactic.Functional.MONAD m)
instance Language.Syntactic.Interpretation.Equality (Language.Syntactic.Functional.MONAD m)
instance Language.Syntactic.Interpretation.StringTree (Language.Syntactic.Functional.MONAD m)
instance Language.Syntactic.Syntax.Symbol Language.Syntactic.Functional.Let
instance Language.Syntactic.Interpretation.Render Language.Syntactic.Functional.Let
instance Language.Syntactic.Interpretation.Equality Language.Syntactic.Functional.Let
instance Language.Syntactic.Interpretation.StringTree Language.Syntactic.Functional.Let
instance (Language.Syntactic.Functional.BindingDomain sym1, Language.Syntactic.Functional.BindingDomain sym2) => Language.Syntactic.Functional.BindingDomain (sym1 Language.Syntactic.Syntax.:+: sym2)
instance Language.Syntactic.Functional.BindingDomain sym => Language.Syntactic.Functional.BindingDomain (Language.Syntactic.Syntax.Typed sym)
instance Language.Syntactic.Functional.BindingDomain sym => Language.Syntactic.Functional.BindingDomain (sym Language.Syntactic.Decoration.:&: i)
instance Language.Syntactic.Functional.BindingDomain sym => Language.Syntactic.Functional.BindingDomain (Language.Syntactic.Syntax.AST sym)
instance Language.Syntactic.Functional.BindingDomain Language.Syntactic.Functional.Binding
instance Language.Syntactic.Functional.BindingDomain Language.Syntactic.Functional.BindingT
instance Language.Syntactic.Functional.BindingDomain sym
instance Language.Syntactic.Syntax.Symbol Language.Syntactic.Functional.BindingT
instance Language.Syntactic.Syntax.NFData1 Language.Syntactic.Functional.BindingT
instance Language.Syntactic.Interpretation.Equality Language.Syntactic.Functional.BindingT
instance Language.Syntactic.Interpretation.Render Language.Syntactic.Functional.BindingT
instance Language.Syntactic.Interpretation.StringTree Language.Syntactic.Functional.BindingT
instance Language.Syntactic.Syntax.Symbol Language.Syntactic.Functional.Binding
instance Language.Syntactic.Syntax.NFData1 Language.Syntactic.Functional.Binding
instance Language.Syntactic.Interpretation.Equality Language.Syntactic.Functional.Binding
instance Language.Syntactic.Interpretation.Render Language.Syntactic.Functional.Binding
instance Language.Syntactic.Interpretation.StringTree Language.Syntactic.Functional.Binding
instance GHC.Show.Show Language.Syntactic.Functional.Name
instance Language.Syntactic.Syntax.Symbol Language.Syntactic.Functional.Literal
instance Language.Syntactic.Interpretation.Render Language.Syntactic.Functional.Literal
instance Language.Syntactic.Interpretation.Equality Language.Syntactic.Functional.Literal
instance Language.Syntactic.Interpretation.StringTree Language.Syntactic.Functional.Literal


-- | <a>Syntactic</a> instance for functions for domains based on
--   <a>Typed</a> and <a>BindingT</a>
module Language.Syntactic.Sugar.BindingTyped
instance (sym Data.Type.Equality.~ Language.Syntactic.Syntax.Typed s, Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Domain b Data.Type.Equality.~ sym, Language.Syntactic.Functional.BindingT Language.Syntactic.Syntax.:<: s, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b)) => Language.Syntactic.Sugar.Syntactic (a -> b)


-- | <a>Syntactic</a> instance for <a>Remon</a> for domains based on
--   <a>Typed</a> and <a>BindingT</a>
module Language.Syntactic.Sugar.MonadTyped

-- | One-layer sugaring of monadic actions
sugarMonad :: (sym ~ Typed s, BindingT :<: s, MONAD m :<: s, Typeable m, Typeable a) => ASTF sym (m a) -> Remon sym m (ASTF sym a)
instance (sym Data.Type.Equality.~ Language.Syntactic.Syntax.Typed s, Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Functional.BindingT Language.Syntactic.Syntax.:<: s, Language.Syntactic.Functional.MONAD m Language.Syntactic.Syntax.:<: s, Data.Typeable.Internal.Typeable m, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a)) => Language.Syntactic.Sugar.Syntactic (Language.Syntactic.Functional.Remon sym m a)


-- | <a>Syntactic</a> instance for functions for domains based on
--   <a>Binding</a>
module Language.Syntactic.Sugar.Binding
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ dom, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Domain b Data.Type.Equality.~ dom, Language.Syntactic.Functional.Binding Language.Syntactic.Syntax.:<: dom) => Language.Syntactic.Sugar.Syntactic (a -> b)


-- | <a>Syntactic</a> instance for <a>Remon</a> for domains based on
--   <a>Binding</a>
module Language.Syntactic.Sugar.Monad

-- | One-layer sugaring of monadic actions
sugarMonad :: (Binding :<: sym, MONAD m :<: sym) => ASTF sym (m a) -> Remon sym m (ASTF sym a)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Functional.Binding Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Functional.MONAD m Language.Syntactic.Syntax.:<: sym, Data.Typeable.Internal.Typeable m, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a)) => Language.Syntactic.Sugar.Syntactic (Language.Syntactic.Functional.Remon sym m a)


-- | Well-scoped terms
module Language.Syntactic.Functional.WellScoped

-- | Environment extension
class Ext ext orig

-- | Remove the extension of an environment
unext :: Ext ext orig => ext -> orig

-- | Return the amount by which an environment has been extended
diff :: (Ext ext orig, Num a) => Proxy ext -> Proxy orig -> a

-- | Lookup in an extended environment
lookEnv :: forall env a e. Ext env (a, e) => Proxy e -> Reader env a

-- | Well-scoped variable binding
--   
--   Well-scoped terms are introduced to be able to evaluate without type
--   casting. The implementation is inspired by "Typing Dynamic Typing"
--   (Baars and Swierstra, ICFP 2002,
--   <a>http://doi.acm.org/10.1145/581478.581494</a>) where expressions are
--   represented as (essentially) <tt><a>Reader</a> env a</tt> after
--   "compilation". However, a major difference is that "Typing Dynamic
--   Typing" starts from an untyped term, and thus needs (safe) dynamic
--   type casting during compilation. In contrast, the denotational
--   semantics of <a>BindingWS</a> (the <a>Eval</a> instance) uses no type
--   casting.
data BindingWS sig
[VarWS] :: Ext env (a, e) => Proxy e -> BindingWS (Full (Reader env a))
[LamWS] :: BindingWS (Reader (a, e) b :-> Full (Reader e (a -> b)))

-- | Higher-order interface for well-scoped variable binding
--   
--   Inspired by Conor McBride's "I am not a number, I am a classy hack"
--   (<a>http://mazzo.li/epilogue/index.html%3Fp=773.html</a>).
lamWS :: forall a e sym b. BindingWS :<: sym => ((forall env. Ext env (a, e) => ASTF sym (Reader env a)) -> ASTF sym (Reader (a, e) b)) -> ASTF sym (Reader e (a -> b))

-- | Evaluation of open well-scoped terms
evalOpenWS :: Eval s => env -> ASTF s (Reader env a) -> a

-- | Evaluation of closed well-scoped terms
evalClosedWS :: Eval s => ASTF s (Reader () a) -> a

-- | Mapping from a symbol signature
--   
--   <pre>
--   a :-&gt; b :-&gt; Full c
--   </pre>
--   
--   to
--   
--   <pre>
--   Reader env a :-&gt; Reader env b :-&gt; Full (Reader env c)
--   </pre>
type family LiftReader env sig
type family UnReader a

-- | Mapping from a symbol signature
--   
--   <pre>
--   Reader e a :-&gt; Reader e b :-&gt; Full (Reader e c)
--   </pre>
--   
--   to
--   
--   <pre>
--   a :-&gt; b :-&gt; Full c
--   </pre>
type family LowerReader sig

-- | Wrap a symbol to give it a <a>LiftReader</a> signature
data ReaderSym sym sig
[ReaderSym] :: (Signature sig, Denotation (LiftReader env sig) ~ DenotationM (Reader env) sig, LowerReader (LiftReader env sig) ~ sig) => Proxy env -> sym sig -> ReaderSym sym (LiftReader env sig)

-- | Well-scoped <a>AST</a>
type WS sym env a = ASTF (BindingWS :+: ReaderSym sym) (Reader env a)

-- | Convert the representation of variables and binders from
--   <a>BindingWS</a> to <a>Binding</a>. The latter is easier to analyze,
--   has a <a>Render</a> instance, etc.
fromWS :: WS sym env a -> ASTF (Binding :+: sym) a

-- | Make a smart constructor for well-scoped terms. <a>smartWS</a> has any
--   type of the form:
--   
--   <pre>
--   smartWS :: (sub :&lt;: sup, bsym ~ (BindingWS :+: ReaderSym sup))
--       =&gt; sub (a :-&gt; b :-&gt; ... :-&gt; Full x)
--       -&gt; ASTF bsym (Reader env a) -&gt; ASTF bsym (Reader env b) -&gt; ... -&gt; ASTF bsym (Reader env x)
--   </pre>
smartWS :: forall sig sig' bsym f sub sup env a. (Signature sig, Signature sig', sub :<: sup, bsym ~ (BindingWS :+: ReaderSym sup), f ~ SmartFun bsym sig', sig' ~ SmartSig f, bsym ~ SmartSym f, sig' ~ LiftReader env sig, Denotation (LiftReader env sig) ~ DenotationM (Reader env) sig, LowerReader (LiftReader env sig) ~ sig, Reader env a ~ DenResult sig') => sub sig -> f
instance Language.Syntactic.Functional.Eval sym => Language.Syntactic.Functional.Eval (Language.Syntactic.Functional.WellScoped.ReaderSym sym)
instance Language.Syntactic.Syntax.Symbol Language.Syntactic.Functional.WellScoped.BindingWS
instance Language.Syntactic.Syntax.NFData1 Language.Syntactic.Functional.WellScoped.BindingWS
instance Language.Syntactic.Functional.Eval Language.Syntactic.Functional.WellScoped.BindingWS
instance Language.Syntactic.Functional.WellScoped.Ext env env
instance (Language.Syntactic.Functional.WellScoped.Ext env e, ext Data.Type.Equality.~ (a, env)) => Language.Syntactic.Functional.WellScoped.Ext ext e


-- | Construction and elimination of tuples
module Language.Syntactic.Functional.Tuple
data Tuple a
[Pair] :: Tuple (a :-> (b :-> Full (a, b)))
[Fst] :: Tuple ((a, b) :-> Full a)
[Snd] :: Tuple ((a, b) :-> Full b)
instance Language.Syntactic.Interpretation.Render Language.Syntactic.Functional.Tuple.Tuple
instance Language.Syntactic.Interpretation.StringTree Language.Syntactic.Functional.Tuple.Tuple
instance Language.Syntactic.Functional.Eval Language.Syntactic.Functional.Tuple.Tuple
instance Language.Syntactic.Functional.EvalEnv Language.Syntactic.Functional.Tuple.Tuple env
instance Language.Syntactic.Interpretation.Equality Language.Syntactic.Functional.Tuple.Tuple
instance Language.Syntactic.Syntax.Symbol Language.Syntactic.Functional.Tuple.Tuple


-- | <a>Syntactic</a> instances for tuples and <a>Typed</a> symbol domains
module Language.Syntactic.Sugar.TupleTyped
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c) => Language.Syntactic.Sugar.Syntactic (a, b, c)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d) => Language.Syntactic.Sugar.Syntactic (a, b, c, d)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal f), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal f), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal g), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal f), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal g), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal h), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal f), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal g), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal h), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal i), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal f), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal g), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal h), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal i), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal j), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Sugar.Syntactic k, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal f), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal g), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal h), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal i), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal j), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal k), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain k) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j, k)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Sugar.Syntactic k, Language.Syntactic.Sugar.Syntactic l, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal f), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal g), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal h), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal i), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal j), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal k), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal l), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain k, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain l) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j, k, l)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Sugar.Syntactic k, Language.Syntactic.Sugar.Syntactic l, Language.Syntactic.Sugar.Syntactic m, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal f), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal g), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal h), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal i), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal j), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal k), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal l), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal m), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain k, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain l, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain m) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j, k, l, m)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Sugar.Syntactic k, Language.Syntactic.Sugar.Syntactic l, Language.Syntactic.Sugar.Syntactic m, Language.Syntactic.Sugar.Syntactic n, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal f), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal g), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal h), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal i), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal j), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal k), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal l), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal m), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal n), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain k, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain l, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain m, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain n) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Sugar.Syntactic k, Language.Syntactic.Sugar.Syntactic l, Language.Syntactic.Sugar.Syntactic m, Language.Syntactic.Sugar.Syntactic n, Language.Syntactic.Sugar.Syntactic o, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal c), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal d), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal e), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal f), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal g), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal h), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal i), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal j), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal k), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal l), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal m), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal n), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal o), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain k, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain l, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain m, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain n, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain o) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal a), Data.Typeable.Internal.Typeable (Language.Syntactic.Sugar.Internal b), Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Syntax.Typed sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b) => Language.Syntactic.Sugar.Syntactic (a, b)


-- | <a>Syntactic</a> instances for tuples
module Language.Syntactic.Sugar.Tuple
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c) => Language.Syntactic.Sugar.Syntactic (a, b, c)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d) => Language.Syntactic.Sugar.Syntactic (a, b, c, d)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Sugar.Syntactic k, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain k) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j, k)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Sugar.Syntactic k, Language.Syntactic.Sugar.Syntactic l, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain k, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain l) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j, k, l)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Sugar.Syntactic k, Language.Syntactic.Sugar.Syntactic l, Language.Syntactic.Sugar.Syntactic m, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain k, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain l, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain m) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j, k, l, m)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Sugar.Syntactic k, Language.Syntactic.Sugar.Syntactic l, Language.Syntactic.Sugar.Syntactic m, Language.Syntactic.Sugar.Syntactic n, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain k, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain l, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain m, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain n) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Sugar.Syntactic c, Language.Syntactic.Sugar.Syntactic d, Language.Syntactic.Sugar.Syntactic e, Language.Syntactic.Sugar.Syntactic f, Language.Syntactic.Sugar.Syntactic g, Language.Syntactic.Sugar.Syntactic h, Language.Syntactic.Sugar.Syntactic i, Language.Syntactic.Sugar.Syntactic j, Language.Syntactic.Sugar.Syntactic k, Language.Syntactic.Sugar.Syntactic l, Language.Syntactic.Sugar.Syntactic m, Language.Syntactic.Sugar.Syntactic n, Language.Syntactic.Sugar.Syntactic o, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ sym, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain c, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain d, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain e, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain f, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain g, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain h, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain i, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain j, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain k, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain l, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain m, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain n, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain o) => Language.Syntactic.Sugar.Syntactic (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
instance (Language.Syntactic.Sugar.Syntactic a, Language.Syntactic.Sugar.Syntactic b, Language.Syntactic.Functional.Tuple.Tuple Language.Syntactic.Syntax.:<: Language.Syntactic.Sugar.Domain a, Language.Syntactic.Sugar.Domain a Data.Type.Equality.~ Language.Syntactic.Sugar.Domain b) => Language.Syntactic.Sugar.Syntactic (a, b)


-- | Simple code motion transformation performing common sub-expression
--   elimination and variable hoisting. Note that the implementation is
--   very inefficient.
--   
--   The code is based on an implementation by Gergely Dévai.
module Language.Syntactic.Functional.Sharing

-- | Interface for injecting binding constructs
data InjDict sym a b
InjDict :: (Name -> sym (Full a)) -> (Name -> sym (b :-> Full (a -> b))) -> sym (a :-> ((a -> b) :-> Full b)) -> InjDict sym a b

-- | Inject a variable
[injVariable] :: InjDict sym a b -> Name -> sym (Full a)

-- | Inject a lambda
[injLambda] :: InjDict sym a b -> Name -> sym (b :-> Full (a -> b))

-- | Inject a "let" symbol
[injLet] :: InjDict sym a b -> sym (a :-> ((a -> b) :-> Full b))

-- | Code motion interface
data CodeMotionInterface sym
Interface :: (forall a b. ASTF sym a -> ASTF sym b -> Maybe (InjDict sym a b)) -> (forall a b. ASTF sym a -> ASTF sym b -> Maybe (ASTF sym b)) -> (forall c. ASTF sym c -> Bool) -> CodeMotionInterface sym

-- | Try to construct an <a>InjDict</a>. The first argument is the
--   expression to be shared, and the second argument the expression in
--   which it will be shared. This function can be used to transfer
--   information (e.g. from static analysis) from the shared expression to
--   the introduced variable.
[mkInjDict] :: CodeMotionInterface sym -> forall a b. ASTF sym a -> ASTF sym b -> Maybe (InjDict sym a b)

-- | Try to type cast an expression. The first argument is the expression
--   to cast. The second argument can be used to construct a witness to
--   support the casting. The resulting expression (if any) should be equal
--   to the first argument.
[castExprCM] :: CodeMotionInterface sym -> forall a b. ASTF sym a -> ASTF sym b -> Maybe (ASTF sym b)

-- | Whether a sub-expression can be hoisted over the given expression
[hoistOver] :: CodeMotionInterface sym -> forall c. ASTF sym c -> Bool

-- | Default <a>CodeMotionInterface</a> for domains of the form
--   <tt><a>Typed</a> (... <a>:+:</a> <a>Binding</a> <a>:+:</a> ...)</tt>.
defaultInterface :: forall binding sym symT. (binding :<: sym, Let :<: sym, symT ~ Typed sym) => (forall a. Typeable a => Name -> binding (Full a)) -> (forall a b. Typeable a => Name -> binding (b :-> Full (a -> b))) -> (forall a b. ASTF symT a -> ASTF symT b -> Bool) -> (forall a. ASTF symT a -> Bool) -> CodeMotionInterface symT

-- | Default <a>CodeMotionInterface</a> for domains of the form <tt>(...
--   <a>:&amp;:</a> info)</tt>, where <tt>info</tt> can be used to witness
--   type casting
defaultInterfaceDecor :: forall binding sym symI info. (binding :<: sym, Let :<: sym, symI ~ (sym :&: info)) => (forall a b. info a -> info b -> Maybe (Dict (a ~ b))) -> (forall a b. info a -> info b -> info (a -> b)) -> (forall a. info a -> Name -> binding (Full a)) -> (forall a b. info a -> info b -> Name -> binding (b :-> Full (a -> b))) -> (forall a b. ASTF symI a -> ASTF symI b -> Bool) -> (forall a. ASTF symI a -> Bool) -> CodeMotionInterface symI

-- | Perform common sub-expression elimination and variable hoisting
codeMotion :: forall sym m a. (Equality sym, BindingDomain sym) => CodeMotionInterface sym -> ASTF sym a -> ASTF sym a