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

prettyPrint :: Pretty a => a -> String

type Asst = Asst ()

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

equalP :: Type -> Type -> Asst

type ConDecl = ConDecl ()

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

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

type Decl = Decl ()

patSynSig :: Name -> Type -> Decl

patSyn :: Pat -> Pat -> Decl

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

funBind :: [Match] -> Decl

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

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

type Exp = Exp ()

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

stringExp :: String -> 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

type FieldUpdate = FieldUpdate ()

fieldUpdate :: QName -> Exp -> FieldUpdate

type InstHead = InstHead ()

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

type Match = Match ()

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

A simple clause of a function binding.

type Module = Module ()

module' :: ModuleName -> [ModulePragma] -> [ImportDecl ()] -> [Decl] -> Module

type ModuleName = ModuleName ()

type ModulePragma = ModulePragma ()

languagePragma :: [Name] -> ModulePragma

optionsGhcPragma :: String -> ModulePragma

type Name = Name ()

type Pat = Pat ()

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

pVar :: Name -> Pat

pWildCard :: Pat

stringPat :: String -> Pat

type QName = QName ()

qual :: ModuleName -> Name -> QName

unQual :: Name -> QName

type TyVarBind = TyVarBind ()

type Type = Type ()

tyCon :: QName -> Type

tyList :: Type -> Type

tyPromotedString :: String -> Type

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

tyBang :: Type -> Type

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

Methods

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

App Exp

Methods

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

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 ()

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

Methods

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

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

Foldable ImportDecl

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

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

Methods

ann :: ImportDecl l -> l

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

Eq l => Eq (ImportDecl l)

Methods

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

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

Data l => Data (ImportDecl l)

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)

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)

Methods

showsPrec :: Int -> ImportDecl l -> ShowS

show :: ImportDecl l -> String

showList :: [ImportDecl l] -> ShowS

Generic (ImportDecl l)

Associated Types

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

Methods

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

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

Pretty (ImportDecl l)

Methods

pretty :: ImportDecl l -> Doc

prettyPrec :: Int -> ImportDecl l -> Doc

type Rep (ImportDecl l)

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

Orphan instances

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