-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Typesafe generation of haskell source code
--   
--   This library provides an interface to generate haskell source code,
--   verifying at compile time that the resulting code typechecks. See
--   <a>https://github.com/bennofs/haskell-generate</a> for an introduction
--   explaining how to use the library.
@package haskell-generate
@version 0.2.4

module Language.Haskell.Generate.Expression
newtype Expression t
Expression :: Exp -> Expression t
[runExpression] :: Expression t -> Exp
app :: Expression (a -> b) -> Expression a -> Expression b

module Language.Haskell.Generate.Monad

-- | This monad keeps track of a counter for generating unique names and
--   the set of modules that are needed for the expression.
newtype Generate a
Generate :: StateT Integer (Writer (Set ModuleName)) a -> Generate a
[unGenerate] :: Generate a -> StateT Integer (Writer (Set ModuleName)) a

-- | This is a type alias for a Generate action that returns an expression
--   of type <tt>t</tt>.
type ExpG t = Generate (Expression t)

-- | Extract the set of modules and the value from a Generate action.
runGenerate :: Generate a -> (a, Set ModuleName)

-- | Generate a new unique variable name with the given prefix. Note that
--   this new variable name is only unique relative to other variable names
--   generated by this function.
newName :: String -> Generate Name

-- | Use a haskell-src-exts Exp as the result of a Generate action.
returnE :: Exp -> ExpG t

-- | Import a function from a module. This function is polymorphic in the
--   type of the resulting expression, you should probably only use this
--   function to define type-restricted specializations.
--   
--   Example:
--   
--   <pre>
--   addInt :: ExpG (Int -&gt; Int -&gt; Int) -- Here we restricted the type to something sensible
--   addInt = useValue "Prelude" $ Symbol "+"
--   </pre>
useValue :: String -> Name -> ExpG a

-- | Import a value constructor from a module. Returns the qualified name
--   of the constructor.
useCon :: String -> Name -> Generate QName

-- | Use the value of a variable with the given name.
useVar :: Name -> ExpG t

-- | Generate a case expression.
caseE :: ExpG x -> [(Pat, ExpG t)] -> ExpG t

-- | Apply a function in a haskell expression to a value.
applyE :: ExpG (a -> b) -> ExpG a -> ExpG b

-- | ApplyE for 2 arguments
applyE2 :: ExpG (a -> b -> c) -> ExpG a -> ExpG b -> ExpG c

-- | Apply a function to 3 arguments
applyE3 :: ExpG (a -> b -> c -> d) -> ExpG a -> ExpG b -> ExpG c -> ExpG d

-- | Apply a function to 4 arguments
applyE4 :: ExpG (a -> b -> c -> d -> e) -> ExpG a -> ExpG b -> ExpG c -> ExpG d -> ExpG e

-- | Apply a function to 5 arguments
applyE5 :: ExpG (a -> b -> c -> d -> e -> f) -> ExpG a -> ExpG b -> ExpG c -> ExpG d -> ExpG e -> ExpG f

-- | Apply a function to 6 arguments
applyE6 :: ExpG (a -> b -> c -> d -> e -> f -> g) -> ExpG a -> ExpG b -> ExpG c -> ExpG d -> ExpG e -> ExpG f -> ExpG g

-- | Operator for <a>applyE</a>.
(<>$) :: ExpG (a -> b) -> ExpG a -> ExpG b

-- | Generate a expression from a haskell value. This can for example be
--   used to create lambdas:
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ generateExp $ expr (\x f -&gt; f &lt;&gt;$ x)
--   \ pvar_0 -&gt; \ pvar_1 -&gt; pvar_1 pvar_0
--   </pre>
--   
--   Or string literals:
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ generateExp $ expr "I'm a string!"
--   ['I', '\'', 'm', ' ', 'a', ' ', 's', 't', 'r', 'i', 'n', 'g', '!']
--   </pre>
class GenExp t where type family GenExpType t :: *

-- | This function generates the haskell expression from the given haskell
--   value.
expr :: GenExp t => t -> ExpG (GenExpType t)

-- | A module keeps track of the needed imports, but also has a list of
--   declarations in it.
newtype ModuleM a
ModuleM :: (Writer (Set ModuleName, [Decl]) a) -> ModuleM a

-- | This is the resulting type of a function generating a module. It is a
--   ModuleM action returning the export list.
type ModuleG = ModuleM (Maybe [ExportSpec])

-- | A reference to a function. With a reference to a function, you can
--   apply it (by lifting it into ExprT using <a>expr</a>) to some value or
--   export it using <a>exportFun</a>.
data FunRef t
FunRef :: Name -> FunRef t

