LambdaCube.Compiler.Patterns

Documentation

data ParseCheck

Constructors

TrackedCode Range

Reachable Range

Uncovered' SIName [PatList]

type PatList = ([ParPat_ ()], [(ParPat_ (), SExp)])

type ConsInfo = Either ((SName, Int), [(SIName, Int)]) Int

type Pat = Pat_ ConsInfo

data Pat_ c

Constructors

PVar SIName

PCon_ SI (SIName, c) [ParPat_ c]

ViewPat_ SI SExp (ParPat_ c)

PatType_ SI (ParPat_ c) SExp

Instances

Rearrange Pat

Methods

rearrange :: Int -> RearrangeFun -> Pat -> Pat

PatVars Pat

Methods

getPVars :: Pat -> [SIName]

PShow (Pat_ a)

Methods

pShow :: Pat_ a -> Doc

SetSourceInfo (Pat_ c)

Methods

setSI :: SI -> Pat_ c -> Pat_ c

SourceInfo (Pat_ c)

Methods

sourceInfo :: Pat_ c -> SI

type ParPat = ParPat_ ConsInfo

data ParPat_ c

Constructors

ParPat_ SI [Pat_ c]

Instances

Rearrange ParPat

Methods

rearrange :: Int -> RearrangeFun -> ParPat -> ParPat

PatVars ParPat

Methods

getPVars :: ParPat -> [SIName]

DeBruijnify SIName ParPat

Methods

deBruijnify_ :: Int -> [SIName] -> ParPat -> ParPat

PShow (ParPat_ a)

Methods

pShow :: ParPat_ a -> Doc

SetSourceInfo (ParPat_ c)

Methods

setSI :: SI -> ParPat_ c -> ParPat_ c

SourceInfo (ParPat_ c)

Methods

sourceInfo :: ParPat_ c -> SI

pattern ParPat :: forall t. [Pat_ t] -> ParPat_ t

pattern PWildcard :: forall t. SI -> ParPat_ t

pattern PCon :: forall t. (SIName, t) -> [ParPat_ t] -> Pat_ t

pattern ViewPat :: forall t. SExp -> ParPat_ t -> Pat_ t

pattern PatType :: forall t. ParPat_ t -> SExp -> Pat_ t

pattern PVarSimp :: forall t. SIName -> ParPat_ t

pattern PConSimp :: forall t. (SIName, t) -> [ParPat_ t] -> ParPat_ t

pattern ViewPatSimp :: forall t. SExp -> ParPat_ t -> ParPat_ t

pattern PatTypeSimp :: forall t. ParPat_ t -> SExp -> ParPat_ t

pBuiltin :: FNameTag -> Either (d1, [(FNameTag, d)]) d2 -> [ParPat_ (Either (d1, [(SIName, d)]) d2)] -> ParPat_ (Either (d1, [(SIName, d)]) d2)

cTrue :: (Num d, Num t) => ParPat_ (Either ((SName, t), [(SIName, d)]) d1)

cZero :: (Num d, Num t) => ParPat_ (Either ((SName, t), [(SIName, d)]) d1)

cNil :: (Num d, Num t) => ParPat_ (Either ((SName, t), [(SIName, d)]) d1)

cHNil :: (Num d, Num t, IsString t1) => ParPat_ (Either ((t1, t), [(SIName, d)]) d1)

cList :: Num d2 => ParPat_ (Either (d1, [(SIName, d)]) d2) -> ParPat_ (Either (d1, [(SIName, d)]) d2)

cHList :: Num d2 => ParPat_ (Either (d1, [(SIName, d)]) d2) -> ParPat_ (Either (d1, [(SIName, d)]) d2)

cSucc :: (Num d, Num t) => ParPat_ (Either ((SName, t), [(SIName, d)]) d1) -> ParPat_ (Either ((SName, t), [(SIName, d)]) d1)

cCons :: (Num d, Num t) => ParPat_ (Either ((SName, t), [(SIName, d)]) d1) -> ParPat_ (Either ((SName, t), [(SIName, d)]) d1) -> ParPat_ (Either ((SName, t), [(SIName, d)]) d1)

cHCons :: (Num d, Num t, IsString t1) => ParPat_ (Either ((t1, t), [(SIName, d)]) d1) -> ParPat_ (Either ((t1, t), [(SIName, d)]) d1) -> ParPat_ (Either ((t1, t), [(SIName, d)]) d1)

