{-# LANGUAGE CPP
           , GADTs
           , DataKinds
           , PolyKinds
           , ExistentialQuantification
           , StandaloneDeriving
           , TypeFamilies
           , TypeOperators
           , OverloadedStrings
           , DeriveDataTypeable
           , ScopedTypeVariables
           , RankNTypes
           , FlexibleContexts
           , LambdaCase
           #-}

{-# OPTIONS_GHC -Wall -fwarn-tabs #-}

module Language.Hakaru.Parser.AST where

import           Prelude       hiding (replicate, unlines)
import           Control.Arrow ((***))

import qualified Data.Foldable       as F
import qualified Data.Vector         as V
import qualified Data.Number.Nat     as N
import qualified Data.Number.Natural as N
import qualified Data.List.NonEmpty  as L

import Language.Hakaru.Types.DataKind
import Language.Hakaru.Types.Sing
import Language.Hakaru.Types.Coercion
import Language.Hakaru.Syntax.ABT    hiding (Var, Bind)
import Language.Hakaru.Syntax.AST
    (Literal(..), MeasureOp(..), LCs(), UnLCs ())
import qualified Language.Hakaru.Syntax.AST as T
import Language.Hakaru.Syntax.IClasses

#if __GLASGOW_HASKELL__ < 710
import Data.Monoid   (Monoid(..))
#endif

import qualified Data.Text as T
import Text.Parsec (SourcePos)
import Text.Parsec.Pos
import Data.Generics hiding ((:~:)(..))

-- N.B., because we're not using the ABT's trick for implementing a HOAS API, we can make the identifier strict.
data Name = Name {-# UNPACK #-}!N.Nat {-# UNPACK #-}!T.Text
    deriving (ReadPrec [Name]
ReadPrec Name
Int -> ReadS Name
ReadS [Name]
(Int -> ReadS Name)
-> ReadS [Name] -> ReadPrec Name -> ReadPrec [Name] -> Read Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Name]
$creadListPrec :: ReadPrec [Name]
readPrec :: ReadPrec Name
$creadPrec :: ReadPrec Name
readList :: ReadS [Name]
$creadList :: ReadS [Name]
readsPrec :: Int -> ReadS Name
$creadsPrec :: Int -> ReadS Name
Read, Int -> Name -> ShowS
[Name] -> ShowS
Name -> String
(Int -> Name -> ShowS)
-> (Name -> String) -> ([Name] -> ShowS) -> Show Name
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Name] -> ShowS
$cshowList :: [Name] -> ShowS
show :: Name -> String
$cshow :: Name -> String
showsPrec :: Int -> Name -> ShowS
$cshowsPrec :: Int -> Name -> ShowS
Show, Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq, Eq Name
Eq Name
-> (Name -> Name -> Ordering)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Name)
-> (Name -> Name -> Name)
-> Ord Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmax :: Name -> Name -> Name
>= :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c< :: Name -> Name -> Bool
compare :: Name -> Name -> Ordering
$ccompare :: Name -> Name -> Ordering
$cp1Ord :: Eq Name
Ord, Typeable Name
DataType
Constr
Typeable Name
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Name -> c Name)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Name)
-> (Name -> Constr)
-> (Name -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Name))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name))
-> ((forall b. Data b => b -> b) -> Name -> Name)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall u. (forall d. Data d => d -> u) -> Name -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Name -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> Data Name
Name -> DataType
Name -> Constr
(forall b. Data b => b -> b) -> Name -> Name
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
forall u. (forall d. Data d => d -> u) -> Name -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cName :: Constr
$tName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMp :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapM :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQ :: (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataTypeOf :: Name -> DataType
$cdataTypeOf :: Name -> DataType
toConstr :: Name -> Constr
$ctoConstr :: Name -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cp1Data :: Typeable Name
Data, Typeable)

nameID :: Name -> N.Nat
nameID :: Name -> Nat
nameID (Name Nat
i Text
_) = Nat
i

hintID :: Name -> T.Text
hintID :: Name -> Text
hintID (Name Nat
_ Text
t) = Text
t

----------------------------------------------------------------
----------------------------------------------------------------

type Name' = T.Text