-- | This type is used to represent variables, and also constructors.
data Name :: *

-- | <i>varid</i> or <i>conid</i>.
Ident :: String -> Name

-- | <i>varsym</i> or <i>consym</i>
Symbol :: String -> Name

-- | Generate a ExportSpec for a given function item.
exportFun :: FunRef t -> ExportSpec

-- | Add a declaration to the module. Return a reference to it that can be
--   used to either apply the function to some values or export it.
addDecl :: Name -> ExpG t -> ModuleM (FunRef t)

-- | Extract the Module from a module generator.
runModuleM :: ModuleG -> String -> Module

-- | Generate the source code for a module.
generateModule :: ModuleG -> String -> String

-- | Pretty print the expression generated by a given action.
generateExp :: ExpG t -> String
instance GHC.Base.Monad Language.Haskell.Generate.Monad.ModuleM
instance GHC.Base.Applicative Language.Haskell.Generate.Monad.ModuleM
instance GHC.Base.Functor Language.Haskell.Generate.Monad.ModuleM
instance GHC.Base.Monad Language.Haskell.Generate.Monad.Generate
instance GHC.Base.Applicative Language.Haskell.Generate.Monad.Generate
instance GHC.Base.Functor Language.Haskell.Generate.Monad.Generate
instance Language.Haskell.Generate.Monad.GenExp (Language.Haskell.Generate.Monad.ExpG a)
instance Language.Haskell.Generate.Monad.GenExp (Language.Haskell.Generate.Expression.Expression t)
instance Language.Haskell.Generate.Monad.GenExp GHC.Types.Char
instance Language.Haskell.Generate.Monad.GenExp GHC.Integer.Type.Integer
instance Language.Haskell.Generate.Monad.GenExp GHC.Real.Rational
instance Language.Haskell.Generate.Monad.GenExp a => Language.Haskell.Generate.Monad.GenExp [a]
instance Language.Haskell.Generate.Monad.GenExp x => Language.Haskell.Generate.Monad.GenExp (Language.Haskell.Generate.Monad.ExpG a -> x)
instance Language.Haskell.Generate.Monad.GenExp (Language.Haskell.Generate.Monad.FunRef t)

module Language.Haskell.Generate.TH

-- | Declare a function. The name of the definition will be the name of the
--   function with an added apostrophe. (Example: declareFunction 'add
--   generates a definition with the name add').
declareFunction :: Name -> DecsQ

-- | Declare a symbol, using the given name for the definition.
declareNamedSymbol :: (Name, String) -> DecsQ

-- | Make a ExpG for the given function, using the given name for the
--   definition.
declareNamedFunction :: (Name, String) -> DecsQ

-- | Make a ExpG for some thing, using the given name for the definition.
--   The third tuple element specifies the constructor to use for
--   constructing the Name. This can either be <tt>'Symbol</tt> (for
--   symbols) or <tt>'Ident</tt> (for functions).
declareNamedThing :: (Name, String, Name) -> DecsQ