pattern PParens :: forall t. ParPat_ t -> ParPat_ t

mapP :: (Int -> SExp -> SExp) -> Int -> Pat -> Pat

mapPP :: (Int -> SExp -> SExp) -> Int -> ParPat_ ConsInfo -> ParPat_ ConsInfo

upPats :: PatVars a => (Int -> a -> t) -> Int -> [a] -> [t]

class PatVars a where

Minimal complete definition

getPVars

Methods

getPVars :: a -> [SIName]

Instances

PatVars ParPat

Methods

getPVars :: ParPat -> [SIName]

PatVars Pat

Methods

getPVars :: Pat -> [SIName]

PatVars a => PatVars [a]

Methods

getPVars :: [a] -> [SIName]

patVars :: PatVars a => a -> Int

type PMC = Writer ([CasePath], [Range])

type CasePath = [Maybe (SIName, Int, SExp)]

runPMC :: MonadWriter [ParseCheck] m => Maybe SIName -> [(Visibility, SExp)] -> PMC a -> m a

data Lets a

Constructors

LLet SIName SExp (Lets a)

LTypeAnn SExp (Lets a)

In a

Instances

Monoid GuardTrees

Methods

mempty :: GuardTrees

mappend :: GuardTrees -> GuardTrees -> GuardTrees

mconcat :: [GuardTrees] -> GuardTrees

DeBruijnify SIName a => DeBruijnify SIName (Lets a)

Methods

deBruijnify_ :: Int -> [SIName] -> Lets a -> Lets a

Rearrange a => Rearrange (Lets a)

Methods

rearrange :: Int -> RearrangeFun -> Lets a -> Lets a

lLet :: Rearrange a => SIName -> SExp' Void -> Lets a -> Lets a

foldLets :: (t1 -> t) -> Lets t1 -> t

mapLets :: Num t1 => (t1 -> SExp -> SExp) -> (t1 -> t -> a) -> t1 -> Lets t -> Lets a

data GuardTree

Constructors

GuardNode SExp (SIName, ConsInfo) [SIName] GuardTrees GuardTrees

GTSuccess SExp

GTFailure

Instances

Monoid GuardTrees

Methods

mempty :: GuardTrees

mappend :: GuardTrees -> GuardTrees -> GuardTrees

mconcat :: [GuardTrees] -> GuardTrees

Rearrange GuardTree

Methods

rearrange :: Int -> RearrangeFun -> GuardTree -> GuardTree

DeBruijnify SIName GuardTree

Methods

deBruijnify_ :: Int -> [SIName] -> GuardTree -> GuardTree

type GuardTrees = Lets GuardTree

noGuards :: SExp -> Lets GuardTree

mapGT :: (Int -> ParPat -> ParPat) -> (Int -> SExp -> SExp) -> Int -> GuardTree -> GuardTree

mapGTs :: (Int -> ParPat -> ParPat) -> (Int -> SExp -> SExp) -> Int -> Lets GuardTree -> Lets GuardTree

pattern Otherwise :: forall t. SExp' t

guardNode :: Pat -> SExp -> GuardTrees -> GuardTrees

guardNode' :: ParPat_ ConsInfo -> SExp' Void -> Lets GuardTree -> Lets GuardTree

buildNode :: (Rearrange t1, Rearrange b, PatVars t1) => (t1 -> SExp' t -> b -> b) -> Int -> [t1] -> [Int] -> b -> b

compilePatts :: [ParPat] -> GuardTrees -> GuardTrees

compileGuardTree :: MonadWriter [ParseCheck] m => (SExp -> SExp) -> (SExp -> SExp) -> Maybe SIName -> [(Visibility, SExp)] -> GuardTrees -> m SExp

compileGuardTrees :: MonadWriter [ParseCheck] m => (SExp -> SExp) -> Maybe SIName -> [(Visibility, SExp)] -> [GuardTrees] -> m SExp

compileGuardTrees' :: (MonadWriter [ParseCheck] f, Traversable t) => t1 -> [(Visibility, SExp)] -> t GuardTrees -> f (SExp' Void)

compileCase :: MonadWriter [ParseCheck] f => SExp' Void -> [(ParPat, GuardTrees)] -> f (SExp' Void)

patLam :: MonadWriter [ParseCheck] m => (SExp -> SExp) -> (Visibility, SExp) -> ParPat -> SExp -> m SExp