Data.ProtoLens.Compiler.Combinators

Some utility functions, classes and instances for nicer code generation.

Re-exports simpler versions of the types and constructors from haskell-src-exts.

We define orphan instances of IsString for various syntax datatypes, with some intelligence about Haskell names. For example, "foo" :: Exp is treated as a variable and Foo :: Exp is treated as a constructor.

Documentation

class App a where

Application of a Haskell type or expression to an argument. For example, to represent f x y, you can write

"f" @@ "x" @@ "y"

Minimal complete definition

(@@)

Methods

(@@) :: a -> a -> a infixl 2

Instances

App Type

Defined in Data.ProtoLens.Compiler.Combinators

Methods

(@@) :: Type -> Type -> Type

App Exp

Defined in Data.ProtoLens.Compiler.Combinators

Methods

(@@) :: Exp -> Exp -> Exp

type Promoted = Promoted ()

type Type = Type ()

type TyVarBind = TyVarBind ()

type QName = QName ()

type Pat = Pat ()

type Name = Name ()

type ModulePragma = ModulePragma ()

type ModuleName = ModuleName ()

type ExportSpec = ExportSpec ()

data CommentedDecl

A declaration, along with an optional comment.

Constructors

CommentedDecl (Maybe String) Decl

data Module

A hand-rolled type for modules, which allows comments on top-level declarations.

Constructors

Module ModuleName (Maybe [ExportSpec]) [ModulePragma] [ImportDecl ()] [CommentedDecl]

type Match = Match ()

type InstHead = InstHead ()

type FieldUpdate = FieldUpdate ()

type Alt = Alt ()

type Exp = Exp ()

type Deriving = Deriving ()

type Decl = Decl ()

type ConDecl = ConDecl ()

type Asst = Asst ()

prettyPrint :: Pretty a => a -> String

prettyPrim :: Pretty a => a -> Doc

classA :: QName -> [Type] -> Asst

equalP :: Type -> Type -> Asst

conDecl :: Name -> [Type] -> ConDecl

recDecl :: Name -> [(Name, Type)] -> ConDecl

patSynSig :: Name -> Type -> Decl

patSyn :: Pat -> Pat -> Decl

dataDecl :: Name -> [ConDecl] -> Deriving -> Decl

newtypeDecl :: Name -> Type -> Deriving -> Decl

dataDeclHelper :: DataOrNew () -> Name -> [ConDecl] -> Deriving -> Decl

deriving' :: [QName] -> Deriving

funBind :: [Match] -> Decl

instType :: Type -> Type -> InstDecl ()

instMatch :: [Match] -> InstDecl ()

instDeclWithTypes :: [Asst] -> InstHead -> [InstDecl ()] -> Decl

instDecl :: [Asst] -> InstHead -> [[Match]] -> Decl

typeSig :: [Name] -> Type -> Decl

let' :: [Decl] -> Exp -> Exp

case' :: Exp -> [Alt] -> Exp

alt :: Pat -> Exp -> Alt

stringExp :: String -> Exp

charExp :: Char -> Exp

tuple :: [Exp] -> Exp

lambda :: [Pat] -> Exp -> Exp

(@::@) :: Exp -> Type -> Exp infixl 2

recConstr :: QName -> [FieldUpdate] -> Exp

recUpdate :: Exp -> [FieldUpdate] -> Exp

var :: QName -> Exp

con :: QName -> Exp

list :: [Exp] -> Exp

fieldUpdate :: QName -> Exp -> FieldUpdate

ihApp :: InstHead -> [Type] -> InstHead

tyParen :: Type -> Type

match :: Name -> [Pat] -> Exp -> Match

A simple clause of a function binding.

guardedMatch :: Name -> [Pat] -> [(Exp, Exp)] -> Match

uncommented :: Decl -> CommentedDecl

commented :: String -> Decl -> CommentedDecl

prettyPrintModule :: Module -> String

getModuleName :: Module -> ModuleName

languagePragma :: [Name] -> ModulePragma

optionsGhcPragma :: String -> ModulePragma

exportVar :: QName -> ExportSpec

exportAll :: QName -> ExportSpec

exportWith :: QName -> [Name] -> ExportSpec

pApp :: QName -> [Pat] -> Pat

pVar :: Name -> Pat

pWildCard :: Pat

stringPat :: String -> Pat

qual :: ModuleName -> Name -> QName

unQual :: Name -> QName

tyCon :: QName -> Type

tyList :: Type -> Type

tyPromotedList :: [Type] -> Type

tyPromotedString :: String -> Type

tyPromotedCon :: Promoted -> Type

tyForAll :: [TyVarBind] -> [Asst] -> Type -> Type

tyBang :: Type -> Type

isIdentChar :: Char -> Bool

Whether this character belongs to an Ident (e.g., "foo") or a symbol (e.g., "$").

litInt :: Integer -> Exp

litFrac :: Rational -> Exp

pLitInt :: Integer -> Pat

string :: String -> Literal ()

char :: Char -> Literal ()

modifyModuleName :: (String -> String) -> ModuleName -> ModuleName

data ImportDecl l

An import declaration.

Constructors

ImportDecl

Fields

• importAnn :: l

  annotation, used by parser for position of the import keyword.

• importModule :: ModuleName l

  name of the module imported.

• importQualified :: Bool

  imported qualified?