module Language.Haskell.Generate.PreludeDef
nothing' :: ExpG (Maybe a_a9PI)
true' :: ExpG Bool
false' :: ExpG Bool
right' :: ExpG (b_aas7 -> Either a_aas6 b_aas7)
left' :: ExpG (a_aas6 -> Either a_aas6 b_aas7)
just' :: ExpG (a_a9PI -> Maybe a_a9PI)
readLn' :: Read a_aha6 => ExpG (IO a_aha6)
readIO' :: Read a_aha5 => ExpG (String -> IO a_aha5)
appendFile' :: ExpG (FilePath -> String -> IO ())
writeFile' :: ExpG (FilePath -> String -> IO ())
readFile' :: ExpG (FilePath -> IO String)
interact' :: ExpG ((String -> String) -> IO ())
getContents' :: ExpG (IO String)
getLine' :: ExpG (IO String)
getChar' :: ExpG (IO Char)
print' :: Show a_ah8A => ExpG (a_ah8A -> IO ())
putStrLn' :: ExpG (String -> IO ())
putStr' :: ExpG (String -> IO ())
putChar' :: ExpG (Char -> IO ())
show' :: Show a_aaWA => ExpG (a_aaWA -> String)
read' :: Read a_agYo => ExpG (String -> a_agYo)
unwords' :: ExpG ([String] -> String)
unlines' :: ExpG ([String] -> String)
words' :: ExpG (String -> [String])
lines' :: ExpG (String -> [String])
unzip3' :: ExpG ([(a_agYl, b_agYm, c_agYn)] -> ([a_agYl], [b_agYm], [c_agYn]))
unzip' :: ExpG ([(a_agYj, b_agYk)] -> ([a_agYj], [b_agYk]))
zipWith3' :: ExpG ((a_agYf -> b_agYg -> c_agYh -> d_agYi) -> [a_agYf] -> [b_agYg] -> [c_agYh] -> [d_agYi])
zipWith' :: ExpG ((a_agYc -> b_agYd -> c_agYe) -> [a_agYc] -> [b_agYd] -> [c_agYe])
zip3' :: ExpG ([a_agY9] -> [b_agYa] -> [c_agYb] -> [(a_agY9, b_agYa, c_agYb)])
zip' :: ExpG ([a_agY7] -> [b_agY8] -> [(a_agY7, b_agY8)])
lookup' :: Eq a_agY5 => ExpG (a_agY5 -> [(a_agY5, b_agY6)] -> Maybe b_agY6)
notElem' :: (Foldable t_agY4, Eq a_agY3) => ExpG (a_agY3 -> t_agY4 a_agY3 -> Bool)
elem' :: Foldable t_aaOT => forall a_agXW. Eq a_agXW => ExpG (a_agXW -> t_aaOT a_agXW -> Bool)
break' :: ExpG ((a_agXV -> Bool) -> [a_agXV] -> ([a_agXV], [a_agXV]))
span' :: ExpG ((a_agXU -> Bool) -> [a_agXU] -> ([a_agXU], [a_agXU]))
dropWhile' :: ExpG ((a_agXT -> Bool) -> [a_agXT] -> [a_agXT])
takeWhile' :: ExpG ((a_agXS -> Bool) -> [a_agXS] -> [a_agXS])
splitAt' :: ExpG (Int -> [a_agXR] -> ([a_agXR], [a_agXR]))
drop' :: ExpG (Int -> [a_agXQ] -> [a_agXQ])
take' :: ExpG (Int -> [a_agXP] -> [a_agXP])
cycle' :: ExpG ([a_agXO] -> [a_agXO])
replicate' :: ExpG (Int -> a_agXN -> [a_agXN])
repeat' :: ExpG (a_agXM -> [a_agXM])
iterate' :: ExpG ((a_agXL -> a_agXL) -> a_agXL -> [a_agXL])
scanr1' :: ExpG ((a_agXK -> a_agXK -> a_agXK) -> [a_agXK] -> [a_agXK])
scanl1' :: ExpG ((a_agXJ -> a_agXJ -> a_agXJ) -> [a_agXJ] -> [a_agXJ])
scanr' :: ExpG ((a_agXH -> b_agXI -> b_agXI) -> b_agXI -> [a_agXH] -> [b_agXI])
scanl' :: ExpG ((b_agXF -> a_agXG -> b_agXF) -> b_agXF -> [a_agXG] -> [b_agXF])
minimum' :: Foldable t_aaOT => forall a_agXE. Ord a_agXE => ExpG (t_aaOT a_agXE -> a_agXE)
maximum' :: Foldable t_aaOT => forall a_agXD. Ord a_agXD => ExpG (t_aaOT a_agXD -> a_agXD)
concatMap' :: Foldable t_agXC => ExpG ((a_agXA -> [b_agXB]) -> t_agXC a_agXA -> [b_agXB])
concat' :: Foldable t_agJh => ExpG (t_agJh [a_agJi] -> [a_agJi])
product' :: Foldable t_aaOT => forall a_agXz. Num a_agXz => ExpG (t_aaOT a_agXz -> a_agXz)
sum' :: Foldable t_aaOT => forall a_agXy. Num a_agXy => ExpG (t_aaOT a_agXy -> a_agXy)
all' :: Foldable t_agXx => ExpG ((a_agXw -> Bool) -> t_agXx a_agXw -> Bool)
any' :: Foldable t_agXv => ExpG ((a_agXu -> Bool) -> t_agXv a_agXu -> Bool)
or' :: Foldable t_agXt => ExpG (t_agXt Bool -> Bool)
and' :: Foldable t_agXs => ExpG (t_agXs Bool -> Bool)
foldr1' :: Foldable t_aaOT => forall a_agXr. ExpG ((a_agXr -> a_agXr -> a_agXr) -> t_aaOT a_agXr -> a_agXr)
foldl1' :: Foldable t_aaOT => forall a_aaPc. ExpG ((a_aaPc -> a_aaPc -> a_aaPc) -> t_aaOT a_aaPc -> a_aaPc)
foldr' :: Foldable t_aaOT => forall a_agXp b_agXq. ExpG ((a_agXp -> b_agXq -> b_agXq) -> b_agXq -> t_aaOT a_agXp -> b_agXq)
foldl' :: Foldable t_aaOT => forall b_agXn a_agXo. ExpG ((b_agXn -> a_agXo -> b_agXn) -> b_agXn -> t_aaOT a_agXo -> b_agXn)
reverse' :: ExpG ([a_agXm] -> [a_agXm])
length' :: Foldable t_aaOT => forall a_agXl. ExpG (t_aaOT a_agXl -> Int)
null' :: Foldable t_aaOT => forall a_agXk. ExpG (t_aaOT a_agXk -> Bool)
init' :: ExpG ([a_agXj] -> [a_agXj])
tail' :: ExpG ([a_agXi] -> [a_agXi])
last' :: ExpG ([a_agXh] -> a_agXh)
head' :: ExpG ([a_agXg] -> a_agXg)
filter' :: ExpG ((a_agXf -> Bool) -> [a_agXf] -> [a_agXf])
map' :: ExpG ((a_aaq9 -> b_aaqa) -> [a_aaq9] -> [b_aaqa])
undefined' :: ExpG a_12
asTypeOf' :: ExpG (a_agXe -> a_agXe -> a_agXe)
until' :: ExpG ((a_agXd -> Bool) -> (a_agXd -> a_agXd) -> a_agXd -> a_agXd)
flip' :: ExpG ((a_afMO -> b_afMP -> c_afMQ) -> b_afMP -> a_afMO -> c_afMQ)
const' :: ExpG (a_agXb -> b_agXc -> a_agXb)
id' :: ExpG (a_abib -> a_abib)
mapM_' :: (Foldable t_agXa, Monad m_agX8) => ExpG ((a_agX7 -> m_agX8 b_agX9) -> t_agXa a_agX7 -> m_agX8 ())
mapM' :: Traversable t_aaPj => forall a_aaYP m_aaYQ b_aaYR. Monad m_aaYQ => ExpG ((a_aaYP -> m_aaYQ b_aaYR) -> t_aaPj a_aaYP -> m_aaYQ (t_aaPj b_aaYR))
return' :: Monad m_a9S0 => forall a_aaie. ExpG (a_aaie -> m_a9S0 a_aaie)
fmap' :: Functor f_a9RH => forall a_a9Sj b_a9Sk. ExpG ((a_a9Sj -> b_a9Sk) -> f_a9RH a_a9Sj -> f_a9RH b_a9Sk)
realToFrac' :: (Real a_agWY, Fractional b_agWZ) => ExpG (a_agWY -> b_agWZ)
fromIntegral' :: (Integral a_agWW, Num b_agWX) => ExpG (a_agWW -> b_agWX)
lcm' :: Integral a_agWV => ExpG (a_agWV -> a_agWV -> a_agWV)
gcd' :: Integral a_agWU => ExpG (a_agWU -> a_agWU -> a_agWU)
odd' :: Integral a_agWT => ExpG (a_agWT -> Bool)
even' :: Integral a_agWS => ExpG (a_agWS -> Bool)
subtract' :: Num a_agWR => ExpG (a_agWR -> a_agWR -> a_agWR)
atan2' :: RealFloat a_agWy => ExpG (a_agWy -> a_agWy -> a_agWy)
isNegativeZero' :: RealFloat a_agWy => ExpG (a_agWy -> Bool)
isIEEE' :: RealFloat a_agWy => ExpG (a_agWy -> Bool)
isDenormalized' :: RealFloat a_agWy => ExpG (a_agWy -> Bool)
isInfinite' :: RealFloat a_agWy => ExpG (a_agWy -> Bool)
isNaN' :: RealFloat a_agWy => ExpG (a_agWy -> Bool)
scaleFloat' :: RealFloat a_agWy => ExpG (Int -> a_agWy -> a_agWy)
significand' :: RealFloat a_agWy => ExpG (a_agWy -> a_agWy)
exponent' :: RealFloat a_agWy => ExpG (a_agWy -> Int)
encodeFloat' :: RealFloat a_agWy => ExpG (Integer -> Int -> a_agWy)
decodeFloat' :: RealFloat a_agWy => ExpG (a_agWy -> (Integer, Int))
floatRange' :: RealFloat a_agWy => ExpG (a_agWy -> (Int, Int))
floatDigits' :: RealFloat a_agWy => ExpG (a_agWy -> Int)
floatRadix' :: RealFloat a_agWy => ExpG (a_agWy -> Integer)
floor' :: RealFrac a_agWi => forall b_agWw. Integral b_agWw => ExpG (a_agWi -> b_agWw)
ceiling' :: RealFrac a_agWi => forall b_agWv. Integral b_agWv => ExpG (a_agWi -> b_agWv)
round' :: RealFrac a_agWi => forall b_agWu. Integral b_agWu => ExpG (a_agWi -> b_agWu)
truncate' :: RealFrac a_agWi => forall b_agWt. Integral b_agWt => ExpG (a_agWi -> b_agWt)
properFraction' :: RealFrac a_agWi => forall b_agWs. Integral b_agWs => ExpG (a_agWi -> (b_agWs, a_agWi))
atanh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
acosh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
asinh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
tanh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
cosh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
sinh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
atan' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
acos' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
asin' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
tan' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
cos' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
sin' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
logBase' :: Floating a_agVV => ExpG (a_agVV -> a_agVV -> a_agVV)
sqrt' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
log' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
exp' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
pi' :: Floating a_agVV => ExpG a_agVV
fromRational' :: Fractional a_agVN => ExpG (Rational -> a_agVN)
recip' :: Fractional a_agVN => ExpG (a_agVN -> a_agVN)
toInteger' :: Integral a_agVA => ExpG (a_agVA -> Integer)
divMod' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> (a_agVA, a_agVA))
quotRem' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> (a_agVA, a_agVA))
mod' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> a_agVA)
div' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> a_agVA)
rem' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> a_agVA)
quot' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> a_agVA)
fromInteger' :: Num a_aaZQ => ExpG (Integer -> a_aaZQ)
signum' :: Num a_aaZQ => ExpG (a_aaZQ -> a_aaZQ)
abs' :: Num a_aaZQ => ExpG (a_aaZQ -> a_aaZQ)
negate' :: Num a_aaZQ => ExpG (a_aaZQ -> a_aaZQ)
not' :: ExpG (Bool -> Bool)
uncurry' :: ExpG ((a_agVw -> b_agVx -> c_agVy) -> (a_agVw, b_agVx) -> c_agVy)
curry' :: ExpG (((a_agVt, b_agVu) -> c_agVv) -> a_agVt -> b_agVu -> c_agVv)
snd' :: ExpG ((a_agVr, b_agVs) -> b_agVs)
fst' :: ExpG ((a_ab0n, b_ab0o) -> a_ab0n)
either' :: ExpG ((a_agVo -> c_agVp) -> (b_agVq -> c_agVp) -> Either a_agVo b_agVq -> c_agVp)
maybe' :: ExpG (b_afM6 -> (a_afM7 -> b_afM6) -> Maybe a_afM7 -> b_afM6)
notequal' :: Eq a_agXY => ExpG (a_agXY -> a_agXY -> Bool)
equal' :: Eq a_agXY => ExpG (a_agXY -> a_agXY -> Bool)
index' :: ExpG ([a_ai3R] -> Int -> a_ai3R)
append' :: ExpG ([a_aaWw] -> [a_aaWw] -> [a_aaWw])
then' :: Monad m_a9S0 => forall a_aai8 b_aai9. ExpG (m_a9S0 a_aai8 -> m_a9S0 b_aai9 -> m_a9S0 b_aai9)
bind' :: Monad m_a9S0 => forall a_aai2 b_aai3. ExpG (m_a9S0 a_aai2 -> (a_aai2 -> m_a9S0 b_aai3) -> m_a9S0 b_aai3)
floatPow' :: Floating a_agVV => ExpG (a_agVV -> a_agVV -> a_agVV)
divide' :: Fractional a_agVN => ExpG (a_agVN -> a_agVN -> a_agVN)
mult' :: Num a_aaZQ => ExpG (a_aaZQ -> a_aaZQ -> a_aaZQ)
add' :: Num a_aaZQ => ExpG (a_aaZQ -> a_aaZQ -> a_aaZQ)
dot' :: ExpG ((b_aaqm -> c_aaqn) -> (a_aaqo -> b_aaqm) -> a_aaqo -> c_aaqn)
(<>.) :: ExpG (b -> c) -> ExpG (a -> b) -> ExpG (a -> c)
tuple0 :: ExpG ()
tuple2 :: ExpG (a -> b -> (a, b))
tuple3 :: ExpG (a -> b -> c -> (a, b, c))
tuple4 :: ExpG (a -> b -> c -> d -> (a, b, c, d))
tuple5 :: ExpG (a -> b -> c -> d -> (a, b, c, d, e))
cons :: ExpG (a -> [a] -> [a])
instance GHC.Num.Num t => GHC.Num.Num (Language.Haskell.Generate.Monad.ExpG t)

module Language.Haskell.Generate