data Branch' a
    = Branch'  (Pattern' Name') (AST' a)
    | Branch'' (Pattern' Name)  (AST' a)
    deriving (Branch' a -> Branch' a -> Bool
(Branch' a -> Branch' a -> Bool)
-> (Branch' a -> Branch' a -> Bool) -> Eq (Branch' a)
forall a. Eq a => Branch' a -> Branch' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Branch' a -> Branch' a -> Bool
$c/= :: forall a. Eq a => Branch' a -> Branch' a -> Bool
== :: Branch' a -> Branch' a -> Bool
$c== :: forall a. Eq a => Branch' a -> Branch' a -> Bool
Eq, Int -> Branch' a -> ShowS
[Branch' a] -> ShowS
Branch' a -> String
(Int -> Branch' a -> ShowS)
-> (Branch' a -> String)
-> ([Branch' a] -> ShowS)
-> Show (Branch' a)
forall a. Show a => Int -> Branch' a -> ShowS
forall a. Show a => [Branch' a] -> ShowS
forall a. Show a => Branch' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Branch' a] -> ShowS
$cshowList :: forall a. Show a => [Branch' a] -> ShowS
show :: Branch' a -> String
$cshow :: forall a. Show a => Branch' a -> String
showsPrec :: Int -> Branch' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Branch' a -> ShowS
Show, Typeable (Branch' a)
DataType
Constr
Typeable (Branch' a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Branch' a -> c (Branch' a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Branch' a))
-> (Branch' a -> Constr)
-> (Branch' a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Branch' a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Branch' a)))
-> ((forall b. Data b => b -> b) -> Branch' a -> Branch' a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Branch' a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Branch' a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Branch' a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Branch' a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a))
-> Data (Branch' a)
Branch' a -> DataType
Branch' a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Branch' a))
(forall b. Data b => b -> b) -> Branch' a -> Branch' a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch' a -> c (Branch' a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Branch' a)
forall a. Data a => Typeable (Branch' a)
forall a. Data a => Branch' a -> DataType
forall a. Data a => Branch' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Branch' a -> Branch' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Branch' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Branch' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Branch' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Branch' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Branch' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch' a -> c (Branch' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Branch' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Branch' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Branch' a -> u
forall u. (forall d. Data d => d -> u) -> Branch' a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Branch' a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Branch' a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Branch' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch' a -> c (Branch' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Branch' a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Branch' a))
$cBranch'' :: Constr
$cBranch' :: Constr
$tBranch' :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a)
gmapMp :: (forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a)
gmapM :: (forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Branch' a -> m (Branch' a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Branch' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Branch' a -> u
gmapQ :: (forall d. Data d => d -> u) -> Branch' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Branch' a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Branch' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Branch' a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Branch' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Branch' a -> r
gmapT :: (forall b. Data b => b -> b) -> Branch' a -> Branch' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Branch' a -> Branch' a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Branch' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Branch' a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Branch' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Branch' a))
dataTypeOf :: Branch' a -> DataType
$cdataTypeOf :: forall a. Data a => Branch' a -> DataType
toConstr :: Branch' a -> Constr
$ctoConstr :: forall a. Data a => Branch' a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Branch' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Branch' a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch' a -> c (Branch' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Branch' a -> c (Branch' a)
$cp1Data :: forall a. Data a => Typeable (Branch' a)
Data, Typeable)

data Pattern' a
    = PVar'  a
    | PWild'
    | PData' (PDatum a)
    deriving (Pattern' a -> Pattern' a -> Bool
(Pattern' a -> Pattern' a -> Bool)
-> (Pattern' a -> Pattern' a -> Bool) -> Eq (Pattern' a)
forall a. Eq a => Pattern' a -> Pattern' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pattern' a -> Pattern' a -> Bool
$c/= :: forall a. Eq a => Pattern' a -> Pattern' a -> Bool
== :: Pattern' a -> Pattern' a -> Bool
$c== :: forall a. Eq a => Pattern' a -> Pattern' a -> Bool
Eq, Int -> Pattern' a -> ShowS
[Pattern' a] -> ShowS
Pattern' a -> String
(Int -> Pattern' a -> ShowS)
-> (Pattern' a -> String)
-> ([Pattern' a] -> ShowS)
-> Show (Pattern' a)
forall a. Show a => Int -> Pattern' a -> ShowS
forall a. Show a => [Pattern' a] -> ShowS
forall a. Show a => Pattern' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Pattern' a] -> ShowS
$cshowList :: forall a. Show a => [Pattern' a] -> ShowS
show :: Pattern' a -> String
$cshow :: forall a. Show a => Pattern' a -> String
showsPrec :: Int -> Pattern' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Pattern' a -> ShowS
Show, Typeable (Pattern' a)
DataType
Constr
Typeable (Pattern' a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Pattern' a))
-> (Pattern' a -> Constr)
-> (Pattern' a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Pattern' a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Pattern' a)))
-> ((forall b. Data b => b -> b) -> Pattern' a -> Pattern' a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Pattern' a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Pattern' a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pattern' a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Pattern' a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a))
-> Data (Pattern' a)
Pattern' a -> DataType
Pattern' a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Pattern' a))
(forall b. Data b => b -> b) -> Pattern' a -> Pattern' a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pattern' a)
forall a. Data a => Typeable (Pattern' a)
forall a. Data a => Pattern' a -> DataType
forall a. Data a => Pattern' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Pattern' a -> Pattern' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Pattern' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Pattern' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pattern' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Pattern' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pattern' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Pattern' a -> u
forall u. (forall d. Data d => d -> u) -> Pattern' a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pattern' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Pattern' a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pattern' a))
$cPData' :: Constr
$cPWild' :: Constr
$cPVar' :: Constr
$tPattern' :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
gmapMp :: (forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
gmapM :: (forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Pattern' a -> m (Pattern' a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Pattern' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Pattern' a -> u
gmapQ :: (forall d. Data d => d -> u) -> Pattern' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Pattern' a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Pattern' a -> r
gmapT :: (forall b. Data b => b -> b) -> Pattern' a -> Pattern' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Pattern' a -> Pattern' a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pattern' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Pattern' a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Pattern' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Pattern' a))
dataTypeOf :: Pattern' a -> DataType
$cdataTypeOf :: forall a. Data a => Pattern' a -> DataType
toConstr :: Pattern' a -> Constr
$ctoConstr :: forall a. Data a => Pattern' a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pattern' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Pattern' a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pattern' a -> c (Pattern' a)
$cp1Data :: forall a. Data a => Typeable (Pattern' a)
Data, Typeable)

data PDatum a = DV Name' [Pattern' a]
    deriving (PDatum a -> PDatum a -> Bool
(PDatum a -> PDatum a -> Bool)
-> (PDatum a -> PDatum a -> Bool) -> Eq (PDatum a)
forall a. Eq a => PDatum a -> PDatum a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDatum a -> PDatum a -> Bool
$c/= :: forall a. Eq a => PDatum a -> PDatum a -> Bool
== :: PDatum a -> PDatum a -> Bool
$c== :: forall a. Eq a => PDatum a -> PDatum a -> Bool
Eq, Int -> PDatum a -> ShowS
[PDatum a] -> ShowS
PDatum a -> String
(Int -> PDatum a -> ShowS)
-> (PDatum a -> String) -> ([PDatum a] -> ShowS) -> Show (PDatum a)
forall a. Show a => Int -> PDatum a -> ShowS
forall a. Show a => [PDatum a] -> ShowS
forall a. Show a => PDatum a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDatum a] -> ShowS
$cshowList :: forall a. Show a => [PDatum a] -> ShowS
show :: PDatum a -> String
$cshow :: forall a. Show a => PDatum a -> String
showsPrec :: Int -> PDatum a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> PDatum a -> ShowS
Show, Typeable (PDatum a)
DataType
Constr
Typeable (PDatum a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PDatum a -> c (PDatum a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (PDatum a))
-> (PDatum a -> Constr)
-> (PDatum a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (PDatum a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (PDatum a)))
-> ((forall b. Data b => b -> b) -> PDatum a -> PDatum a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PDatum a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PDatum a -> r)
-> (forall u. (forall d. Data d => d -> u) -> PDatum a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PDatum a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a))
-> Data (PDatum a)
PDatum a -> DataType
PDatum a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (PDatum a))
(forall b. Data b => b -> b) -> PDatum a -> PDatum a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PDatum a -> c (PDatum a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PDatum a)
forall a. Data a => Typeable (PDatum a)
forall a. Data a => PDatum a -> DataType
forall a. Data a => PDatum a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> PDatum a -> PDatum a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> PDatum a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> PDatum a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PDatum a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PDatum a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PDatum a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PDatum a -> c (PDatum a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PDatum a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PDatum a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PDatum a -> u
forall u. (forall d. Data d => d -> u) -> PDatum a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PDatum a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PDatum a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PDatum a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PDatum a -> c (PDatum a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (PDatum a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PDatum a))
$cDV :: Constr
$tPDatum :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a)
gmapMp :: (forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a)
gmapM :: (forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> PDatum a -> m (PDatum a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> PDatum a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> PDatum a -> u
gmapQ :: (forall d. Data d => d -> u) -> PDatum a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> PDatum a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PDatum a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PDatum a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PDatum a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PDatum a -> r
gmapT :: (forall b. Data b => b -> b) -> PDatum a -> PDatum a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> PDatum a -> PDatum a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PDatum a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (PDatum a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (PDatum a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (PDatum a))
dataTypeOf :: PDatum a -> DataType
$cdataTypeOf :: forall a. Data a => PDatum a -> DataType
toConstr :: PDatum a -> Constr
$ctoConstr :: forall a. Data a => PDatum a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PDatum a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (PDatum a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PDatum a -> c (PDatum a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PDatum a -> c (PDatum a)
$cp1Data :: forall a. Data a => Typeable (PDatum a)
Data, Typeable)

-- Meta stores start and end position for AST in source code
data SourceSpan = SourceSpan !SourcePos !SourcePos
    deriving (SourceSpan -> SourceSpan -> Bool
(SourceSpan -> SourceSpan -> Bool)
-> (SourceSpan -> SourceSpan -> Bool) -> Eq SourceSpan
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SourceSpan -> SourceSpan -> Bool
$c/= :: SourceSpan -> SourceSpan -> Bool
== :: SourceSpan -> SourceSpan -> Bool
$c== :: SourceSpan -> SourceSpan -> Bool
Eq, Int -> SourceSpan -> ShowS
[SourceSpan] -> ShowS
SourceSpan -> String
(Int -> SourceSpan -> ShowS)
-> (SourceSpan -> String)
-> ([SourceSpan] -> ShowS)
-> Show SourceSpan
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SourceSpan] -> ShowS
$cshowList :: [SourceSpan] -> ShowS
show :: SourceSpan -> String
$cshow :: SourceSpan -> String
showsPrec :: Int -> SourceSpan -> ShowS
$cshowsPrec :: Int -> SourceSpan -> ShowS
Show, Typeable SourceSpan
DataType
Constr
Typeable SourceSpan
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SourceSpan -> c SourceSpan)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SourceSpan)
-> (SourceSpan -> Constr)
-> (SourceSpan -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SourceSpan))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SourceSpan))
-> ((forall b. Data b => b -> b) -> SourceSpan -> SourceSpan)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceSpan -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SourceSpan -> r)
-> (forall u. (forall d. Data d => d -> u) -> SourceSpan -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SourceSpan -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan)
-> Data SourceSpan
SourceSpan -> DataType
SourceSpan -> Constr
(forall b. Data b => b -> b) -> SourceSpan -> SourceSpan
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceSpan -> c SourceSpan
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceSpan
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SourceSpan -> u
forall u. (forall d. Data d => d -> u) -> SourceSpan -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceSpan
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceSpan -> c SourceSpan
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceSpan)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceSpan)
$cSourceSpan :: Constr
$tSourceSpan :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
gmapMp :: (forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
gmapM :: (forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SourceSpan -> m SourceSpan
gmapQi :: Int -> (forall d. Data d => d -> u) -> SourceSpan -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SourceSpan -> u
gmapQ :: (forall d. Data d => d -> u) -> SourceSpan -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SourceSpan -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SourceSpan -> r
gmapT :: (forall b. Data b => b -> b) -> SourceSpan -> SourceSpan
$cgmapT :: (forall b. Data b => b -> b) -> SourceSpan -> SourceSpan
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceSpan)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SourceSpan)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SourceSpan)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SourceSpan)
dataTypeOf :: SourceSpan -> DataType
$cdataTypeOf :: SourceSpan -> DataType
toConstr :: SourceSpan -> Constr
$ctoConstr :: SourceSpan -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceSpan
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SourceSpan
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceSpan -> c SourceSpan
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SourceSpan -> c SourceSpan
$cp1Data :: Typeable SourceSpan
Data, Typeable)

printSourceSpan :: SourceSpan -> V.Vector T.Text -> T.Text
printSourceSpan :: SourceSpan -> Vector Text -> Text
printSourceSpan (SourceSpan SourcePos
start SourcePos
stop) Vector Text
input
  = [Text] -> Text
T.unlines ((Int -> [Text]) -> [Int] -> [Text]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Int -> [Text]
line [Int
startLine..Int
stopLine])
  where
  line :: Int -> [T.Text]
  line :: Int -> [Text]
line Int
i | (SourcePos -> Int
sourceLine SourcePos
start, SourcePos -> Int
sourceColumn SourcePos
start) (Int, Int) -> (Int, Int) -> Bool
forall a. Ord a => a -> a -> Bool
<= (Int
i, Int
1) Bool -> Bool -> Bool
&&
           (Int
i, Int
eol) (Int, Int) -> (Int, Int) -> Bool
forall a. Ord a => a -> a -> Bool
<= (SourcePos -> Int
sourceLine SourcePos
stop, SourcePos -> Int
sourceColumn SourcePos
stop)
         = [Text
T.empty | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
startLine] [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++
           [Char -> Text
quote Char
'>'] [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++
           [Text
T.empty | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
stopLine]
         | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
stopLine
         = [Text
T.empty | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
startLine] [Text] -> [Text] -> [Text]
forall a. [a] -> [a] -> [a]
++
           [Char -> Text
quote Char
' ',
            Int -> Int -> Char -> Text
marking (if Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== SourcePos -> Int
sourceLine SourcePos
start then SourcePos -> Int
sourceColumn SourcePos
start else Int
1)
                    (if Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== SourcePos -> Int
sourceLine SourcePos
stop  then SourcePos -> Int
sourceColumn SourcePos
stop  else Int
eol)
                    Char
'^']
         | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== SourcePos -> Int
sourceLine SourcePos
start
         = [Int -> Int -> Char -> Text
marking (SourcePos -> Int
sourceColumn SourcePos
start) Int
eol Char
'.',
            Char -> Text
quote Char
' ']
         | Bool
otherwise
         = [Char -> Text
quote Char
' ']
    where numbering :: Text
numbering = String -> Text
T.pack (Int -> String
forall a. Show a => a -> String
show Int
i)
          lining :: Text
lining    = Vector Text
input Vector Text -> Int -> Text
forall a. Vector a -> Int -> a
V.! (Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1)
          eol :: Int
eol       = Text -> Int
T.length Text
lining Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1
          quote :: Char -> Text
quote Char
c   = Int -> Text
spacing (Int
digits Int -> Int -> Int
forall a. Num a => a -> a -> a
- Text -> Int
T.length Text
numbering)
                      Text -> Text -> Text
`T.append` Text
numbering
                      Text -> Text -> Text
`T.append` Char -> Text
T.singleton Char
'|'
                      Text -> Text -> Text
`T.append` Char -> Text
T.singleton Char
c
                      Text -> Text -> Text
`T.append` Text
lining
  spacing :: Int -> Text
spacing Int
k     = Int -> Text -> Text
T.replicate Int
k (Char -> Text
T.singleton Char
' ')
  marking :: Int -> Int -> Char -> Text
marking Int
l Int
r Char
c = Int -> Text
spacing (Int
digits Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
l)
                  Text -> Text -> Text
`T.append` Int -> Text -> Text
T.replicate (Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
1 (Int
r Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
l)) (Char -> Text
T.singleton Char
c)
  startLine :: Int
startLine     = Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
1
                (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ SourcePos -> Int
sourceLine SourcePos
start
  stopLine :: Int
stopLine      = Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
startLine
                (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Int
forall a. Ord a => a -> a -> a
min (Vector Text -> Int
forall a. Vector a -> Int
V.length Vector Text
input)
                (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ (if SourcePos -> Int
sourceColumn SourcePos
stop Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
1 then Int -> Int
forall a. Enum a => a -> a
pred else Int -> Int
forall a. a -> a
id)
                (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ SourcePos -> Int
sourceLine SourcePos
stop
  digits :: Int
digits        = Int -> Int -> Int
forall a a. (Integral a, Num a) => a -> a -> a
loop Int
stopLine Int
1
    where loop :: a -> a -> a
loop a
i a
res | a
i a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
10    = a
res
                     | Bool
otherwise = (a -> a -> a
loop (a -> a -> a) -> a -> a -> a
forall a b. (a -> b) -> a -> b
$! a -> a -> a
forall a. Integral a => a -> a -> a
div a
i a
10) (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$! (a
res a -> a -> a
forall a. Num a => a -> a -> a
+ a
1)

data Literal'
    = Nat  Integer
    | Int  Integer
    | Prob Rational
    | Real Rational
    deriving (Literal' -> Literal' -> Bool
(Literal' -> Literal' -> Bool)
-> (Literal' -> Literal' -> Bool) -> Eq Literal'
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Literal' -> Literal' -> Bool
$c/= :: Literal' -> Literal' -> Bool
== :: Literal' -> Literal' -> Bool
$c== :: Literal' -> Literal' -> Bool
Eq, Int -> Literal' -> ShowS
[Literal'] -> ShowS
Literal' -> String
(Int -> Literal' -> ShowS)
-> (Literal' -> String) -> ([Literal'] -> ShowS) -> Show Literal'
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Literal'] -> ShowS
$cshowList :: [Literal'] -> ShowS
show :: Literal' -> String
$cshow :: Literal' -> String
showsPrec :: Int -> Literal' -> ShowS
$cshowsPrec :: Int -> Literal' -> ShowS
Show, Typeable Literal'
DataType
Constr
Typeable Literal'
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Literal' -> c Literal')
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Literal')
-> (Literal' -> Constr)
-> (Literal' -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Literal'))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal'))
-> ((forall b. Data b => b -> b) -> Literal' -> Literal')
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal' -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal' -> r)
-> (forall u. (forall d. Data d => d -> u) -> Literal' -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Literal' -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Literal' -> m Literal')
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal' -> m Literal')
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal' -> m Literal')
-> Data Literal'
Literal' -> DataType
Literal' -> Constr
(forall b. Data b => b -> b) -> Literal' -> Literal'
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal' -> c Literal'
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal'
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Literal' -> u
forall u. (forall d. Data d => d -> u) -> Literal' -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal' -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal' -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal' -> m Literal'
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal' -> m Literal'
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal'
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal' -> c Literal'
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal')
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal')
$cReal :: Constr
$cProb :: Constr
$cInt :: Constr
$cNat :: Constr
$tLiteral' :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Literal' -> m Literal'
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal' -> m Literal'
gmapMp :: (forall d. Data d => d -> m d) -> Literal' -> m Literal'
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal' -> m Literal'
gmapM :: (forall d. Data d => d -> m d) -> Literal' -> m Literal'
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal' -> m Literal'
gmapQi :: Int -> (forall d. Data d => d -> u) -> Literal' -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal' -> u
gmapQ :: (forall d. Data d => d -> u) -> Literal' -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Literal' -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal' -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal' -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal' -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal' -> r
gmapT :: (forall b. Data b => b -> b) -> Literal' -> Literal'
$cgmapT :: (forall b. Data b => b -> b) -> Literal' -> Literal'
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal')
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal')
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Literal')
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal')
dataTypeOf :: Literal' -> DataType
$cdataTypeOf :: Literal' -> DataType
toConstr :: Literal' -> Constr
$ctoConstr :: Literal' -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal'
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal'
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal' -> c Literal'
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal' -> c Literal'
$cp1Data :: Typeable Literal'
Data, Typeable)

data NaryOp
    = And | Or   | Xor
    | Iff | Min  | Max
    | Sum | Prod
    deriving (NaryOp -> NaryOp -> Bool
(NaryOp -> NaryOp -> Bool)
-> (NaryOp -> NaryOp -> Bool) -> Eq NaryOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NaryOp -> NaryOp -> Bool
$c/= :: NaryOp -> NaryOp -> Bool
== :: NaryOp -> NaryOp -> Bool
$c== :: NaryOp -> NaryOp -> Bool
Eq, Int -> NaryOp -> ShowS
[NaryOp] -> ShowS
NaryOp -> String
(Int -> NaryOp -> ShowS)
-> (NaryOp -> String) -> ([NaryOp] -> ShowS) -> Show NaryOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NaryOp] -> ShowS
$cshowList :: [NaryOp] -> ShowS
show :: NaryOp -> String
$cshow :: NaryOp -> String
showsPrec :: Int -> NaryOp -> ShowS
$cshowsPrec :: Int -> NaryOp -> ShowS
Show, Typeable NaryOp
DataType
Constr
Typeable NaryOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NaryOp -> c NaryOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NaryOp)
-> (NaryOp -> Constr)
-> (NaryOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NaryOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NaryOp))
-> ((forall b. Data b => b -> b) -> NaryOp -> NaryOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NaryOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NaryOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> NaryOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> NaryOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NaryOp -> m NaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NaryOp -> m NaryOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NaryOp -> m NaryOp)
-> Data NaryOp
NaryOp -> DataType
NaryOp -> Constr
(forall b. Data b => b -> b) -> NaryOp -> NaryOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NaryOp -> c NaryOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NaryOp
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NaryOp -> u
forall u. (forall d. Data d => d -> u) -> NaryOp -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NaryOp -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NaryOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NaryOp -> m NaryOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NaryOp -> m NaryOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NaryOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NaryOp -> c NaryOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NaryOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NaryOp)
$cProd :: Constr
$cSum :: Constr
$cMax :: Constr
$cMin :: Constr
$cIff :: Constr
$cXor :: Constr
$cOr :: Constr
$cAnd :: Constr
$tNaryOp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> NaryOp -> m NaryOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NaryOp -> m NaryOp
gmapMp :: (forall d. Data d => d -> m d) -> NaryOp -> m NaryOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NaryOp -> m NaryOp
gmapM :: (forall d. Data d => d -> m d) -> NaryOp -> m NaryOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NaryOp -> m NaryOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> NaryOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NaryOp -> u
gmapQ :: (forall d. Data d => d -> u) -> NaryOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NaryOp -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NaryOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> NaryOp -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NaryOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> NaryOp -> r
gmapT :: (forall b. Data b => b -> b) -> NaryOp -> NaryOp
$cgmapT :: (forall b. Data b => b -> b) -> NaryOp -> NaryOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NaryOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NaryOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NaryOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NaryOp)
dataTypeOf :: NaryOp -> DataType
$cdataTypeOf :: NaryOp -> DataType
toConstr :: NaryOp -> Constr
$ctoConstr :: NaryOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NaryOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NaryOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NaryOp -> c NaryOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NaryOp -> c NaryOp
$cp1Data :: Typeable NaryOp
Data, Typeable)

data ArrayOp = Index_ | Size | Reduce deriving (Typeable ArrayOp
DataType
Constr
Typeable ArrayOp
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ArrayOp -> c ArrayOp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ArrayOp)
-> (ArrayOp -> Constr)
-> (ArrayOp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ArrayOp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayOp))
-> ((forall b. Data b => b -> b) -> ArrayOp -> ArrayOp)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ArrayOp -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ArrayOp -> r)
-> (forall u. (forall d. Data d => d -> u) -> ArrayOp -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ArrayOp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp)
-> Data ArrayOp
ArrayOp -> DataType
ArrayOp -> Constr
(forall b. Data b => b -> b) -> ArrayOp -> ArrayOp
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArrayOp -> c ArrayOp
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArrayOp
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ArrayOp -> u
forall u. (forall d. Data d => d -> u) -> ArrayOp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayOp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayOp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArrayOp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArrayOp -> c ArrayOp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArrayOp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayOp)
$cReduce :: Constr
$cSize :: Constr
$cIndex_ :: Constr
$tArrayOp :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp
gmapMp :: (forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp
gmapM :: (forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ArrayOp -> m ArrayOp
gmapQi :: Int -> (forall d. Data d => d -> u) -> ArrayOp -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ArrayOp -> u
gmapQ :: (forall d. Data d => d -> u) -> ArrayOp -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ArrayOp -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayOp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayOp -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayOp -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ArrayOp -> r
gmapT :: (forall b. Data b => b -> b) -> ArrayOp -> ArrayOp
$cgmapT :: (forall b. Data b => b -> b) -> ArrayOp -> ArrayOp
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayOp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ArrayOp)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c ArrayOp)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ArrayOp)
dataTypeOf :: ArrayOp -> DataType
$cdataTypeOf :: ArrayOp -> DataType
toConstr :: ArrayOp -> Constr
$ctoConstr :: ArrayOp -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArrayOp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ArrayOp
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArrayOp -> c ArrayOp
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ArrayOp -> c ArrayOp
$cp1Data :: Typeable ArrayOp
Data, Typeable)

data TypeAST'
    = TypeVar Name'
    | TypeApp Name'    [TypeAST']
    | TypeFun TypeAST' TypeAST'
    deriving (TypeAST' -> TypeAST' -> Bool
(TypeAST' -> TypeAST' -> Bool)
-> (TypeAST' -> TypeAST' -> Bool) -> Eq TypeAST'
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeAST' -> TypeAST' -> Bool
$c/= :: TypeAST' -> TypeAST' -> Bool
== :: TypeAST' -> TypeAST' -> Bool
$c== :: TypeAST' -> TypeAST' -> Bool
Eq, Int -> TypeAST' -> ShowS
[TypeAST'] -> ShowS
TypeAST' -> String
(Int -> TypeAST' -> ShowS)
-> (TypeAST' -> String) -> ([TypeAST'] -> ShowS) -> Show TypeAST'
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TypeAST'] -> ShowS
$cshowList :: [TypeAST'] -> ShowS
show :: TypeAST' -> String
$cshow :: TypeAST' -> String
showsPrec :: Int -> TypeAST' -> ShowS
$cshowsPrec :: Int -> TypeAST' -> ShowS
Show, Typeable TypeAST'
DataType
Constr
Typeable TypeAST'
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TypeAST' -> c TypeAST')
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TypeAST')
-> (TypeAST' -> Constr)
-> (TypeAST' -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TypeAST'))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeAST'))
-> ((forall b. Data b => b -> b) -> TypeAST' -> TypeAST')
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeAST' -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TypeAST' -> r)
-> (forall u. (forall d. Data d => d -> u) -> TypeAST' -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TypeAST' -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST')
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST')
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST')
-> Data TypeAST'
TypeAST' -> DataType
TypeAST' -> Constr
(forall b. Data b => b -> b) -> TypeAST' -> TypeAST'
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeAST' -> c TypeAST'
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeAST'
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TypeAST' -> u
forall u. (forall d. Data d => d -> u) -> TypeAST' -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeAST' -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeAST' -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST'
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST'
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeAST'
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeAST' -> c TypeAST'
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeAST')
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeAST')
$cTypeFun :: Constr
$cTypeApp :: Constr
$cTypeVar :: Constr
$tTypeAST' :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST'
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST'
gmapMp :: (forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST'
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST'
gmapM :: (forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST'
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TypeAST' -> m TypeAST'
gmapQi :: Int -> (forall d. Data d => d -> u) -> TypeAST' -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TypeAST' -> u
gmapQ :: (forall d. Data d => d -> u) -> TypeAST' -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TypeAST' -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeAST' -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TypeAST' -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeAST' -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TypeAST' -> r
gmapT :: (forall b. Data b => b -> b) -> TypeAST' -> TypeAST'
$cgmapT :: (forall b. Data b => b -> b) -> TypeAST' -> TypeAST'
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeAST')
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TypeAST')
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TypeAST')
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TypeAST')
dataTypeOf :: TypeAST' -> DataType
$cdataTypeOf :: TypeAST' -> DataType
toConstr :: TypeAST' -> Constr
$ctoConstr :: TypeAST' -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeAST'
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TypeAST'
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeAST' -> c TypeAST'
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TypeAST' -> c TypeAST'
$cp1Data :: Typeable TypeAST'
Data, Typeable)

data Reducer' a
    = R_Fanout (Reducer' a) (Reducer' a)
    | R_Index a (AST' a) (AST' a) (Reducer' a)
    | R_Split (AST' a) (Reducer' a) (Reducer' a)
    | R_Nop
    | R_Add (AST' a)
    deriving (Reducer' a -> Reducer' a -> Bool
(Reducer' a -> Reducer' a -> Bool)
-> (Reducer' a -> Reducer' a -> Bool) -> Eq (Reducer' a)
forall a. Eq a => Reducer' a -> Reducer' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Reducer' a -> Reducer' a -> Bool
$c/= :: forall a. Eq a => Reducer' a -> Reducer' a -> Bool
== :: Reducer' a -> Reducer' a -> Bool
$c== :: forall a. Eq a => Reducer' a -> Reducer' a -> Bool
Eq, Int -> Reducer' a -> ShowS
[Reducer' a] -> ShowS
Reducer' a -> String
(Int -> Reducer' a -> ShowS)
-> (Reducer' a -> String)
-> ([Reducer' a] -> ShowS)
-> Show (Reducer' a)
forall a. Show a => Int -> Reducer' a -> ShowS
forall a. Show a => [Reducer' a] -> ShowS
forall a. Show a => Reducer' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Reducer' a] -> ShowS
$cshowList :: forall a. Show a => [Reducer' a] -> ShowS
show :: Reducer' a -> String
$cshow :: forall a. Show a => Reducer' a -> String
showsPrec :: Int -> Reducer' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Reducer' a -> ShowS
Show, Typeable (Reducer' a)
DataType
Constr
Typeable (Reducer' a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Reducer' a -> c (Reducer' a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Reducer' a))
-> (Reducer' a -> Constr)
-> (Reducer' a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Reducer' a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Reducer' a)))
-> ((forall b. Data b => b -> b) -> Reducer' a -> Reducer' a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Reducer' a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Reducer' a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Reducer' a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Reducer' a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a))
-> Data (Reducer' a)
Reducer' a -> DataType
Reducer' a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (Reducer' a))
(forall b. Data b => b -> b) -> Reducer' a -> Reducer' a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Reducer' a -> c (Reducer' a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Reducer' a)
forall a. Data a => Typeable (Reducer' a)
forall a. Data a => Reducer' a -> DataType
forall a. Data a => Reducer' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> Reducer' a -> Reducer' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Reducer' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Reducer' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Reducer' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Reducer' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Reducer' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Reducer' a -> c (Reducer' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Reducer' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Reducer' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Reducer' a -> u
forall u. (forall d. Data d => d -> u) -> Reducer' a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Reducer' a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Reducer' a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Reducer' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Reducer' a -> c (Reducer' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Reducer' a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Reducer' a))
$cR_Add :: Constr
$cR_Nop :: Constr
$cR_Split :: Constr
$cR_Index :: Constr
$cR_Fanout :: Constr
$tReducer' :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a)
gmapMp :: (forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a)
gmapM :: (forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Reducer' a -> m (Reducer' a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Reducer' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Reducer' a -> u
gmapQ :: (forall d. Data d => d -> u) -> Reducer' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Reducer' a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Reducer' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Reducer' a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Reducer' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Reducer' a -> r
gmapT :: (forall b. Data b => b -> b) -> Reducer' a -> Reducer' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Reducer' a -> Reducer' a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Reducer' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Reducer' a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Reducer' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Reducer' a))
dataTypeOf :: Reducer' a -> DataType
$cdataTypeOf :: forall a. Data a => Reducer' a -> DataType
toConstr :: Reducer' a -> Constr
$ctoConstr :: forall a. Data a => Reducer' a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Reducer' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Reducer' a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Reducer' a -> c (Reducer' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Reducer' a -> c (Reducer' a)
$cp1Data :: forall a. Data a => Typeable (Reducer' a)
Data, Typeable)

data Transform'
    = Observe
    | MH
    | MCMC
    | Disint T.TransformImpl
    | Summarize
    | Simplify
    | Reparam
    | Expect
    deriving (Transform' -> Transform' -> Bool
(Transform' -> Transform' -> Bool)
-> (Transform' -> Transform' -> Bool) -> Eq Transform'
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Transform' -> Transform' -> Bool
$c/= :: Transform' -> Transform' -> Bool
== :: Transform' -> Transform' -> Bool
$c== :: Transform' -> Transform' -> Bool
Eq, Int -> Transform' -> ShowS
[Transform'] -> ShowS
Transform' -> String
(Int -> Transform' -> ShowS)
-> (Transform' -> String)
-> ([Transform'] -> ShowS)
-> Show Transform'
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Transform'] -> ShowS
$cshowList :: [Transform'] -> ShowS
show :: Transform' -> String
$cshow :: Transform' -> String
showsPrec :: Int -> Transform' -> ShowS
$cshowsPrec :: Int -> Transform' -> ShowS
Show, Typeable Transform'
DataType
Constr
Typeable Transform'
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Transform' -> c Transform')
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Transform')
-> (Transform' -> Constr)
-> (Transform' -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Transform'))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Transform'))
-> ((forall b. Data b => b -> b) -> Transform' -> Transform')
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Transform' -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Transform' -> r)
-> (forall u. (forall d. Data d => d -> u) -> Transform' -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Transform' -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Transform' -> m Transform')
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Transform' -> m Transform')
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Transform' -> m Transform')
-> Data Transform'
Transform' -> DataType
Transform' -> Constr
(forall b. Data b => b -> b) -> Transform' -> Transform'
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Transform' -> c Transform'
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Transform'
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Transform' -> u
forall u. (forall d. Data d => d -> u) -> Transform' -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Transform' -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Transform' -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Transform' -> m Transform'
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Transform' -> m Transform'
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Transform'
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Transform' -> c Transform'
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Transform')
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Transform')
$cExpect :: Constr
$cReparam :: Constr
$cSimplify :: Constr
$cSummarize :: Constr
$cDisint :: Constr
$cMCMC :: Constr
$cMH :: Constr
$cObserve :: Constr
$tTransform' :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Transform' -> m Transform'
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Transform' -> m Transform'
gmapMp :: (forall d. Data d => d -> m d) -> Transform' -> m Transform'
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Transform' -> m Transform'
gmapM :: (forall d. Data d => d -> m d) -> Transform' -> m Transform'
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Transform' -> m Transform'
gmapQi :: Int -> (forall d. Data d => d -> u) -> Transform' -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Transform' -> u
gmapQ :: (forall d. Data d => d -> u) -> Transform' -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Transform' -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Transform' -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Transform' -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Transform' -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Transform' -> r
gmapT :: (forall b. Data b => b -> b) -> Transform' -> Transform'
$cgmapT :: (forall b. Data b => b -> b) -> Transform' -> Transform'
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Transform')
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Transform')
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Transform')
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Transform')
dataTypeOf :: Transform' -> DataType
$cdataTypeOf :: Transform' -> DataType
toConstr :: Transform' -> Constr
$ctoConstr :: Transform' -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Transform'
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Transform'
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Transform' -> c Transform'
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Transform' -> c Transform'
$cp1Data :: Typeable Transform'
Data, Typeable)

trFromTyped :: T.Transform as x -> Transform'
trFromTyped :: Transform as x -> Transform'
trFromTyped = \case
  Transform as x
T.Observe   -> Transform'
Observe
  Transform as x
T.MH        -> Transform'
MH
  Transform as x
T.MCMC      -> Transform'
MCMC
  T.Disint TransformImpl
k  -> TransformImpl -> Transform'
Disint TransformImpl
k
  Transform as x
T.Summarize -> Transform'
Summarize
  Transform as x
T.Simplify  -> Transform'
Simplify
  Transform as x
T.Reparam   -> Transform'
Reparam
  Transform as x
T.Expect    -> Transform'
Expect

data AST' a
    = Var a
    | Lam a TypeAST' (AST' a)
    | App (AST' a) (AST' a)
    | Let a    (AST' a) (AST' a)
    | If  (AST' a) (AST' a) (AST' a)
    | Ann (AST' a) TypeAST'
    | Infinity'
    | ULiteral Literal'
    | NaryOp NaryOp [AST' a]
    | Unit
    | Pair (AST' a) (AST' a)
    | Array a (AST' a) (AST' a)
    | ArrayLiteral [AST' a]
    | Index (AST' a) (AST' a)
    | Case  (AST' a) [(Branch' a)] -- match
    | Bind  a  (AST' a) (AST' a)
    | Plate a  (AST' a) (AST' a)
    | Chain a  (AST' a) (AST' a) (AST' a)
    | Integrate a (AST' a) (AST' a) (AST' a)
    | Summate   a (AST' a) (AST' a) (AST' a)
    | Product   a (AST' a) (AST' a) (AST' a)
    | Bucket    a (AST' a) (AST' a) (Reducer' a)
    | Transform Transform' (SArgs' a)
    | Msum  [AST' a]
    | Data  a [a] [TypeAST'] (AST' a)
    | WithMeta (AST' a) SourceSpan
    deriving (Int -> AST' a -> ShowS
[AST' a] -> ShowS
AST' a -> String
(Int -> AST' a -> ShowS)
-> (AST' a -> String) -> ([AST' a] -> ShowS) -> Show (AST' a)
forall a. Show a => Int -> AST' a -> ShowS
forall a. Show a => [AST' a] -> ShowS
forall a. Show a => AST' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AST' a] -> ShowS
$cshowList :: forall a. Show a => [AST' a] -> ShowS
show :: AST' a -> String
$cshow :: forall a. Show a => AST' a -> String
showsPrec :: Int -> AST' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> AST' a -> ShowS
Show, Typeable (AST' a)
DataType
Constr
Typeable (AST' a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> AST' a -> c (AST' a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (AST' a))
-> (AST' a -> Constr)
-> (AST' a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (AST' a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AST' a)))
-> ((forall b. Data b => b -> b) -> AST' a -> AST' a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AST' a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AST' a -> r)
-> (forall u. (forall d. Data d => d -> u) -> AST' a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> AST' a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AST' a -> m (AST' a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AST' a -> m (AST' a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AST' a -> m (AST' a))
-> Data (AST' a)
AST' a -> DataType
AST' a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (AST' a))
(forall b. Data b => b -> b) -> AST' a -> AST' a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AST' a -> c (AST' a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AST' a)
forall a. Data a => Typeable (AST' a)
forall a. Data a => AST' a -> DataType
forall a. Data a => AST' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> AST' a -> AST' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> AST' a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> AST' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AST' a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AST' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> AST' a -> m (AST' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> AST' a -> m (AST' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AST' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AST' a -> c (AST' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AST' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AST' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> AST' a -> u
forall u. (forall d. Data d => d -> u) -> AST' a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AST' a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AST' a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AST' a -> m (AST' a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AST' a -> m (AST' a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AST' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AST' a -> c (AST' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (AST' a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AST' a))
$cWithMeta :: Constr
$cData :: Constr
$cMsum :: Constr
$cTransform :: Constr
$cBucket :: Constr
$cProduct :: Constr
$cSummate :: Constr
$cIntegrate :: Constr
$cChain :: Constr
$cPlate :: Constr
$cBind :: Constr
$cCase :: Constr
$cIndex :: Constr
$cArrayLiteral :: Constr
$cArray :: Constr
$cPair :: Constr
$cUnit :: Constr
$cNaryOp :: Constr
$cULiteral :: Constr
$cInfinity' :: Constr
$cAnn :: Constr
$cIf :: Constr
$cLet :: Constr
$cApp :: Constr
$cLam :: Constr
$cVar :: Constr
$tAST' :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> AST' a -> m (AST' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> AST' a -> m (AST' a)
gmapMp :: (forall d. Data d => d -> m d) -> AST' a -> m (AST' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> AST' a -> m (AST' a)
gmapM :: (forall d. Data d => d -> m d) -> AST' a -> m (AST' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> AST' a -> m (AST' a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> AST' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> AST' a -> u
gmapQ :: (forall d. Data d => d -> u) -> AST' a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> AST' a -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AST' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AST' a -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AST' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AST' a -> r
gmapT :: (forall b. Data b => b -> b) -> AST' a -> AST' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> AST' a -> AST' a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AST' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (AST' a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (AST' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (AST' a))
dataTypeOf :: AST' a -> DataType
$cdataTypeOf :: forall a. Data a => AST' a -> DataType
toConstr :: AST' a -> Constr
$ctoConstr :: forall a. Data a => AST' a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AST' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (AST' a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AST' a -> c (AST' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AST' a -> c (AST' a)
$cp1Data :: forall a. Data a => Typeable (AST' a)
Data, Typeable)

newtype SArgs' a = SArgs' [ ([a], AST' a) ]
    deriving (SArgs' a -> SArgs' a -> Bool
(SArgs' a -> SArgs' a -> Bool)
-> (SArgs' a -> SArgs' a -> Bool) -> Eq (SArgs' a)
forall a. Eq a => SArgs' a -> SArgs' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SArgs' a -> SArgs' a -> Bool
$c/= :: forall a. Eq a => SArgs' a -> SArgs' a -> Bool
== :: SArgs' a -> SArgs' a -> Bool
$c== :: forall a. Eq a => SArgs' a -> SArgs' a -> Bool
Eq, Int -> SArgs' a -> ShowS
[SArgs' a] -> ShowS
SArgs' a -> String
(Int -> SArgs' a -> ShowS)
-> (SArgs' a -> String) -> ([SArgs' a] -> ShowS) -> Show (SArgs' a)
forall a. Show a => Int -> SArgs' a -> ShowS
forall a. Show a => [SArgs' a] -> ShowS
forall a. Show a => SArgs' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SArgs' a] -> ShowS
$cshowList :: forall a. Show a => [SArgs' a] -> ShowS
show :: SArgs' a -> String
$cshow :: forall a. Show a => SArgs' a -> String
showsPrec :: Int -> SArgs' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> SArgs' a -> ShowS
Show, Typeable (SArgs' a)
DataType
Constr
Typeable (SArgs' a)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> SArgs' a -> c (SArgs' a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (SArgs' a))
-> (SArgs' a -> Constr)
-> (SArgs' a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (SArgs' a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SArgs' a)))
-> ((forall b. Data b => b -> b) -> SArgs' a -> SArgs' a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SArgs' a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SArgs' a -> r)
-> (forall u. (forall d. Data d => d -> u) -> SArgs' a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SArgs' a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a))
-> Data (SArgs' a)
SArgs' a -> DataType
SArgs' a -> Constr
(forall d. Data d => c (t d)) -> Maybe (c (SArgs' a))
(forall b. Data b => b -> b) -> SArgs' a -> SArgs' a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SArgs' a -> c (SArgs' a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SArgs' a)
forall a. Data a => Typeable (SArgs' a)
forall a. Data a => SArgs' a -> DataType
forall a. Data a => SArgs' a -> Constr
forall a.
Data a =>
(forall b. Data b => b -> b) -> SArgs' a -> SArgs' a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SArgs' a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> SArgs' a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SArgs' a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SArgs' a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SArgs' a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SArgs' a -> c (SArgs' a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SArgs' a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SArgs' a))
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SArgs' a -> u
forall u. (forall d. Data d => d -> u) -> SArgs' a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SArgs' a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SArgs' a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SArgs' a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SArgs' a -> c (SArgs' a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (SArgs' a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SArgs' a))
$cSArgs' :: Constr
$tSArgs' :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a)
gmapMp :: (forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a)
gmapM :: (forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> SArgs' a -> m (SArgs' a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> SArgs' a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> SArgs' a -> u
gmapQ :: (forall d. Data d => d -> u) -> SArgs' a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> SArgs' a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SArgs' a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SArgs' a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SArgs' a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SArgs' a -> r
gmapT :: (forall b. Data b => b -> b) -> SArgs' a -> SArgs' a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> SArgs' a -> SArgs' a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SArgs' a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (SArgs' a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (SArgs' a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (SArgs' a))
dataTypeOf :: SArgs' a -> DataType
$cdataTypeOf :: forall a. Data a => SArgs' a -> DataType
toConstr :: SArgs' a -> Constr
$ctoConstr :: forall a. Data a => SArgs' a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SArgs' a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (SArgs' a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SArgs' a -> c (SArgs' a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SArgs' a -> c (SArgs' a)
$cp1Data :: forall a. Data a => Typeable (SArgs' a)
Data, Typeable)

-- For backwards compatibility
_Expect :: a -> AST' a -> AST' a -> AST' a
_Expect :: a -> AST' a -> AST' a -> AST' a
_Expect a
v AST' a
a AST' a
b = Transform' -> SArgs' a -> AST' a
forall a. Transform' -> SArgs' a -> AST' a
Transform Transform'
Expect (SArgs' a -> AST' a) -> SArgs' a -> AST' a
forall a b. (a -> b) -> a -> b
$ [([a], AST' a)] -> SArgs' a
forall a. [([a], AST' a)] -> SArgs' a
SArgs' ([([a], AST' a)] -> SArgs' a) -> [([a], AST' a)] -> SArgs' a
forall a b. (a -> b) -> a -> b
$ [ ([], AST' a
a), ([a
v], AST' a
b) ]

withoutMeta :: AST' a -> AST' a
withoutMeta :: AST' a -> AST' a
withoutMeta (WithMeta AST' a
e SourceSpan
_) = AST' a -> AST' a
forall a. AST' a -> AST' a
withoutMeta AST' a
e
withoutMeta           AST' a
e    =             AST' a
e

withoutMetaE :: forall a . Data a => AST' a -> AST' a
withoutMetaE :: AST' a -> AST' a
withoutMetaE = (forall b. Data b => b -> b) -> forall b. Data b => b -> b
everywhere ((AST' a -> AST' a) -> a -> a
forall a b. (Typeable a, Typeable b) => (b -> b) -> a -> a
mkT (AST' a -> AST' a
forall a. AST' a -> AST' a
withoutMeta :: AST' a -> AST' a))

instance Eq a => Eq (AST' a) where
    (Var a
t)             == :: AST' a -> AST' a -> Bool
== (Var a
t')                 = a
t    a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
t'
    (Lam a
n  TypeAST'
e1 AST' a
e2)      == (Lam a
n' TypeAST'
e1' AST' a
e2')         = a
n    a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
n'  Bool -> Bool -> Bool
&&
                                                      TypeAST'
e1   TypeAST' -> TypeAST' -> Bool
forall a. Eq a => a -> a -> Bool
== TypeAST'
e1' Bool -> Bool -> Bool
&&
                                                      AST' a
e2   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2'
    (App    AST' a
e1 AST' a
e2)      == (App    AST' a
e1' AST' a
e2')         = AST' a
e1   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e1' Bool -> Bool -> Bool
&&
                                                      AST' a
e2   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2'
    (Let a
n  AST' a
e1 AST' a
e2)      == (Let a
n' AST' a
e1' AST' a
e2')         = a
n    a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
n'  Bool -> Bool -> Bool
&&
                                                      AST' a
e1   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e1' Bool -> Bool -> Bool
&&
                                                      AST' a
e2   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2'
    (If  AST' a
c  AST' a
e1 AST' a
e2)      == (If  AST' a
c' AST' a
e1' AST' a
e2')         = AST' a
c    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
c'  Bool -> Bool -> Bool
&&
                                                      AST' a
e1   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e1' Bool -> Bool -> Bool
&&
                                                      AST' a
e2   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2'
    (Ann AST' a
e TypeAST'
typ)         == (Ann AST' a
e' TypeAST'
typ')            = AST' a
e    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e'  Bool -> Bool -> Bool
&&
                                                      TypeAST'
typ  TypeAST' -> TypeAST' -> Bool
forall a. Eq a => a -> a -> Bool
== TypeAST'
typ'
    AST' a
Infinity'           == AST' a
Infinity'                = Bool
True
    (ULiteral Literal'
v)        == (ULiteral Literal'
v')            = Literal'
v    Literal' -> Literal' -> Bool
forall a. Eq a => a -> a -> Bool
== Literal'
v'
    (NaryOp NaryOp
op [AST' a]
args)    == (NaryOp NaryOp
op' [AST' a]
args')       = NaryOp
op   NaryOp -> NaryOp -> Bool
forall a. Eq a => a -> a -> Bool
== NaryOp
op' Bool -> Bool -> Bool
&&
                                                      [AST' a]
args [AST' a] -> [AST' a] -> Bool
forall a. Eq a => a -> a -> Bool
== [AST' a]
args'
    AST' a
Unit                == AST' a
Unit                     = Bool
True
    (Pair  AST' a
e1 AST' a
e2)       == (Pair   AST' a
e1' AST' a
e2')         = AST' a
e1   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e1' Bool -> Bool -> Bool
&&
                                                      AST' a
e2   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2'
    (Array a
e1 AST' a
e2 AST' a
e3)    == (Array  a
e1' AST' a
e2' AST' a
e3')     = a
e1   a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
e1' Bool -> Bool -> Bool
&&
                                                      AST' a
e2   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2' Bool -> Bool -> Bool
&&
                                                      AST' a
e3   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e3'
    (ArrayLiteral [AST' a]
es)   == (ArrayLiteral [AST' a]
es')       = [AST' a]
es   [AST' a] -> [AST' a] -> Bool
forall a. Eq a => a -> a -> Bool
== [AST' a]
es'
    (Index AST' a
e1 AST' a
e2)       == (Index  AST' a
e1' AST' a
e2')         = AST' a
e1   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e1' Bool -> Bool -> Bool
&&
                                                      AST' a
e2   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2'
    (Case  AST' a
e1 [Branch' a]
bs)       == (Case   AST' a
e1' [Branch' a]
bs')         = AST' a
e1   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e1' Bool -> Bool -> Bool
&&
                                                      [Branch' a]
bs   [Branch' a] -> [Branch' a] -> Bool
forall a. Eq a => a -> a -> Bool
== [Branch' a]
bs'
    (Bind  a
e1 AST' a
e2 AST' a
e3)    == (Bind   a
e1' AST' a
e2' AST' a
e3')     = a
e1   a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
e1' Bool -> Bool -> Bool
&&
                                                      AST' a
e2   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2' Bool -> Bool -> Bool
&&
                                                      AST' a
e3   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e3'
    (Plate a
e1 AST' a
e2 AST' a
e3)    == (Plate  a
e1' AST' a
e2' AST' a
e3')     = a
e1   a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
e1' Bool -> Bool -> Bool
&&
                                                      AST' a
e2   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2' Bool -> Bool -> Bool
&&
                                                      AST' a
e3   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e3'
    (Chain a
e1 AST' a
e2 AST' a
e3 AST' a
e4) == (Chain  a
e1' AST' a
e2' AST' a
e3' AST' a
e4') = a
e1   a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
e1' Bool -> Bool -> Bool
&&
                                                      AST' a
e2   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2' Bool -> Bool -> Bool
&&
                                                      AST' a
e3   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e3' Bool -> Bool -> Bool
&&
                                                      AST' a
e4   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e4'
    (Integrate a
a AST' a
b AST' a
c AST' a
d) == (Integrate  a
a' AST' a
b' AST' a
c' AST' a
d') = a
a    a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
a' Bool -> Bool -> Bool
&&
                                                      AST' a
b    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
b' Bool -> Bool -> Bool
&&
                                                      AST' a
c    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
c' Bool -> Bool -> Bool
&&
                                                      AST' a
d    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
d'
    (Summate   a
a AST' a
b AST' a
c AST' a
d) == (Summate    a
a' AST' a
b' AST' a
c' AST' a
d') = a
a    a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
a' Bool -> Bool -> Bool
&&
                                                      AST' a
b    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
b' Bool -> Bool -> Bool
&&
                                                      AST' a
c    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
c' Bool -> Bool -> Bool
&&
                                                      AST' a
d    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
d'
    (Product   a
a AST' a
b AST' a
c AST' a
d) == (Product    a
a' AST' a
b' AST' a
c' AST' a
d') = a
a    a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
a' Bool -> Bool -> Bool
&&
                                                      AST' a
b    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
b' Bool -> Bool -> Bool
&&
                                                      AST' a
c    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
c' Bool -> Bool -> Bool
&&
                                                      AST' a
d    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
d'
    (Bucket    a
a AST' a
b AST' a
c Reducer' a
d) == (Bucket     a
a' AST' a
b' AST' a
c' Reducer' a
d') = a
a    a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
a' Bool -> Bool -> Bool
&&
                                                      AST' a
b    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
b' Bool -> Bool -> Bool
&&
                                                      AST' a
c    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
c' Bool -> Bool -> Bool
&&
                                                      Reducer' a
d    Reducer' a -> Reducer' a -> Bool
forall a. Eq a => a -> a -> Bool
== Reducer' a
d'
    (Transform Transform'
t0 SArgs' a
es0)  == (Transform Transform'
t1 SArgs' a
es1)       = Transform'
t0   Transform' -> Transform' -> Bool
forall a. Eq a => a -> a -> Bool
== Transform'
t1 Bool -> Bool -> Bool
&&
                                                      SArgs' a
es0  SArgs' a -> SArgs' a -> Bool
forall a. Eq a => a -> a -> Bool
== SArgs' a
es1
    (Msum  [AST' a]
es)          == (Msum   [AST' a]
es')             = [AST' a]
es   [AST' a] -> [AST' a] -> Bool
forall a. Eq a => a -> a -> Bool
== [AST' a]
es'
    (Data  a
n [a]
ft [TypeAST']
ts AST' a
e)   == (Data   a
n' [a]
ft' [TypeAST']
ts' AST' a
e')   = a
n    a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
n'  Bool -> Bool -> Bool
&&
                                                      [a]
ft   [a] -> [a] -> Bool
forall a. Eq a => a -> a -> Bool
== [a]
ft' Bool -> Bool -> Bool
&&
                                                      [TypeAST']
ts   [TypeAST'] -> [TypeAST'] -> Bool
forall a. Eq a => a -> a -> Bool
== [TypeAST']
ts' Bool -> Bool -> Bool
&&
                                                      AST' a
e    AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e'
    (WithMeta AST' a
e1 SourceSpan
_ )    == AST' a
e2                       = AST' a
e1   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2
    AST' a
e1                  == (WithMeta AST' a
e2 SourceSpan
_)          = AST' a
e1   AST' a -> AST' a -> Bool
forall a. Eq a => a -> a -> Bool
== AST' a
e2
    AST' a
_                   == AST' a
_                        = Bool
False

data Import a = Import a
     deriving (Import a -> Import a -> Bool
(Import a -> Import a -> Bool)
-> (Import a -> Import a -> Bool) -> Eq (Import a)
forall a. Eq a => Import a -> Import a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Import a -> Import a -> Bool
$c/= :: forall a. Eq a => Import a -> Import a -> Bool
== :: Import a -> Import a -> Bool
$c== :: forall a. Eq a => Import a -> Import a -> Bool
Eq, Int -> Import a -> ShowS
[Import a] -> ShowS
Import a -> String
(Int -> Import a -> ShowS)
-> (Import a -> String) -> ([Import a] -> ShowS) -> Show (Import a)
forall a. Show a => Int -> Import a -> ShowS
forall a. Show a => [Import a] -> ShowS
forall a. Show a => Import a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Import a] -> ShowS
$cshowList :: forall a. Show a => [Import a] -> ShowS
show :: Import a -> String
$cshow :: forall a. Show a => Import a -> String
showsPrec :: Int -> Import a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Import a -> ShowS
Show)
data ASTWithImport' a = ASTWithImport' [Import a] (AST' a)
     deriving (ASTWithImport' a -> ASTWithImport' a -> Bool
(ASTWithImport' a -> ASTWithImport' a -> Bool)
-> (ASTWithImport' a -> ASTWithImport' a -> Bool)
-> Eq (ASTWithImport' a)
forall a. Eq a => ASTWithImport' a -> ASTWithImport' a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ASTWithImport' a -> ASTWithImport' a -> Bool
$c/= :: forall a. Eq a => ASTWithImport' a -> ASTWithImport' a -> Bool
== :: ASTWithImport' a -> ASTWithImport' a -> Bool
$c== :: forall a. Eq a => ASTWithImport' a -> ASTWithImport' a -> Bool
Eq, Int -> ASTWithImport' a -> ShowS
[ASTWithImport' a] -> ShowS
ASTWithImport' a -> String
(Int -> ASTWithImport' a -> ShowS)
-> (ASTWithImport' a -> String)
-> ([ASTWithImport' a] -> ShowS)
-> Show (ASTWithImport' a)
forall a. Show a => Int -> ASTWithImport' a -> ShowS
forall a. Show a => [ASTWithImport' a] -> ShowS
forall a. Show a => ASTWithImport' a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ASTWithImport' a] -> ShowS
$cshowList :: forall a. Show a => [ASTWithImport' a] -> ShowS
show :: ASTWithImport' a -> String
$cshow :: forall a. Show a => ASTWithImport' a -> String
showsPrec :: Int -> ASTWithImport' a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ASTWithImport' a -> ShowS
Show)

----------------------------------------------------------------
----------------------------------------------------------------

val :: Literal' -> Some1 Literal
val :: Literal' -> Some1 Literal
val (Nat  Integer
n) = Literal 'HNat -> Some1 Literal
forall k (a :: k -> *) (i :: k). a i -> Some1 a
Some1 (Literal 'HNat -> Some1 Literal) -> Literal 'HNat -> Some1 Literal
forall a b. (a -> b) -> a -> b
$ Natural -> Literal 'HNat
LNat  (Integer -> Natural
N.unsafeNatural Integer
n)
val (Int  Integer
n) = Literal 'HInt -> Some1 Literal
forall k (a :: k -> *) (i :: k). a i -> Some1 a
Some1 (Literal 'HInt -> Some1 Literal) -> Literal 'HInt -> Some1 Literal
forall a b. (a -> b) -> a -> b
$ Integer -> Literal 'HInt
LInt  Integer
n
val (Prob Rational
n) = Literal 'HProb -> Some1 Literal
forall k (a :: k -> *) (i :: k). a i -> Some1 a
Some1 (Literal 'HProb -> Some1 Literal)
-> Literal 'HProb -> Some1 Literal
forall a b. (a -> b) -> a -> b
$ NonNegativeRational -> Literal 'HProb
LProb (Rational -> NonNegativeRational
N.unsafeNonNegativeRational Rational
n)
val (Real Rational
n) = Literal 'HReal -> Some1 Literal
forall k (a :: k -> *) (i :: k). a i -> Some1 a
Some1 (Literal 'HReal -> Some1 Literal)
-> Literal 'HReal -> Some1 Literal
forall a b. (a -> b) -> a -> b
$ Rational -> Literal 'HReal
LReal Rational
n

data PrimOp
    = Not | Impl | Diff   | Nand | Nor
    | Pi
    | Sin        | Cos    | Tan
    | Asin       | Acos   | Atan
    | Sinh       | Cosh   | Tanh
    | Asinh      | Acosh  | Atanh
    | RealPow    | Choose | NatPow
    | Exp        | Log    | Infinity
    | GammaFunc  | BetaFunc
    | Equal      | Less
    | Negate     | Recip
    | Abs        | Signum | NatRoot | Erf
    | Floor
    deriving (PrimOp -> PrimOp -> Bool
(PrimOp -> PrimOp -> Bool)
-> (PrimOp -> PrimOp -> Bool) -> Eq PrimOp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrimOp -> PrimOp -> Bool
$c/= :: PrimOp -> PrimOp -> Bool
== :: PrimOp -> PrimOp -> Bool
$c== :: PrimOp -> PrimOp -> Bool
Eq, Int -> PrimOp -> ShowS
[PrimOp] -> ShowS
PrimOp -> String
(Int -> PrimOp -> ShowS)
-> (PrimOp -> String) -> ([PrimOp] -> ShowS) -> Show PrimOp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrimOp] -> ShowS
$cshowList :: [PrimOp] -> ShowS
show :: PrimOp -> String
$cshow :: PrimOp -> String
showsPrec :: Int -> PrimOp -> ShowS
$cshowsPrec :: Int -> PrimOp -> ShowS
Show)

data SomeOp op where
    SomeOp
        :: (typs ~ UnLCs args, args ~ LCs typs)
        => !(op typs a)
        -> SomeOp op

data SSing =
    forall (a :: Hakaru). SSing !(Sing a)

data Branch_ abt = Branch_ Pattern (abt '[] 'U)

fmapBranch
    :: (f '[] 'U -> g '[] 'U)
    -> Branch_ f
    -> Branch_ g
fmapBranch :: (f '[] 'U -> g '[] 'U) -> Branch_ f -> Branch_ g
fmapBranch f '[] 'U -> g '[] 'U
f (Branch_ Pattern
pat f '[] 'U
e) = Pattern -> g '[] 'U -> Branch_ g
forall k (abt :: [k] -> Untyped -> *).
Pattern -> abt '[] 'U -> Branch_ abt
Branch_ Pattern
pat (f '[] 'U -> g '[] 'U
f f '[] 'U
e)

foldBranch
    :: (abt '[] 'U -> m)
    -> Branch_ abt
    -> m
foldBranch :: (abt '[] 'U -> m) -> Branch_ abt -> m
foldBranch abt '[] 'U -> m
f (Branch_ Pattern
_ abt '[] 'U
e) = abt '[] 'U -> m
f abt '[] 'U
e

data Pattern
    = PWild
    | PVar Name
    | PDatum T.Text PCode

data PFun
    = PKonst Pattern
    | PIdent Pattern

data PStruct
    = PEt PFun PStruct
    | PDone

data PCode
    = PInr PCode
    | PInl PStruct

infixr 7 `Et`, `PEt`

data DFun abt
    = Konst (abt '[] 'U)
    | Ident (abt '[] 'U)

data DStruct abt
    = Et (DFun abt) (DStruct abt)
    | Done

data DCode abt
    = Inr (DCode   abt)
    | Inl (DStruct abt)

data Datum abt = Datum T.Text (DCode abt)

fmapDatum
    :: (f '[] 'U -> g '[] 'U)
    -> Datum f
    -> Datum g
fmapDatum :: (f '[] 'U -> g '[] 'U) -> Datum f -> Datum g
fmapDatum f '[] 'U -> g '[] 'U
f (Datum Text
t DCode f
dcode) = Text -> DCode g -> Datum g
forall k (abt :: [k] -> Untyped -> *).
Text -> DCode abt -> Datum abt
Datum Text
t ((f '[] 'U -> g '[] 'U) -> DCode f -> DCode g
forall k k (abt :: [k] -> Untyped -> *)
       (abt :: [k] -> Untyped -> *).
(abt '[] 'U -> abt '[] 'U) -> DCode abt -> DCode abt
fdcode f '[] 'U -> g '[] 'U
f DCode f
dcode)
   where fdcode :: (abt '[] 'U -> abt '[] 'U) -> DCode abt -> DCode abt
fdcode   abt '[] 'U -> abt '[] 'U
f' (Inr DCode abt
d)    = DCode abt -> DCode abt
forall k (abt :: [k] -> Untyped -> *). DCode abt -> DCode abt
Inr ((abt '[] 'U -> abt '[] 'U) -> DCode abt -> DCode abt
fdcode   abt '[] 'U -> abt '[] 'U
f' DCode abt
d)
         fdcode   abt '[] 'U -> abt '[] 'U
f' (Inl DStruct abt
d)    = DStruct abt -> DCode abt
forall k (abt :: [k] -> Untyped -> *). DStruct abt -> DCode abt
Inl ((abt '[] 'U -> abt '[] 'U) -> DStruct abt -> DStruct abt
forall k k (abt :: [k] -> Untyped -> *)
       (abt :: [k] -> Untyped -> *).
(abt '[] 'U -> abt '[] 'U) -> DStruct abt -> DStruct abt
fdstruct abt '[] 'U -> abt '[] 'U
f' DStruct abt
d)
         fdstruct :: (abt '[] 'U -> abt '[] 'U) -> DStruct abt -> DStruct abt
fdstruct abt '[] 'U -> abt '[] 'U
f' (Et DFun abt
df DStruct abt
ds) = DFun abt -> DStruct abt -> DStruct abt
forall k (abt :: [k] -> Untyped -> *).
DFun abt -> DStruct abt -> DStruct abt
Et  ((abt '[] 'U -> abt '[] 'U) -> DFun abt -> DFun abt
forall k k (abt :: [k] -> Untyped -> *)
       (abt :: [k] -> Untyped -> *).
(abt '[] 'U -> abt '[] 'U) -> DFun abt -> DFun abt
fdfun    abt '[] 'U -> abt '[] 'U
f' DFun abt
df)
                                      ((abt '[] 'U -> abt '[] 'U) -> DStruct abt -> DStruct abt
fdstruct abt '[] 'U -> abt '[] 'U
f' DStruct abt
ds)
         fdstruct abt '[] 'U -> abt '[] 'U
_  DStruct abt
Done       = DStruct abt
forall k (abt :: [k] -> Untyped -> *). DStruct abt
Done
         fdfun :: (abt '[] 'U -> abt '[] 'U) -> DFun abt -> DFun abt
fdfun    abt '[] 'U -> abt '[] 'U
f' (Konst abt '[] 'U
e)  = abt '[] 'U -> DFun abt
forall k (abt :: [k] -> Untyped -> *). abt '[] 'U -> DFun abt
Konst (abt '[] 'U -> abt '[] 'U
f' abt '[] 'U
e)
         fdfun    abt '[] 'U -> abt '[] 'U
f' (Ident abt '[] 'U
e)  = abt '[] 'U -> DFun abt
forall k (abt :: [k] -> Untyped -> *). abt '[] 'U -> DFun abt
Ident (abt '[] 'U -> abt '[] 'U
f' abt '[] 'U
e)

foldDatum
    :: (Monoid m)
    => (abt '[] 'U -> m)
    -> Datum abt
    -> m
foldDatum :: (abt '[] 'U -> m) -> Datum abt -> m
foldDatum abt '[] 'U -> m
f (Datum Text
_ DCode abt
dcode) = (abt '[] 'U -> m) -> DCode abt -> m
forall k p (abt :: [k] -> Untyped -> *).
Monoid p =>
(abt '[] 'U -> p) -> DCode abt -> p
fdcode abt '[] 'U -> m
f DCode abt
dcode
   where fdcode :: (abt '[] 'U -> p) -> DCode abt -> p
fdcode   abt '[] 'U -> p
f' (Inr DCode abt
d)    = (abt '[] 'U -> p) -> DCode abt -> p
fdcode   abt '[] 'U -> p
f' DCode abt
d
         fdcode   abt '[] 'U -> p
f' (Inl DStruct abt
d)    = (abt '[] 'U -> p) -> DStruct abt -> p
forall k p (abt :: [k] -> Untyped -> *).
Monoid p =>
(abt '[] 'U -> p) -> DStruct abt -> p
fdstruct abt '[] 'U -> p
f' DStruct abt
d
         fdstruct :: (abt '[] 'U -> p) -> DStruct abt -> p
fdstruct abt '[] 'U -> p
f' (Et DFun abt
df DStruct abt
ds) = (abt '[] 'U -> p) -> DFun abt -> p
forall k (abt :: [k] -> Untyped -> *) p.
(abt '[] 'U -> p) -> DFun abt -> p
fdfun    abt '[] 'U -> p
f' DFun abt
df p -> p -> p
forall a. Monoid a => a -> a -> a
`mappend`
                                  (abt '[] 'U -> p) -> DStruct abt -> p
fdstruct abt '[] 'U -> p
f' DStruct abt
ds
         fdstruct abt '[] 'U -> p
_  DStruct abt
Done       = p
forall a. Monoid a => a
mempty
         fdfun :: (abt '[] 'U -> p) -> DFun abt -> p
fdfun    abt '[] 'U -> p
f' (Konst abt '[] 'U
e)  = abt '[] 'U -> p
f' abt '[] 'U
e
         fdfun    abt '[] 'U -> p
f' (Ident abt '[] 'U
e)  = abt '[] 'U -> p
f' abt '[] 'U
e


data Reducer (xs  :: [Untyped])
             (abt :: [Untyped] -> Untyped -> *)
             (a   :: Untyped) where
    R_Fanout_ :: Reducer xs abt 'U
              -> Reducer xs abt 'U
              -> Reducer xs abt 'U
    R_Index_  :: Variable 'U -- HACK: Shouldn't need to pass this argument
              -> abt xs 'U
              -> abt ( 'U ': xs) 'U
              -> Reducer ( 'U ': xs) abt 'U
              -> Reducer xs abt 'U
    R_Split_  :: abt ( 'U ': xs) 'U
              -> Reducer xs abt 'U
              -> Reducer xs abt 'U
              -> Reducer xs abt 'U
    R_Nop_    :: Reducer xs abt 'U
    R_Add_    :: abt ( 'U ': xs) 'U
              -> Reducer xs abt 'U

instance Functor21 (Reducer xs) where
    fmap21 :: (forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> Reducer xs a j -> Reducer xs b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (R_Fanout_ Reducer xs a 'U
r1 Reducer xs a 'U
r2)       = Reducer xs b 'U -> Reducer xs b 'U -> Reducer xs b 'U
forall (xs :: [Untyped]) (abt :: [Untyped] -> Untyped -> *).
Reducer xs abt 'U -> Reducer xs abt 'U -> Reducer xs abt 'U
R_Fanout_ ((forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> Reducer xs a 'U -> Reducer xs b 'U
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *)
       (a :: k1 -> k2 -> *) (b :: k1 -> k2 -> *) (j :: k3).
Functor21 f =>
(forall (h :: k1) (i :: k2). a h i -> b h i) -> f a j -> f b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f Reducer xs a 'U
r1) ((forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> Reducer xs a 'U -> Reducer xs b 'U
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *)
       (a :: k1 -> k2 -> *) (b :: k1 -> k2 -> *) (j :: k3).
Functor21 f =>
(forall (h :: k1) (i :: k2). a h i -> b h i) -> f a j -> f b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f Reducer xs a 'U
r2)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (R_Index_  Variable 'U
bv a xs 'U
e1 a ('U : xs) 'U
e2 Reducer ('U : xs) a 'U
r1) = Variable 'U
-> b xs 'U
-> b ('U : xs) 'U
-> Reducer ('U : xs) b 'U
-> Reducer xs b 'U
forall (abt :: [Untyped] -> Untyped -> *) (xs :: [Untyped]).
Variable 'U
-> abt xs 'U
-> abt ('U : xs) 'U
-> Reducer ('U : xs) abt 'U
-> Reducer xs abt 'U
R_Index_ Variable 'U
bv (a xs 'U -> b xs 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a xs 'U
e1) (a ('U : xs) 'U -> b ('U : xs) 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a ('U : xs) 'U
e2) ((forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> Reducer ('U : xs) a 'U -> Reducer ('U : xs) b 'U
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *)
       (a :: k1 -> k2 -> *) (b :: k1 -> k2 -> *) (j :: k3).
Functor21 f =>
(forall (h :: k1) (i :: k2). a h i -> b h i) -> f a j -> f b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f Reducer ('U : xs) a 'U
r1)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (R_Split_  a ('U : xs) 'U
e1 Reducer xs a 'U
r1 Reducer xs a 'U
r2)    = b ('U : xs) 'U
-> Reducer xs b 'U -> Reducer xs b 'U -> Reducer xs b 'U
forall (abt :: [Untyped] -> Untyped -> *) (xs :: [Untyped]).
abt ('U : xs) 'U
-> Reducer xs abt 'U -> Reducer xs abt 'U -> Reducer xs abt 'U
R_Split_ (a ('U : xs) 'U -> b ('U : xs) 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a ('U : xs) 'U
e1) ((forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> Reducer xs a 'U -> Reducer xs b 'U
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *)
       (a :: k1 -> k2 -> *) (b :: k1 -> k2 -> *) (j :: k3).
Functor21 f =>
(forall (h :: k1) (i :: k2). a h i -> b h i) -> f a j -> f b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f Reducer xs a 'U
r1) ((forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> Reducer xs a 'U -> Reducer xs b 'U
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *)
       (a :: k1 -> k2 -> *) (b :: k1 -> k2 -> *) (j :: k3).
Functor21 f =>
(forall (h :: k1) (i :: k2). a h i -> b h i) -> f a j -> f b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f Reducer xs a 'U
r2)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
_ Reducer xs a j
R_Nop_                  = Reducer xs b j
forall (xs :: [Untyped]) (abt :: [Untyped] -> Untyped -> *).
Reducer xs abt 'U
R_Nop_
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (R_Add_    a ('U : xs) 'U
e1)          = b ('U : xs) 'U -> Reducer xs b 'U
forall (abt :: [Untyped] -> Untyped -> *) (xs :: [Untyped]).
abt ('U : xs) 'U -> Reducer xs abt 'U
R_Add_ (a ('U : xs) 'U -> b ('U : xs) 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a ('U : xs) 'U
e1)

instance Foldable21 (Reducer xs) where
    foldMap21 :: (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> Reducer xs a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (R_Fanout_ Reducer xs a 'U
r1 Reducer xs a 'U
r2)       = (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> Reducer xs a 'U -> m
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *) m
       (a :: k1 -> k2 -> *) (j :: k3).
(Foldable21 f, Monoid m) =>
(forall (h :: k1) (i :: k2). a h i -> m) -> f a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f Reducer xs a 'U
r1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> Reducer xs a 'U -> m
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *) m
       (a :: k1 -> k2 -> *) (j :: k3).
(Foldable21 f, Monoid m) =>
(forall (h :: k1) (i :: k2). a h i -> m) -> f a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f Reducer xs a 'U
r2
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (R_Index_  Variable 'U
_  a xs 'U
e1 a ('U : xs) 'U
e2 Reducer ('U : xs) a 'U
r1) =
        a xs 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a xs 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a ('U : xs) 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a ('U : xs) 'U
e2 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> Reducer ('U : xs) a 'U -> m
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *) m
       (a :: k1 -> k2 -> *) (j :: k3).
(Foldable21 f, Monoid m) =>
(forall (h :: k1) (i :: k2). a h i -> m) -> f a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f Reducer ('U : xs) a 'U
r1
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (R_Split_  a ('U : xs) 'U
e1 Reducer xs a 'U
r1 Reducer xs a 'U
r2)    =
        a ('U : xs) 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a ('U : xs) 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> Reducer xs a 'U -> m
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *) m
       (a :: k1 -> k2 -> *) (j :: k3).
(Foldable21 f, Monoid m) =>
(forall (h :: k1) (i :: k2). a h i -> m) -> f a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f Reducer xs a 'U
r1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> Reducer xs a 'U -> m
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *) m
       (a :: k1 -> k2 -> *) (j :: k3).
(Foldable21 f, Monoid m) =>
(forall (h :: k1) (i :: k2). a h i -> m) -> f a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f Reducer xs a 'U
r2
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
_ Reducer xs a j
R_Nop_                  = m
forall a. Monoid a => a
mempty
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (R_Add_    a ('U : xs) 'U
e1)          = a ('U : xs) 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a ('U : xs) 'U
e1

-- | The kind containing exactly one type.
data Untyped = U
    deriving (ReadPrec [Untyped]
ReadPrec Untyped
Int -> ReadS Untyped
ReadS [Untyped]
(Int -> ReadS Untyped)
-> ReadS [Untyped]
-> ReadPrec Untyped
-> ReadPrec [Untyped]
-> Read Untyped
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Untyped]
$creadListPrec :: ReadPrec [Untyped]
readPrec :: ReadPrec Untyped
$creadPrec :: ReadPrec Untyped
readList :: ReadS [Untyped]
$creadList :: ReadS [Untyped]
readsPrec :: Int -> ReadS Untyped
$creadsPrec :: Int -> ReadS Untyped
Read, Int -> Untyped -> ShowS
[Untyped] -> ShowS
Untyped -> String
(Int -> Untyped -> ShowS)
-> (Untyped -> String) -> ([Untyped] -> ShowS) -> Show Untyped
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Untyped] -> ShowS
$cshowList :: [Untyped] -> ShowS
show :: Untyped -> String
$cshow :: Untyped -> String
showsPrec :: Int -> Untyped -> ShowS
$cshowsPrec :: Int -> Untyped -> ShowS
Show)

data instance Sing (a :: Untyped) where
    SU :: Sing 'U

instance SingI 'U where
    sing :: Sing 'U
sing = Sing 'U
SU

instance Show (Sing (a :: Untyped)) where
    showsPrec :: Int -> Sing a -> ShowS
showsPrec = Int -> Sing a -> ShowS
forall k (a :: k -> *) (i :: k). Show1 a => Int -> a i -> ShowS
showsPrec1
    show :: Sing a -> String
show      = Sing a -> String
forall k (a :: k -> *) (i :: k). Show1 a => a i -> String
show1

instance Show1 (Sing :: Untyped -> *) where
    showsPrec1 :: Int -> Sing i -> ShowS
showsPrec1 Int
_ Sing i
SU = (String
"SU" String -> ShowS
forall a. [a] -> [a] -> [a]
++)

instance Eq (Sing (a :: Untyped)) where
    Sing a
SU == :: Sing a -> Sing a -> Bool
== Sing a
SU = Bool
True

instance Eq1 (Sing :: Untyped -> *) where
    eq1 :: Sing i -> Sing i -> Bool
eq1 Sing i
SU Sing i
SU = Bool
True

instance JmEq1 (Sing :: Untyped -> *) where
    jmEq1 :: Sing i -> Sing j -> Maybe (TypeEq i j)
jmEq1 Sing i
SU Sing j
SU = TypeEq i i -> Maybe (TypeEq i i)
forall a. a -> Maybe a
Just TypeEq i i
forall k (a :: k). TypeEq a a
Refl

nameToVar :: Name -> Variable 'U
nameToVar :: Name -> Variable 'U
nameToVar (Name Nat
i Text
h) = Text -> Nat -> Sing 'U -> Variable 'U
forall k (a :: k). Text -> Nat -> Sing a -> Variable a
Variable Text
h Nat
i Sing 'U
SU

data Term :: ([Untyped] -> Untyped -> *) -> Untyped -> * where
    Lam_          :: SSing            -> abt '[ 'U ] 'U  -> Term abt 'U
    App_          :: abt '[] 'U       -> abt '[]     'U  -> Term abt 'U
    Let_          :: abt '[] 'U       -> abt '[ 'U ] 'U  -> Term abt 'U
    Ann_          :: SSing            -> abt '[]     'U  -> Term abt 'U
    CoerceTo_     :: Some2 Coercion   -> abt '[]     'U  -> Term abt 'U
    UnsafeTo_     :: Some2 Coercion   -> abt '[]     'U  -> Term abt 'U
    PrimOp_       :: PrimOp           -> [abt '[] 'U]    -> Term abt 'U
    ArrayOp_      :: ArrayOp          -> [abt '[] 'U]    -> Term abt 'U
    MeasureOp_    :: SomeOp MeasureOp -> [abt '[] 'U]    -> Term abt 'U
    NaryOp_       :: NaryOp           -> [abt '[] 'U]    -> Term abt 'U
    Literal_      :: Some1 Literal                       -> Term abt 'U
    Pair_         :: abt '[] 'U       -> abt '[]     'U  -> Term abt 'U
    Array_        :: abt '[] 'U       -> abt '[ 'U ] 'U  -> Term abt 'U
    ArrayLiteral_ :: [abt '[] 'U]                        -> Term abt 'U
    Datum_        :: Datum abt                           -> Term abt 'U
    Case_         :: abt '[] 'U       -> [Branch_ abt]   -> Term abt 'U
    Dirac_        :: abt '[] 'U                          -> Term abt 'U
    MBind_        :: abt '[] 'U       -> abt '[ 'U ] 'U  -> Term abt 'U
    Plate_        :: abt '[] 'U       -> abt '[ 'U ] 'U  -> Term abt 'U
    Chain_        :: abt '[] 'U       -> abt '[]     'U  -> abt '[ 'U ] 'U -> Term abt 'U
    Integrate_    :: abt '[] 'U       -> abt '[]     'U  -> abt '[ 'U ] 'U -> Term abt 'U
    Summate_      :: abt '[] 'U       -> abt '[]     'U  -> abt '[ 'U ] 'U -> Term abt 'U
    Product_      :: abt '[] 'U       -> abt '[]     'U  -> abt '[ 'U ] 'U -> Term abt 'U
    Bucket_       :: abt '[] 'U       -> abt '[]     'U  -> Reducer xs abt 'U -> Term abt 'U
    Transform_    :: T.Transform as x -> SArgs abt as    -> Term abt 'U
    Superpose_    :: L.NonEmpty (abt '[] 'U, abt '[] 'U) -> Term abt 'U
    Reject_       ::                                        Term abt 'U
    InjTyped      :: (forall abt' . ABT T.Term abt'
                                 => abt' '[] x)          -> Term abt 'U

infixr 5 :*
data SArgs (abt :: [Untyped] -> Untyped -> *) (as :: [([k], k)]) where
  End :: SArgs abt '[]
  (:*) :: !(List2 ToUntyped vars varsu, abt varsu 'U)
       -> !(SArgs abt args)
       -> SArgs abt ( '(vars, a) ': args)

data ToUntyped (x :: k) (y :: Untyped) where
  ToU :: ToUntyped x 'U

instance Functor21 SArgs where
    fmap21 :: (forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> SArgs a j -> SArgs b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f = \case
      SArgs a j
End          -> SArgs b j
forall k (abt :: [Untyped] -> Untyped -> *). SArgs abt '[]
End
      (List2 ToUntyped vars varsu
m, a varsu 'U
a) :* SArgs a args
as -> (List2 ToUntyped vars varsu
m, a varsu 'U -> b varsu 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a varsu 'U
a) (List2 ToUntyped vars varsu, b varsu 'U)
-> SArgs b args -> SArgs b ('(vars, a) : args)
forall k (vars :: [k]) (varsu :: [Untyped])
       (abt :: [Untyped] -> Untyped -> *) (args :: [([k], k)]) (a :: k).
(List2 ToUntyped vars varsu, abt varsu 'U)
-> SArgs abt args -> SArgs abt ('(vars, a) : args)
:* (forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> SArgs a args -> SArgs b args
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *)
       (a :: k1 -> k2 -> *) (b :: k1 -> k2 -> *) (j :: k3).
Functor21 f =>
(forall (h :: k1) (i :: k2). a h i -> b h i) -> f a j -> f b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f SArgs a args
as

-- TODO: instance of Traversable21 for Term
instance Functor21 Term where
    fmap21 :: (forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> Term a j -> Term b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Lam_       SSing
typ a '[ 'U] 'U
e1)    = SSing -> b '[ 'U] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
SSing -> abt '[ 'U] 'U -> Term abt 'U
Lam_       SSing
typ    (a '[ 'U] 'U -> b '[ 'U] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[ 'U] 'U
e1)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (App_       a '[] 'U
e1  a '[] 'U
e2)    = b '[] 'U -> b '[] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> abt '[] 'U -> Term abt 'U
App_       (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e2)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Let_       a '[] 'U
e1  a '[ 'U] 'U
e2)    = b '[] 'U -> b '[ 'U] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> abt '[ 'U] 'U -> Term abt 'U
Let_       (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[ 'U] 'U -> b '[ 'U] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[ 'U] 'U
e2)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Ann_       SSing
typ a '[] 'U
e1)    = SSing -> b '[] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
SSing -> abt '[] 'U -> Term abt 'U
Ann_       SSing
typ    (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (CoerceTo_  Some2 Coercion
c   a '[] 'U
e1)    = Some2 Coercion -> b '[] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
Some2 Coercion -> abt '[] 'U -> Term abt 'U
CoerceTo_  Some2 Coercion
c      (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (UnsafeTo_  Some2 Coercion
c   a '[] 'U
e1)    = Some2 Coercion -> b '[] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
Some2 Coercion -> abt '[] 'U -> Term abt 'U
UnsafeTo_  Some2 Coercion
c      (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (PrimOp_    PrimOp
op  [a '[] 'U]
es)    = PrimOp -> [b '[] 'U] -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
PrimOp -> [abt '[] 'U] -> Term abt 'U
PrimOp_    PrimOp
op     ((a '[] 'U -> b '[] 'U) -> [a '[] 'U] -> [b '[] 'U]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f [a '[] 'U]
es)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (ArrayOp_   ArrayOp
op  [a '[] 'U]
es)    = ArrayOp -> [b '[] 'U] -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
ArrayOp -> [abt '[] 'U] -> Term abt 'U
ArrayOp_   ArrayOp
op     ((a '[] 'U -> b '[] 'U) -> [a '[] 'U] -> [b '[] 'U]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f [a '[] 'U]
es)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (MeasureOp_ SomeOp MeasureOp
op  [a '[] 'U]
es)    = SomeOp MeasureOp -> [b '[] 'U] -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
SomeOp MeasureOp -> [abt '[] 'U] -> Term abt 'U
MeasureOp_ SomeOp MeasureOp
op     ((a '[] 'U -> b '[] 'U) -> [a '[] 'U] -> [b '[] 'U]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f [a '[] 'U]
es)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (NaryOp_    NaryOp
op  [a '[] 'U]
es)    = NaryOp -> [b '[] 'U] -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
NaryOp -> [abt '[] 'U] -> Term abt 'U
NaryOp_    NaryOp
op     ((a '[] 'U -> b '[] 'U) -> [a '[] 'U] -> [b '[] 'U]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f [a '[] 'U]
es)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
_ (Literal_   Some1 Literal
v)         = Some1 Literal -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
Some1 Literal -> Term abt 'U
Literal_   Some1 Literal
v
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Pair_      a '[] 'U
e1  a '[] 'U
e2)    = b '[] 'U -> b '[] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> abt '[] 'U -> Term abt 'U
Pair_      (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e2)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Array_     a '[] 'U
e1  a '[ 'U] 'U
e2)    = b '[] 'U -> b '[ 'U] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> abt '[ 'U] 'U -> Term abt 'U
Array_     (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[ 'U] 'U -> b '[ 'U] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[ 'U] 'U
e2)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (ArrayLiteral_  [a '[] 'U]
es)    = [b '[] 'U] -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
[abt '[] 'U] -> Term abt 'U
ArrayLiteral_     ((a '[] 'U -> b '[] 'U) -> [a '[] 'U] -> [b '[] 'U]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f [a '[] 'U]
es)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Datum_     Datum a
d)         = Datum b -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *). Datum abt -> Term abt 'U
Datum_     ((a '[] 'U -> b '[] 'U) -> Datum a -> Datum b
forall k k (f :: [k] -> Untyped -> *) (g :: [k] -> Untyped -> *).
(f '[] 'U -> g '[] 'U) -> Datum f -> Datum g
fmapDatum a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f Datum a
d)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Case_      a '[] 'U
e1  [Branch_ a]
bs)    = b '[] 'U -> [Branch_ b] -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> [Branch_ abt] -> Term abt 'U
Case_      (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) ((Branch_ a -> Branch_ b) -> [Branch_ a] -> [Branch_ b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a '[] 'U -> b '[] 'U) -> Branch_ a -> Branch_ b
forall k k (f :: [k] -> Untyped -> *) (g :: [k] -> Untyped -> *).
(f '[] 'U -> g '[] 'U) -> Branch_ f -> Branch_ g
fmapBranch a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f) [Branch_ a]
bs)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Dirac_     a '[] 'U
e1)        = b '[] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> Term abt 'U
Dirac_     (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (MBind_     a '[] 'U
e1  a '[ 'U] 'U
e2)    = b '[] 'U -> b '[ 'U] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> abt '[ 'U] 'U -> Term abt 'U
MBind_     (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[ 'U] 'U -> b '[ 'U] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[ 'U] 'U
e2)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Plate_     a '[] 'U
e1  a '[ 'U] 'U
e2)    = b '[] 'U -> b '[ 'U] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> abt '[ 'U] 'U -> Term abt 'U
Plate_     (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[ 'U] 'U -> b '[ 'U] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[ 'U] 'U
e2)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Chain_     a '[] 'U
e1  a '[] 'U
e2 a '[ 'U] 'U
e3) = b '[] 'U -> b '[] 'U -> b '[ 'U] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> abt '[] 'U -> abt '[ 'U] 'U -> Term abt 'U
Chain_     (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e2) (a '[ 'U] 'U -> b '[ 'U] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[ 'U] 'U
e3)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Integrate_ a '[] 'U
e1  a '[] 'U
e2 a '[ 'U] 'U
e3) = b '[] 'U -> b '[] 'U -> b '[ 'U] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> abt '[] 'U -> abt '[ 'U] 'U -> Term abt 'U
Integrate_ (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e2) (a '[ 'U] 'U -> b '[ 'U] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[ 'U] 'U
e3)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Summate_   a '[] 'U
e1  a '[] 'U
e2 a '[ 'U] 'U
e3) = b '[] 'U -> b '[] 'U -> b '[ 'U] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> abt '[] 'U -> abt '[ 'U] 'U -> Term abt 'U
Summate_   (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e2) (a '[ 'U] 'U -> b '[ 'U] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[ 'U] 'U
e3)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Product_   a '[] 'U
e1  a '[] 'U
e2 a '[ 'U] 'U
e3) = b '[] 'U -> b '[] 'U -> b '[ 'U] 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
abt '[] 'U -> abt '[] 'U -> abt '[ 'U] 'U -> Term abt 'U
Product_   (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e2) (a '[ 'U] 'U -> b '[ 'U] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[ 'U] 'U
e3)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Bucket_    a '[] 'U
e1  a '[] 'U
e2 Reducer xs a 'U
e3) = b '[] 'U -> b '[] 'U -> Reducer xs b 'U -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *) (xs :: [Untyped]).
abt '[] 'U -> abt '[] 'U -> Reducer xs abt 'U -> Term abt 'U
Bucket_    (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e1) (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f a '[] 'U
e2) ((forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> Reducer xs a 'U -> Reducer xs b 'U
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *)
       (a :: k1 -> k2 -> *) (b :: k1 -> k2 -> *) (j :: k3).
Functor21 f =>
(forall (h :: k1) (i :: k2). a h i -> b h i) -> f a j -> f b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f Reducer xs a 'U
e3)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Transform_ Transform as x
t SArgs a as
as)      = Transform as x -> SArgs b as -> Term b 'U
forall (as :: [([Hakaru], Hakaru)]) (x :: Hakaru)
       (abt :: [Untyped] -> Untyped -> *).
Transform as x -> SArgs abt as -> Term abt 'U
Transform_ Transform as x
t ((forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i)
-> SArgs a as -> SArgs b as
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *)
       (a :: k1 -> k2 -> *) (b :: k1 -> k2 -> *) (j :: k3).
Functor21 f =>
(forall (h :: k1) (i :: k2). a h i -> b h i) -> f a j -> f b j
fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f SArgs a as
as)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (Superpose_ NonEmpty (a '[] 'U, a '[] 'U)
es)        = NonEmpty (b '[] 'U, b '[] 'U) -> Term b 'U
forall (abt :: [Untyped] -> Untyped -> *).
NonEmpty (abt '[] 'U, abt '[] 'U) -> Term abt 'U
Superpose_ (((a '[] 'U, a '[] 'U) -> (b '[] 'U, b '[] 'U))
-> NonEmpty (a '[] 'U, a '[] 'U) -> NonEmpty (b '[] 'U, b '[] 'U)
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
L.map (a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f (a '[] 'U -> b '[] 'U)
-> (a '[] 'U -> b '[] 'U)
-> (a '[] 'U, a '[] 'U)
-> (b '[] 'U, b '[] 'U)
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** a '[] 'U -> b '[] 'U
forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
f) NonEmpty (a '[] 'U, a '[] 'U)
es)
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
_ Term a j
Reject_                = Term b j
forall (abt :: [Untyped] -> Untyped -> *). Term abt 'U
Reject_
    fmap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> b h i
_ (InjTyped forall (abt' :: [Hakaru] -> Hakaru -> *).
ABT Term abt' =>
abt' '[] x
x)           = (forall (abt' :: [Hakaru] -> Hakaru -> *).
 ABT Term abt' =>
 abt' '[] x)
-> Term b 'U
forall (x :: Hakaru) (abt :: [Untyped] -> Untyped -> *).
(forall (abt' :: [Hakaru] -> Hakaru -> *).
 ABT Term abt' =>
 abt' '[] x)
-> Term abt 'U
InjTyped forall (abt' :: [Hakaru] -> Hakaru -> *).
ABT Term abt' =>
abt' '[] x
x

instance Foldable21 SArgs where
    foldMap21 :: (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> SArgs a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f = \case
      SArgs a j
End          -> m
forall a. Monoid a => a
mempty
      (List2 ToUntyped vars varsu
_, a varsu 'U
a) :* SArgs a args
as -> a varsu 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a varsu 'U
a m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> SArgs a args -> m
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *) m
       (a :: k1 -> k2 -> *) (j :: k3).
(Foldable21 f, Monoid m) =>
(forall (h :: k1) (i :: k2). a h i -> m) -> f a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f SArgs a args
as

instance Foldable21 Term where
    foldMap21 :: (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> Term a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Lam_       SSing
_  a '[ 'U] 'U
e1)    = a '[ 'U] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[ 'U] 'U
e1
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (App_       a '[] 'U
e1 a '[] 'U
e2)    = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e2
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Let_       a '[] 'U
e1 a '[ 'U] 'U
e2)    = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[ 'U] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[ 'U] 'U
e2
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Ann_       SSing
_  a '[] 'U
e1)    = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (CoerceTo_  Some2 Coercion
_  a '[] 'U
e1)    = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (UnsafeTo_  Some2 Coercion
_  a '[] 'U
e1)    = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (PrimOp_    PrimOp
_  [a '[] 'U]
es)    = (a '[] 'U -> m) -> [a '[] 'U] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f [a '[] 'U]
es
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (ArrayOp_   ArrayOp
_  [a '[] 'U]
es)    = (a '[] 'U -> m) -> [a '[] 'U] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f [a '[] 'U]
es
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (MeasureOp_ SomeOp MeasureOp
_  [a '[] 'U]
es)    = (a '[] 'U -> m) -> [a '[] 'U] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f [a '[] 'U]
es
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (NaryOp_    NaryOp
_  [a '[] 'U]
es)    = (a '[] 'U -> m) -> [a '[] 'U] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f [a '[] 'U]
es
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
_ (Literal_   Some1 Literal
_)        = m
forall a. Monoid a => a
mempty
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Pair_      a '[] 'U
e1 a '[] 'U
e2)    = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e2
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Array_     a '[] 'U
e1 a '[ 'U] 'U
e2)    = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[ 'U] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[ 'U] 'U
e2
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (ArrayLiteral_ [a '[] 'U]
es)    = (a '[] 'U -> m) -> [a '[] 'U] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f [a '[] 'U]
es
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Datum_     Datum a
d)        = (a '[] 'U -> m) -> Datum a -> m
forall k m (abt :: [k] -> Untyped -> *).
Monoid m =>
(abt '[] 'U -> m) -> Datum abt -> m
foldDatum a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f Datum a
d
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Case_      a '[] 'U
e1 [Branch_ a]
bs)    = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (Branch_ a -> m) -> [Branch_ a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap ((a '[] 'U -> m) -> Branch_ a -> m
forall k (abt :: [k] -> Untyped -> *) m.
(abt '[] 'U -> m) -> Branch_ abt -> m
foldBranch a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f) [Branch_ a]
bs
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Dirac_     a '[] 'U
e1)       = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (MBind_     a '[] 'U
e1 a '[ 'U] 'U
e2)    = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[ 'U] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[ 'U] 'U
e2
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Plate_     a '[] 'U
e1 a '[ 'U] 'U
e2)    = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[ 'U] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[ 'U] 'U
e2
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Chain_     a '[] 'U
e1 a '[] 'U
e2 a '[ 'U] 'U
e3) = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e2 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[ 'U] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[ 'U] 'U
e3
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Integrate_ a '[] 'U
e1 a '[] 'U
e2 a '[ 'U] 'U
e3) = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e2 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[ 'U] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[ 'U] 'U
e3
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Summate_   a '[] 'U
e1 a '[] 'U
e2 a '[ 'U] 'U
e3) = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e2 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[ 'U] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[ 'U] 'U
e3
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Product_   a '[] 'U
e1 a '[] 'U
e2 a '[ 'U] 'U
e3) = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e2 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[ 'U] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[ 'U] 'U
e3
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Bucket_    a '[] 'U
e1 a '[] 'U
e2 Reducer xs a 'U
e3) = a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e2 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> Reducer xs a 'U -> m
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *) m
       (a :: k1 -> k2 -> *) (j :: k3).
(Foldable21 f, Monoid m) =>
(forall (h :: k1) (i :: k2). a h i -> m) -> f a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f Reducer xs a 'U
e3
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Transform_ Transform as x
_ SArgs a as
es)     = (forall (h :: [Untyped]) (i :: Untyped). a h i -> m)
-> SArgs a as -> m
forall k1 k2 k3 (f :: (k1 -> k2 -> *) -> k3 -> *) m
       (a :: k1 -> k2 -> *) (j :: k3).
(Foldable21 f, Monoid m) =>
(forall (h :: k1) (i :: k2). a h i -> m) -> f a j -> m
foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f SArgs a as
es
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f (Superpose_ NonEmpty (a '[] 'U, a '[] 'U)
es)       = ((a '[] 'U, a '[] 'U) -> m) -> NonEmpty (a '[] 'U, a '[] 'U) -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
F.foldMap (\(a '[] 'U
e1,a '[] 'U
e2) -> a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e1 m -> m -> m
forall a. Monoid a => a -> a -> a
`mappend` a '[] 'U -> m
forall (h :: [Untyped]) (i :: Untyped). a h i -> m
f a '[] 'U
e2) NonEmpty (a '[] 'U, a '[] 'U)
es
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
_ Term a j
Reject_               = m
forall a. Monoid a => a
mempty
    foldMap21 forall (h :: [Untyped]) (i :: Untyped). a h i -> m
_ InjTyped{}            = m
forall a. Monoid a => a
mempty

type U_ABT    = MetaABT SourceSpan Term
type AST      = U_ABT '[] 'U
type MetaTerm = Term U_ABT 'U
type Branch   = Branch_ U_ABT

type DFun_    = DFun    U_ABT
type DStruct_ = DStruct U_ABT
type DCode_   = DCode   U_ABT

----------------------------------------------------------------
---------------------------------------------------------- fin.