• importSrc :: Bool

  imported with {-# SOURCE #-}?

• importSafe :: Bool

  Import safe?

• importPkg :: Maybe String

  imported with explicit package name

• importAs :: Maybe (ModuleName l)

  optional alias name in an as clause.

• importSpecs :: Maybe (ImportSpecList l)

  optional list of import specifications.

Instances

Functor ImportDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fmap :: (a -> b) -> ImportDecl a -> ImportDecl b

(<$) :: a -> ImportDecl b -> ImportDecl a

Foldable ImportDecl

Defined in Language.Haskell.Exts.Syntax

Methods

fold :: Monoid m => ImportDecl m -> m

foldMap :: Monoid m => (a -> m) -> ImportDecl a -> m

foldr :: (a -> b -> b) -> b -> ImportDecl a -> b

foldr' :: (a -> b -> b) -> b -> ImportDecl a -> b

foldl :: (b -> a -> b) -> b -> ImportDecl a -> b

foldl' :: (b -> a -> b) -> b -> ImportDecl a -> b

foldr1 :: (a -> a -> a) -> ImportDecl a -> a

foldl1 :: (a -> a -> a) -> ImportDecl a -> a

toList :: ImportDecl a -> [a]

null :: ImportDecl a -> Bool

length :: ImportDecl a -> Int

elem :: Eq a => a -> ImportDecl a -> Bool

maximum :: Ord a => ImportDecl a -> a

minimum :: Ord a => ImportDecl a -> a

sum :: Num a => ImportDecl a -> a

product :: Num a => ImportDecl a -> a

Traversable ImportDecl

Defined in Language.Haskell.Exts.Syntax

Methods

traverse :: Applicative f => (a -> f b) -> ImportDecl a -> f (ImportDecl b)

sequenceA :: Applicative f => ImportDecl (f a) -> f (ImportDecl a)

mapM :: Monad m => (a -> m b) -> ImportDecl a -> m (ImportDecl b)

sequence :: Monad m => ImportDecl (m a) -> m (ImportDecl a)

Annotated ImportDecl

Defined in Language.Haskell.Exts.Syntax

Methods

ann :: ImportDecl l -> l

amap :: (l -> l) -> ImportDecl l -> ImportDecl l

Eq l => Eq (ImportDecl l)

Defined in Language.Haskell.Exts.Syntax

Methods

(==) :: ImportDecl l -> ImportDecl l -> Bool

(/=) :: ImportDecl l -> ImportDecl l -> Bool

Data l => Data (ImportDecl l)

Defined in Language.Haskell.Exts.Syntax

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportDecl l -> c (ImportDecl l)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (ImportDecl l)

toConstr :: ImportDecl l -> Constr

dataTypeOf :: ImportDecl l -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (ImportDecl l))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (ImportDecl l))

gmapT :: (forall b. Data b => b -> b) -> ImportDecl l -> ImportDecl l

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportDecl l -> r

gmapQ :: (forall d. Data d => d -> u) -> ImportDecl l -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportDecl l -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportDecl l -> m (ImportDecl l)

Ord l => Ord (ImportDecl l)

Defined in Language.Haskell.Exts.Syntax

Methods

compare :: ImportDecl l -> ImportDecl l -> Ordering

(<) :: ImportDecl l -> ImportDecl l -> Bool

(<=) :: ImportDecl l -> ImportDecl l -> Bool

(>) :: ImportDecl l -> ImportDecl l -> Bool

(>=) :: ImportDecl l -> ImportDecl l -> Bool

max :: ImportDecl l -> ImportDecl l -> ImportDecl l

min :: ImportDecl l -> ImportDecl l -> ImportDecl l

Show l => Show (ImportDecl l)

Defined in Language.Haskell.Exts.Syntax

Methods

showsPrec :: Int -> ImportDecl l -> ShowS

show :: ImportDecl l -> String

showList :: [ImportDecl l] -> ShowS

Generic (ImportDecl l)

Defined in Language.Haskell.Exts.Syntax

Associated Types

type Rep (ImportDecl l) :: * -> *

Methods

from :: ImportDecl l -> Rep (ImportDecl l) x

to :: Rep (ImportDecl l) x -> ImportDecl l

Pretty (ImportDecl l)

Defined in Language.Haskell.Exts.Pretty

Methods

pretty :: ImportDecl l -> Doc

prettyPrec :: Int -> ImportDecl l -> Doc

type Rep (ImportDecl l)

Defined in Language.Haskell.Exts.Syntax

type Rep (ImportDecl l) = D1 (MetaData "ImportDecl" "Language.Haskell.Exts.Syntax" "haskell-src-exts-1.20.3-KjyAxm84ddk16DoDOnTGLG" False) (C1 (MetaCons "ImportDecl" PrefixI True) (((S1 (MetaSel (Just "importAnn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 l) :*: S1 (MetaSel (Just "importModule") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (ModuleName l))) :*: (S1 (MetaSel (Just "importQualified") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :*: S1 (MetaSel (Just "importSrc") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool))) :*: ((S1 (MetaSel (Just "importSafe") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Bool) :*: S1 (MetaSel (Just "importPkg") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe String))) :*: (S1 (MetaSel (Just "importAs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ModuleName l))) :*: S1 (MetaSel (Just "importSpecs") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe (ImportSpecList l)))))))

Orphan instances

IsString Promoted

Methods

fromString :: String -> Promoted

IsString Type

Methods

fromString :: String -> Type

IsString TyVarBind

Methods

fromString :: String -> TyVarBind

IsString QName

Methods

fromString :: String -> QName

IsString Pat

Methods

fromString :: String -> Pat

IsString Name

Methods

fromString :: String -> Name

IsString ModuleName

Methods

fromString :: String -> ModuleName

IsString InstHead

Methods

fromString :: String -> InstHead

IsString Exp

Methods

fromString :: String -> Exp