{-# LANGUAGE Strict #-}
{-# LANGUAGE TypeFamilies #-}
module Futhark.IR.Syntax
( module Language.Futhark.Core,
prettyString,
prettyText,
Pretty,
module Futhark.IR.Rep,
module Futhark.IR.Syntax.Core,
Uniqueness (..),
NoUniqueness (..),
Rank (..),
ArrayShape (..),
Space (..),
TypeBase (..),
Diet (..),
Ident (..),
SubExp (..),
PatElem (..),
Pat (..),
StmAux (..),
Stm (..),
Stms,
SubExpRes (..),
Result,
Body (..),
BasicOp (..),
UnOp (..),
BinOp (..),
CmpOp (..),
ConvOp (..),
OpaqueOp (..),
ReshapeKind (..),
WithAccInput,
Exp (..),
Case (..),
LoopForm (..),
MatchDec (..),
MatchSort (..),
Safety (..),
Lambda (..),
Param (..),
FParam,
LParam,
FunDef (..),
EntryParam (..),
EntryResult (..),
EntryPoint,
Prog (..),
oneStm,
stmsFromList,
stmsToList,
stmsHead,
stmsLast,
subExpRes,
subExpsRes,
varRes,
varsRes,
subExpResVName,
)
where
import Control.Category
import Data.Foldable
import Data.List.NonEmpty (NonEmpty (..))
import Data.Sequence qualified as Seq
import Data.Text qualified as T
import Data.Traversable (fmapDefault, foldMapDefault)
import Futhark.IR.Rep
import Futhark.IR.Syntax.Core
import Futhark.Util.Pretty (Pretty, prettyString, prettyText)
import Language.Futhark.Core
import Prelude hiding (id, (.))
newtype Pat dec = Pat {forall dec. Pat dec -> [PatElem dec]
patElems :: [PatElem dec]}
deriving (Pat dec -> Pat dec -> Bool
Pat dec -> Pat dec -> Ordering
Pat dec -> Pat dec -> Pat dec
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
forall {dec}. Ord dec => Eq (Pat dec)
forall dec. Ord dec => Pat dec -> Pat dec -> Bool
forall dec. Ord dec => Pat dec -> Pat dec -> Ordering
forall dec. Ord dec => Pat dec -> Pat dec -> Pat dec
min :: Pat dec -> Pat dec -> Pat dec
$cmin :: forall dec. Ord dec => Pat dec -> Pat dec -> Pat dec
max :: Pat dec -> Pat dec -> Pat dec
$cmax :: forall dec. Ord dec => Pat dec -> Pat dec -> Pat dec
>= :: Pat dec -> Pat dec -> Bool
$c>= :: forall dec. Ord dec => Pat dec -> Pat dec -> Bool
> :: Pat dec -> Pat dec -> Bool
$c> :: forall dec. Ord dec => Pat dec -> Pat dec -> Bool
<= :: Pat dec -> Pat dec -> Bool
$c<= :: forall dec. Ord dec => Pat dec -> Pat dec -> Bool
< :: Pat dec -> Pat dec -> Bool
$c< :: forall dec. Ord dec => Pat dec -> Pat dec -> Bool
compare :: Pat dec -> Pat dec -> Ordering
$ccompare :: forall dec. Ord dec => Pat dec -> Pat dec -> Ordering
Ord, Int -> Pat dec -> ShowS
forall dec. Show dec => Int -> Pat dec -> ShowS
forall dec. Show dec => [Pat dec] -> ShowS
forall dec. Show dec => Pat dec -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Pat dec] -> ShowS
$cshowList :: forall dec. Show dec => [Pat dec] -> ShowS
show :: Pat dec -> String
$cshow :: forall dec. Show dec => Pat dec -> String
showsPrec :: Int -> Pat dec -> ShowS
$cshowsPrec :: forall dec. Show dec => Int -> Pat dec -> ShowS
Show, Pat dec -> Pat dec -> Bool
forall dec. Eq dec => Pat dec -> Pat dec -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pat dec -> Pat dec -> Bool
$c/= :: forall dec. Eq dec => Pat dec -> Pat dec -> Bool
== :: Pat dec -> Pat dec -> Bool
$c== :: forall dec. Eq dec => Pat dec -> Pat dec -> Bool
Eq)
instance Semigroup (Pat dec) where
Pat [PatElem dec]
xs <> :: Pat dec -> Pat dec -> Pat dec
<> Pat [PatElem dec]
ys = forall dec. [PatElem dec] -> Pat dec
Pat ([PatElem dec]
xs forall a. Semigroup a => a -> a -> a
<> [PatElem dec]
ys)
instance Monoid (Pat dec) where
mempty :: Pat dec
mempty = forall dec. [PatElem dec] -> Pat dec
Pat forall a. Monoid a => a
mempty
instance Functor Pat where
fmap :: forall a b. (a -> b) -> Pat a -> Pat b
fmap = forall (t :: * -> *) a b. Traversable t => (a -> b) -> t a -> t b
fmapDefault
instance Foldable Pat where
foldMap :: forall m a. Monoid m => (a -> m) -> Pat a -> m
foldMap = forall (t :: * -> *) m a.
(Traversable t, Monoid m) =>
(a -> m) -> t a -> m
foldMapDefault
instance Traversable Pat where
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Pat a -> f (Pat b)
traverse a -> f b
f (Pat [PatElem a]
xs) =
forall dec. [PatElem dec] -> Pat dec
Pat forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse a -> f b
f) [PatElem a]
xs
data StmAux dec = StmAux
{ forall dec. StmAux dec -> Certs
stmAuxCerts :: !Certs,
forall dec. StmAux dec -> Attrs
stmAuxAttrs :: Attrs,
forall dec. StmAux dec -> dec
stmAuxDec :: dec
}
deriving (StmAux dec -> StmAux dec -> Bool
StmAux dec -> StmAux dec -> Ordering
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
forall {dec}. Ord dec => Eq (StmAux dec)
forall dec. Ord dec => StmAux dec -> StmAux dec -> Bool
forall dec. Ord dec => StmAux dec -> StmAux dec -> Ordering
forall dec. Ord dec => StmAux dec -> StmAux dec -> StmAux dec
min :: StmAux dec -> StmAux dec -> StmAux dec
$cmin :: forall dec. Ord dec => StmAux dec -> StmAux dec -> StmAux dec
max :: StmAux dec -> StmAux dec -> StmAux dec
$cmax :: forall dec. Ord dec => StmAux dec -> StmAux dec -> StmAux dec
>= :: StmAux dec -> StmAux dec -> Bool
$c>= :: forall dec. Ord dec => StmAux dec -> StmAux dec -> Bool
> :: StmAux dec -> StmAux dec -> Bool
$c> :: forall dec. Ord dec => StmAux dec -> StmAux dec -> Bool
<= :: StmAux dec -> StmAux dec -> Bool
$c<= :: forall dec. Ord dec => StmAux dec -> StmAux dec -> Bool
< :: StmAux dec -> StmAux dec -> Bool
$c< :: forall dec. Ord dec => StmAux dec -> StmAux dec -> Bool
compare :: StmAux dec -> StmAux dec -> Ordering
$ccompare :: forall dec. Ord dec => StmAux dec -> StmAux dec -> Ordering
Ord, Int -> StmAux dec -> ShowS
forall dec. Show dec => Int -> StmAux dec -> ShowS
forall dec. Show dec => [StmAux dec] -> ShowS
forall dec. Show dec => StmAux dec -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StmAux dec] -> ShowS
$cshowList :: forall dec. Show dec => [StmAux dec] -> ShowS
show :: StmAux dec -> String
$cshow :: forall dec. Show dec => StmAux dec -> String
showsPrec :: Int -> StmAux dec -> ShowS
$cshowsPrec :: forall dec. Show dec => Int -> StmAux dec -> ShowS
Show, StmAux dec -> StmAux dec -> Bool
forall dec. Eq dec => StmAux dec -> StmAux dec -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StmAux dec -> StmAux dec -> Bool
$c/= :: forall dec. Eq dec => StmAux dec -> StmAux dec -> Bool
== :: StmAux dec -> StmAux dec -> Bool
$c== :: forall dec. Eq dec => StmAux dec -> StmAux dec -> Bool
Eq)
instance Semigroup dec => Semigroup (StmAux dec) where
StmAux Certs
cs1 Attrs
attrs1 dec
dec1 <> :: StmAux dec -> StmAux dec -> StmAux dec
<> StmAux Certs
cs2 Attrs
attrs2 dec
dec2 =
forall dec. Certs -> Attrs -> dec -> StmAux dec
StmAux (Certs
cs1 forall a. Semigroup a => a -> a -> a
<> Certs
cs2) (Attrs
attrs1 forall a. Semigroup a => a -> a -> a
<> Attrs
attrs2) (dec
dec1 forall a. Semigroup a => a -> a -> a
<> dec
dec2)
data Stm rep = Let
{
forall rep. Stm rep -> Pat (LetDec rep)
stmPat :: Pat (LetDec rep),
forall rep. Stm rep -> StmAux (ExpDec rep)
stmAux :: StmAux (ExpDec rep),
forall rep. Stm rep -> Exp rep
stmExp :: Exp rep
}
deriving instance RepTypes rep => Ord (Stm rep)
deriving instance RepTypes rep => Show (Stm rep)
deriving instance RepTypes rep => Eq (Stm rep)
type Stms rep = Seq.Seq (Stm rep)
oneStm :: Stm rep -> Stms rep
oneStm :: forall rep. Stm rep -> Stms rep
oneStm = forall a. a -> Seq a
Seq.singleton
stmsFromList :: [Stm rep] -> Stms rep
stmsFromList :: forall rep. [Stm rep] -> Stms rep
stmsFromList = forall a. [a] -> Seq a
Seq.fromList
stmsToList :: Stms rep -> [Stm rep]
stmsToList :: forall rep. Stms rep -> [Stm rep]
stmsToList = forall (t :: * -> *) a. Foldable t => t a -> [a]
toList
stmsHead :: Stms rep -> Maybe (Stm rep, Stms rep)
stmsHead :: forall rep. Stms rep -> Maybe (Stm rep, Stms rep)
stmsHead Stms rep
stms = case forall a. Seq a -> ViewL a
Seq.viewl Stms rep
stms of
Stm rep
stm Seq.:< Stms rep
stms' -> forall a. a -> Maybe a
Just (Stm rep
stm, Stms rep
stms')
ViewL (Stm rep)
Seq.EmptyL -> forall a. Maybe a
Nothing
stmsLast :: Stms lore -> Maybe (Stms lore, Stm lore)
stmsLast :: forall lore. Stms lore -> Maybe (Stms lore, Stm lore)
stmsLast Stms lore
stms = case forall a. Seq a -> ViewR a
Seq.viewr Stms lore
stms of
Stms lore
stms' Seq.:> Stm lore
stm -> forall a. a -> Maybe a
Just (Stms lore
stms', Stm lore
stm)
ViewR (Stm lore)
Seq.EmptyR -> forall a. Maybe a
Nothing
data SubExpRes = SubExpRes
{ SubExpRes -> Certs
resCerts :: Certs,
SubExpRes -> SubExp
resSubExp :: SubExp
}
deriving (SubExpRes -> SubExpRes -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SubExpRes -> SubExpRes -> Bool
$c/= :: SubExpRes -> SubExpRes -> Bool
== :: SubExpRes -> SubExpRes -> Bool
$c== :: SubExpRes -> SubExpRes -> Bool
Eq, Eq SubExpRes
SubExpRes -> SubExpRes -> Bool
SubExpRes -> SubExpRes -> Ordering
SubExpRes -> SubExpRes -> SubExpRes
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 :: SubExpRes -> SubExpRes -> SubExpRes
$cmin :: SubExpRes -> SubExpRes -> SubExpRes
max :: SubExpRes -> SubExpRes -> SubExpRes
$cmax :: SubExpRes -> SubExpRes -> SubExpRes
>= :: SubExpRes -> SubExpRes -> Bool
$c>= :: SubExpRes -> SubExpRes -> Bool
> :: SubExpRes -> SubExpRes -> Bool
$c> :: SubExpRes -> SubExpRes -> Bool
<= :: SubExpRes -> SubExpRes -> Bool
$c<= :: SubExpRes -> SubExpRes -> Bool
< :: SubExpRes -> SubExpRes -> Bool
$c< :: SubExpRes -> SubExpRes -> Bool
compare :: SubExpRes -> SubExpRes -> Ordering
$ccompare :: SubExpRes -> SubExpRes -> Ordering
Ord, Int -> SubExpRes -> ShowS
[SubExpRes] -> ShowS
SubExpRes -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SubExpRes] -> ShowS
$cshowList :: [SubExpRes] -> ShowS
show :: SubExpRes -> String
$cshow :: SubExpRes -> String
showsPrec :: Int -> SubExpRes -> ShowS
$cshowsPrec :: Int -> SubExpRes -> ShowS
Show)
subExpRes :: SubExp -> SubExpRes
subExpRes :: SubExp -> SubExpRes
subExpRes = Certs -> SubExp -> SubExpRes
SubExpRes forall a. Monoid a => a
mempty
varRes :: VName -> SubExpRes
varRes :: VName -> SubExpRes
varRes = SubExp -> SubExpRes
subExpRes forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
. VName -> SubExp
Var
subExpsRes :: [SubExp] -> Result
subExpsRes :: [SubExp] -> [SubExpRes]
subExpsRes = forall a b. (a -> b) -> [a] -> [b]
map SubExp -> SubExpRes
subExpRes
varsRes :: [VName] -> Result
varsRes :: [VName] -> [SubExpRes]
varsRes = forall a b. (a -> b) -> [a] -> [b]
map VName -> SubExpRes
varRes
subExpResVName :: SubExpRes -> Maybe VName
subExpResVName :: SubExpRes -> Maybe VName
subExpResVName (SubExpRes Certs
_ (Var VName
v)) = forall a. a -> Maybe a
Just VName
v
subExpResVName SubExpRes
_ = forall a. Maybe a
Nothing
type Result = [SubExpRes]
data Body rep = Body
{ forall rep. Body rep -> BodyDec rep
bodyDec :: BodyDec rep,
forall rep. Body rep -> Stms rep
bodyStms :: Stms rep,
forall rep. Body rep -> [SubExpRes]
bodyResult :: Result
}
deriving instance RepTypes rep => Ord (Body rep)
deriving instance RepTypes rep => Show (Body rep)
deriving instance RepTypes rep => Eq (Body rep)
data OpaqueOp
=
OpaqueNil
|
OpaqueTrace T.Text
deriving (OpaqueOp -> OpaqueOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OpaqueOp -> OpaqueOp -> Bool
$c/= :: OpaqueOp -> OpaqueOp -> Bool
== :: OpaqueOp -> OpaqueOp -> Bool
$c== :: OpaqueOp -> OpaqueOp -> Bool
Eq, Eq OpaqueOp
OpaqueOp -> OpaqueOp -> Bool
OpaqueOp -> OpaqueOp -> Ordering
OpaqueOp -> OpaqueOp -> OpaqueOp
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 :: OpaqueOp -> OpaqueOp -> OpaqueOp
$cmin :: OpaqueOp -> OpaqueOp -> OpaqueOp
max :: OpaqueOp -> OpaqueOp -> OpaqueOp
$cmax :: OpaqueOp -> OpaqueOp -> OpaqueOp
>= :: OpaqueOp -> OpaqueOp -> Bool
$c>= :: OpaqueOp -> OpaqueOp -> Bool
> :: OpaqueOp -> OpaqueOp -> Bool
$c> :: OpaqueOp -> OpaqueOp -> Bool
<= :: OpaqueOp -> OpaqueOp -> Bool
$c<= :: OpaqueOp -> OpaqueOp -> Bool
< :: OpaqueOp -> OpaqueOp -> Bool
$c< :: OpaqueOp -> OpaqueOp -> Bool
compare :: OpaqueOp -> OpaqueOp -> Ordering
$ccompare :: OpaqueOp -> OpaqueOp -> Ordering
Ord, Int -> OpaqueOp -> ShowS
[OpaqueOp] -> ShowS
OpaqueOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OpaqueOp] -> ShowS
$cshowList :: [OpaqueOp] -> ShowS
show :: OpaqueOp -> String
$cshow :: OpaqueOp -> String
showsPrec :: Int -> OpaqueOp -> ShowS
$cshowsPrec :: Int -> OpaqueOp -> ShowS
Show)
data ReshapeKind
=
ReshapeCoerce
|
ReshapeArbitrary
deriving (ReshapeKind -> ReshapeKind -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ReshapeKind -> ReshapeKind -> Bool
$c/= :: ReshapeKind -> ReshapeKind -> Bool
== :: ReshapeKind -> ReshapeKind -> Bool
$c== :: ReshapeKind -> ReshapeKind -> Bool
Eq, Eq ReshapeKind
ReshapeKind -> ReshapeKind -> Bool
ReshapeKind -> ReshapeKind -> Ordering
ReshapeKind -> ReshapeKind -> ReshapeKind
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 :: ReshapeKind -> ReshapeKind -> ReshapeKind
$cmin :: ReshapeKind -> ReshapeKind -> ReshapeKind
max :: ReshapeKind -> ReshapeKind -> ReshapeKind
$cmax :: ReshapeKind -> ReshapeKind -> ReshapeKind
>= :: ReshapeKind -> ReshapeKind -> Bool
$c>= :: ReshapeKind -> ReshapeKind -> Bool
> :: ReshapeKind -> ReshapeKind -> Bool
$c> :: ReshapeKind -> ReshapeKind -> Bool
<= :: ReshapeKind -> ReshapeKind -> Bool
$c<= :: ReshapeKind -> ReshapeKind -> Bool
< :: ReshapeKind -> ReshapeKind -> Bool
$c< :: ReshapeKind -> ReshapeKind -> Bool
compare :: ReshapeKind -> ReshapeKind -> Ordering
$ccompare :: ReshapeKind -> ReshapeKind -> Ordering
Ord, Int -> ReshapeKind -> ShowS
[ReshapeKind] -> ShowS
ReshapeKind -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ReshapeKind] -> ShowS
$cshowList :: [ReshapeKind] -> ShowS
show :: ReshapeKind -> String
$cshow :: ReshapeKind -> String
showsPrec :: Int -> ReshapeKind -> ShowS
$cshowsPrec :: Int -> ReshapeKind -> ShowS
Show)
data BasicOp
=
SubExp SubExp
|
Opaque OpaqueOp SubExp
|
ArrayLit [SubExp] Type
|
UnOp UnOp SubExp
|
BinOp BinOp SubExp SubExp
|
CmpOp CmpOp SubExp SubExp
|
ConvOp ConvOp SubExp
|
Assert SubExp (ErrorMsg SubExp) (SrcLoc, [SrcLoc])
|
Index VName (Slice SubExp)
|
Update Safety VName (Slice SubExp) SubExp
| FlatIndex VName (FlatSlice SubExp)
| FlatUpdate VName (FlatSlice SubExp) VName
|
Concat Int (NonEmpty VName) SubExp
|
Copy VName
|
Manifest [Int] VName
|
Iota SubExp SubExp SubExp IntType
|
Replicate Shape SubExp
|
Scratch PrimType [SubExp]
|
Reshape ReshapeKind Shape VName
|
Rearrange [Int] VName
|
Rotate [SubExp] VName
|
UpdateAcc VName [SubExp] [SubExp]
deriving (BasicOp -> BasicOp -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BasicOp -> BasicOp -> Bool
$c/= :: BasicOp -> BasicOp -> Bool
== :: BasicOp -> BasicOp -> Bool
$c== :: BasicOp -> BasicOp -> Bool
Eq, Eq BasicOp
BasicOp -> BasicOp -> Bool
BasicOp -> BasicOp -> Ordering
BasicOp -> BasicOp -> BasicOp
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 :: BasicOp -> BasicOp -> BasicOp
$cmin :: BasicOp -> BasicOp -> BasicOp
max :: BasicOp -> BasicOp -> BasicOp
$cmax :: BasicOp -> BasicOp -> BasicOp
>= :: BasicOp -> BasicOp -> Bool
$c>= :: BasicOp -> BasicOp -> Bool
> :: BasicOp -> BasicOp -> Bool
$c> :: BasicOp -> BasicOp -> Bool
<= :: BasicOp -> BasicOp -> Bool
$c<= :: BasicOp -> BasicOp -> Bool
< :: BasicOp -> BasicOp -> Bool
$c< :: BasicOp -> BasicOp -> Bool
compare :: BasicOp -> BasicOp -> Ordering
$ccompare :: BasicOp -> BasicOp -> Ordering
Ord, Int -> BasicOp -> ShowS
[BasicOp] -> ShowS
BasicOp -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BasicOp] -> ShowS
$cshowList :: [BasicOp] -> ShowS
show :: BasicOp -> String
$cshow :: BasicOp -> String
showsPrec :: Int -> BasicOp -> ShowS
$cshowsPrec :: Int -> BasicOp -> ShowS
Show)
type WithAccInput rep =
(Shape, [VName], Maybe (Lambda rep, [SubExp]))
data Case body = Case {forall body. Case body -> [Maybe PrimValue]
casePat :: [Maybe PrimValue], forall body. Case body -> body
caseBody :: body}
deriving (Case body -> Case body -> Bool
forall body. Eq body => Case body -> Case body -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Case body -> Case body -> Bool
$c/= :: forall body. Eq body => Case body -> Case body -> Bool
== :: Case body -> Case body -> Bool
$c== :: forall body. Eq body => Case body -> Case body -> Bool
Eq, Case body -> Case body -> Bool
Case body -> Case body -> Ordering
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
forall {body}. Ord body => Eq (Case body)
forall body. Ord body => Case body -> Case body -> Bool
forall body. Ord body => Case body -> Case body -> Ordering
forall body. Ord body => Case body -> Case body -> Case body
min :: Case body -> Case body -> Case body
$cmin :: forall body. Ord body => Case body -> Case body -> Case body
max :: Case body -> Case body -> Case body
$cmax :: forall body. Ord body => Case body -> Case body -> Case body
>= :: Case body -> Case body -> Bool
$c>= :: forall body. Ord body => Case body -> Case body -> Bool
> :: Case body -> Case body -> Bool
$c> :: forall body. Ord body => Case body -> Case body -> Bool
<= :: Case body -> Case body -> Bool
$c<= :: forall body. Ord body => Case body -> Case body -> Bool
< :: Case body -> Case body -> Bool
$c< :: forall body. Ord body => Case body -> Case body -> Bool
compare :: Case body -> Case body -> Ordering
$ccompare :: forall body. Ord body => Case body -> Case body -> Ordering
Ord, Int -> Case body -> ShowS
forall body. Show body => Int -> Case body -> ShowS
forall body. Show body => [Case body] -> ShowS
forall body. Show body => Case body -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Case body] -> ShowS
$cshowList :: forall body. Show body => [Case body] -> ShowS
show :: Case body -> String
$cshow :: forall body. Show body => Case body -> String
showsPrec :: Int -> Case body -> ShowS
$cshowsPrec :: forall body. Show body => Int -> Case body -> ShowS
Show)
instance Functor Case where
fmap :: forall a b. (a -> b) -> Case a -> Case b
fmap = forall (t :: * -> *) a b. Traversable t => (a -> b) -> t a -> t b
fmapDefault
instance Foldable Case where
foldMap :: forall m a. Monoid m => (a -> m) -> Case a -> m
foldMap = forall (t :: * -> *) m a.
(Traversable t, Monoid m) =>
(a -> m) -> t a -> m
foldMapDefault
instance Traversable Case where
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Case a -> f (Case b)
traverse a -> f b
f (Case [Maybe PrimValue]
vs a
b) = forall body. [Maybe PrimValue] -> body -> Case body
Case [Maybe PrimValue]
vs forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
b
data Exp rep
=
BasicOp BasicOp
| Apply Name [(SubExp, Diet)] [RetType rep] (Safety, SrcLoc, [SrcLoc])
|
Match [SubExp] [Case (Body rep)] (Body rep) (MatchDec (BranchType rep))
|
DoLoop [(FParam rep, SubExp)] (LoopForm rep) (Body rep)
|
WithAcc [WithAccInput rep] (Lambda rep)
| Op (Op rep)
deriving instance RepTypes rep => Eq (Exp rep)
deriving instance RepTypes rep => Show (Exp rep)
deriving instance RepTypes rep => Ord (Exp rep)
data LoopForm rep
= ForLoop
VName
IntType
SubExp
[(LParam rep, VName)]
| WhileLoop VName
deriving instance RepTypes rep => Eq (LoopForm rep)
deriving instance RepTypes rep => Show (LoopForm rep)
deriving instance RepTypes rep => Ord (LoopForm rep)
data MatchDec rt = MatchDec
{ forall rt. MatchDec rt -> [rt]
matchReturns :: [rt],
forall rt. MatchDec rt -> MatchSort
matchSort :: MatchSort
}
deriving (MatchDec rt -> MatchDec rt -> Bool
forall rt. Eq rt => MatchDec rt -> MatchDec rt -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MatchDec rt -> MatchDec rt -> Bool
$c/= :: forall rt. Eq rt => MatchDec rt -> MatchDec rt -> Bool
== :: MatchDec rt -> MatchDec rt -> Bool
$c== :: forall rt. Eq rt => MatchDec rt -> MatchDec rt -> Bool
Eq, Int -> MatchDec rt -> ShowS
forall rt. Show rt => Int -> MatchDec rt -> ShowS
forall rt. Show rt => [MatchDec rt] -> ShowS
forall rt. Show rt => MatchDec rt -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MatchDec rt] -> ShowS
$cshowList :: forall rt. Show rt => [MatchDec rt] -> ShowS
show :: MatchDec rt -> String
$cshow :: forall rt. Show rt => MatchDec rt -> String
showsPrec :: Int -> MatchDec rt -> ShowS
$cshowsPrec :: forall rt. Show rt => Int -> MatchDec rt -> ShowS
Show, MatchDec rt -> MatchDec rt -> Bool
MatchDec rt -> MatchDec rt -> Ordering
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
forall {rt}. Ord rt => Eq (MatchDec rt)
forall rt. Ord rt => MatchDec rt -> MatchDec rt -> Bool
forall rt. Ord rt => MatchDec rt -> MatchDec rt -> Ordering
forall rt. Ord rt => MatchDec rt -> MatchDec rt -> MatchDec rt
min :: MatchDec rt -> MatchDec rt -> MatchDec rt
$cmin :: forall rt. Ord rt => MatchDec rt -> MatchDec rt -> MatchDec rt
max :: MatchDec rt -> MatchDec rt -> MatchDec rt
$cmax :: forall rt. Ord rt => MatchDec rt -> MatchDec rt -> MatchDec rt
>= :: MatchDec rt -> MatchDec rt -> Bool
$c>= :: forall rt. Ord rt => MatchDec rt -> MatchDec rt -> Bool
> :: MatchDec rt -> MatchDec rt -> Bool
$c> :: forall rt. Ord rt => MatchDec rt -> MatchDec rt -> Bool
<= :: MatchDec rt -> MatchDec rt -> Bool
$c<= :: forall rt. Ord rt => MatchDec rt -> MatchDec rt -> Bool
< :: MatchDec rt -> MatchDec rt -> Bool
$c< :: forall rt. Ord rt => MatchDec rt -> MatchDec rt -> Bool
compare :: MatchDec rt -> MatchDec rt -> Ordering
$ccompare :: forall rt. Ord rt => MatchDec rt -> MatchDec rt -> Ordering
Ord)
data MatchSort
=
MatchNormal
|
MatchFallback
|
MatchEquiv
deriving (MatchSort -> MatchSort -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MatchSort -> MatchSort -> Bool
$c/= :: MatchSort -> MatchSort -> Bool
== :: MatchSort -> MatchSort -> Bool
$c== :: MatchSort -> MatchSort -> Bool
Eq, Int -> MatchSort -> ShowS
[MatchSort] -> ShowS
MatchSort -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MatchSort] -> ShowS
$cshowList :: [MatchSort] -> ShowS
show :: MatchSort -> String
$cshow :: MatchSort -> String
showsPrec :: Int -> MatchSort -> ShowS
$cshowsPrec :: Int -> MatchSort -> ShowS
Show, Eq MatchSort
MatchSort -> MatchSort -> Bool
MatchSort -> MatchSort -> Ordering
MatchSort -> MatchSort -> MatchSort
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 :: MatchSort -> MatchSort -> MatchSort
$cmin :: MatchSort -> MatchSort -> MatchSort
max :: MatchSort -> MatchSort -> MatchSort
$cmax :: MatchSort -> MatchSort -> MatchSort
>= :: MatchSort -> MatchSort -> Bool
$c>= :: MatchSort -> MatchSort -> Bool
> :: MatchSort -> MatchSort -> Bool
$c> :: MatchSort -> MatchSort -> Bool
<= :: MatchSort -> MatchSort -> Bool
$c<= :: MatchSort -> MatchSort -> Bool
< :: MatchSort -> MatchSort -> Bool
$c< :: MatchSort -> MatchSort -> Bool
compare :: MatchSort -> MatchSort -> Ordering
$ccompare :: MatchSort -> MatchSort -> Ordering
Ord)
data Lambda rep = Lambda
{ forall rep. Lambda rep -> [LParam rep]
lambdaParams :: [LParam rep],
forall rep. Lambda rep -> Body rep
lambdaBody :: Body rep,
forall rep. Lambda rep -> [Type]
lambdaReturnType :: [Type]
}
deriving instance RepTypes rep => Eq (Lambda rep)
deriving instance RepTypes rep => Show (Lambda rep)
deriving instance RepTypes rep => Ord (Lambda rep)
type FParam rep = Param (FParamInfo rep)
type LParam rep = Param (LParamInfo rep)
data FunDef rep = FunDef
{
forall rep. FunDef rep -> Maybe EntryPoint
funDefEntryPoint :: Maybe EntryPoint,
forall rep. FunDef rep -> Attrs
funDefAttrs :: Attrs,
forall rep. FunDef rep -> Name
funDefName :: Name,
forall rep. FunDef rep -> [RetType rep]
funDefRetType :: [RetType rep],
forall rep. FunDef rep -> [FParam rep]
funDefParams :: [FParam rep],
forall rep. FunDef rep -> Body rep
funDefBody :: Body rep
}
deriving instance RepTypes rep => Eq (FunDef rep)
deriving instance RepTypes rep => Show (FunDef rep)
deriving instance RepTypes rep => Ord (FunDef rep)
data EntryParam = EntryParam
{ EntryParam -> Name
entryParamName :: Name,
EntryParam -> Uniqueness
entryParamUniqueness :: Uniqueness,
EntryParam -> EntryPointType
entryParamType :: EntryPointType
}
deriving (EntryParam -> EntryParam -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EntryParam -> EntryParam -> Bool
$c/= :: EntryParam -> EntryParam -> Bool
== :: EntryParam -> EntryParam -> Bool
$c== :: EntryParam -> EntryParam -> Bool
Eq, Int -> EntryParam -> ShowS
[EntryParam] -> ShowS
EntryParam -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EntryParam] -> ShowS
$cshowList :: [EntryParam] -> ShowS
show :: EntryParam -> String
$cshow :: EntryParam -> String
showsPrec :: Int -> EntryParam -> ShowS
$cshowsPrec :: Int -> EntryParam -> ShowS
Show, Eq EntryParam
EntryParam -> EntryParam -> Bool
EntryParam -> EntryParam -> Ordering
EntryParam -> EntryParam -> EntryParam
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 :: EntryParam -> EntryParam -> EntryParam
$cmin :: EntryParam -> EntryParam -> EntryParam
max :: EntryParam -> EntryParam -> EntryParam
$cmax :: EntryParam -> EntryParam -> EntryParam
>= :: EntryParam -> EntryParam -> Bool
$c>= :: EntryParam -> EntryParam -> Bool
> :: EntryParam -> EntryParam -> Bool
$c> :: EntryParam -> EntryParam -> Bool
<= :: EntryParam -> EntryParam -> Bool
$c<= :: EntryParam -> EntryParam -> Bool
< :: EntryParam -> EntryParam -> Bool
$c< :: EntryParam -> EntryParam -> Bool
compare :: EntryParam -> EntryParam -> Ordering
$ccompare :: EntryParam -> EntryParam -> Ordering
Ord)
data EntryResult = EntryResult
{ EntryResult -> Uniqueness
entryResultUniqueness :: Uniqueness,
EntryResult -> EntryPointType
entryResultType :: EntryPointType
}
deriving (EntryResult -> EntryResult -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: EntryResult -> EntryResult -> Bool
$c/= :: EntryResult -> EntryResult -> Bool
== :: EntryResult -> EntryResult -> Bool
$c== :: EntryResult -> EntryResult -> Bool
Eq, Int -> EntryResult -> ShowS
[EntryResult] -> ShowS
EntryResult -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [EntryResult] -> ShowS
$cshowList :: [EntryResult] -> ShowS
show :: EntryResult -> String
$cshow :: EntryResult -> String
showsPrec :: Int -> EntryResult -> ShowS
$cshowsPrec :: Int -> EntryResult -> ShowS
Show, Eq EntryResult
EntryResult -> EntryResult -> Bool
EntryResult -> EntryResult -> Ordering
EntryResult -> EntryResult -> EntryResult
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 :: EntryResult -> EntryResult -> EntryResult
$cmin :: EntryResult -> EntryResult -> EntryResult
max :: EntryResult -> EntryResult -> EntryResult
$cmax :: EntryResult -> EntryResult -> EntryResult
>= :: EntryResult -> EntryResult -> Bool
$c>= :: EntryResult -> EntryResult -> Bool
> :: EntryResult -> EntryResult -> Bool
$c> :: EntryResult -> EntryResult -> Bool
<= :: EntryResult -> EntryResult -> Bool
$c<= :: EntryResult -> EntryResult -> Bool
< :: EntryResult -> EntryResult -> Bool
$c< :: EntryResult -> EntryResult -> Bool
compare :: EntryResult -> EntryResult -> Ordering
$ccompare :: EntryResult -> EntryResult -> Ordering
Ord)
type EntryPoint = (Name, [EntryParam], [EntryResult])
data Prog rep = Prog
{
forall rep. Prog rep -> OpaqueTypes
progTypes :: OpaqueTypes,
forall rep. Prog rep -> Stms rep
progConsts :: Stms rep,
forall rep. Prog rep -> [FunDef rep]
progFuns :: [FunDef rep]
}
deriving (Prog rep -> Prog rep -> Bool
forall rep. RepTypes rep => Prog rep -> Prog rep -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Prog rep -> Prog rep -> Bool
$c/= :: forall rep. RepTypes rep => Prog rep -> Prog rep -> Bool
== :: Prog rep -> Prog rep -> Bool
$c== :: forall rep. RepTypes rep => Prog rep -> Prog rep -> Bool
Eq, Prog rep -> Prog rep -> Bool
Prog rep -> Prog rep -> Ordering
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
forall rep. RepTypes rep => Eq (Prog rep)
forall rep. RepTypes rep => Prog rep -> Prog rep -> Bool
forall rep. RepTypes rep => Prog rep -> Prog rep -> Ordering
forall rep. RepTypes rep => Prog rep -> Prog rep -> Prog rep
min :: Prog rep -> Prog rep -> Prog rep
$cmin :: forall rep. RepTypes rep => Prog rep -> Prog rep -> Prog rep
max :: Prog rep -> Prog rep -> Prog rep
$cmax :: forall rep. RepTypes rep => Prog rep -> Prog rep -> Prog rep
>= :: Prog rep -> Prog rep -> Bool
$c>= :: forall rep. RepTypes rep => Prog rep -> Prog rep -> Bool
> :: Prog rep -> Prog rep -> Bool
$c> :: forall rep. RepTypes rep => Prog rep -> Prog rep -> Bool
<= :: Prog rep -> Prog rep -> Bool
$c<= :: forall rep. RepTypes rep => Prog rep -> Prog rep -> Bool
< :: Prog rep -> Prog rep -> Bool
$c< :: forall rep. RepTypes rep => Prog rep -> Prog rep -> Bool
compare :: Prog rep -> Prog rep -> Ordering
$ccompare :: forall rep. RepTypes rep => Prog rep -> Prog rep -> Ordering
Ord, Int -> Prog rep -> ShowS
forall rep. RepTypes rep => Int -> Prog rep -> ShowS
forall rep. RepTypes rep => [Prog rep] -> ShowS
forall rep. RepTypes rep => Prog rep -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Prog rep] -> ShowS
$cshowList :: forall rep. RepTypes rep => [Prog rep] -> ShowS
show :: Prog rep -> String
$cshow :: forall rep. RepTypes rep => Prog rep -> String
showsPrec :: Int -> Prog rep -> ShowS
$cshowsPrec :: forall rep. RepTypes rep => Int -> Prog rep -> ShowS
Show)