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


-- | haskell-generate
--   
--   haskell-generate
@package haskell-generate
@version 0.2.2

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 :: *
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 Functor Generate
instance Applicative Generate
instance Monad Generate
instance Functor ModuleM
instance Applicative ModuleM
instance Monad ModuleM
instance GenExp (FunRef t)
instance GenExp x => GenExp (ExpG a -> x)
instance GenExp a => GenExp [a]
instance GenExp Rational
instance GenExp Integer
instance GenExp Char
instance GenExp (Expression t)
instance GenExp (ExpG a)

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_a3aC)
true' :: ExpG Bool
false' :: ExpG Bool
right' :: ExpG (b_a7F7 -> Either a_a7F6 b_a7F7)
left' :: ExpG (a_a7F2 -> Either a_a7F2 b_a7F3)
just' :: ExpG (a_a3aF -> Maybe a_a3aF)
readLn' :: Read a_a7NB => ExpG (IO a_a7NB)
readIO' :: Read a_a7NA => ExpG (String -> IO a_a7NA)
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_a7Mn => ExpG (a_a7Mn -> IO ())
putStrLn' :: ExpG (String -> IO ())
putStr' :: ExpG (String -> IO ())
putChar' :: ExpG (Char -> IO ())
show' :: Show a_a4kA => ExpG (a_a4kA -> String)
read' :: Read a_a7GO => ExpG (String -> a_a7GO)
unwords' :: ExpG ([String] -> String)
unlines' :: ExpG ([String] -> String)
words' :: ExpG (String -> [String])
lines' :: ExpG (String -> [String])
unzip3' :: ExpG ([(a_a7GL, b_a7GM, c_a7GN)] -> ([a_a7GL], [b_a7GM], [c_a7GN]))
unzip' :: ExpG ([(a_a7GJ, b_a7GK)] -> ([a_a7GJ], [b_a7GK]))
zipWith3' :: ExpG ((a_a7GF -> b_a7GG -> c_a7GH -> d_a7GI) -> [a_a7GF] -> [b_a7GG] -> [c_a7GH] -> [d_a7GI])
zipWith' :: ExpG ((a_a7GC -> b_a7GD -> c_a7GE) -> [a_a7GC] -> [b_a7GD] -> [c_a7GE])
zip3' :: ExpG ([a_a7Gz] -> [b_a7GA] -> [c_a7GB] -> [(a_a7Gz, b_a7GA, c_a7GB)])
zip' :: ExpG ([a_a7Gx] -> [b_a7Gy] -> [(a_a7Gx, b_a7Gy)])
lookup' :: Eq a_a7Gv => ExpG (a_a7Gv -> [(a_a7Gv, b_a7Gw)] -> Maybe b_a7Gw)
notElem' :: Eq a_a7Gu => ExpG (a_a7Gu -> [a_a7Gu] -> Bool)
elem' :: Eq a_a7Gr => ExpG (a_a7Gr -> [a_a7Gr] -> Bool)
break' :: ExpG ((a_a7Gq -> Bool) -> [a_a7Gq] -> ([a_a7Gq], [a_a7Gq]))
span' :: ExpG ((a_a7Gp -> Bool) -> [a_a7Gp] -> ([a_a7Gp], [a_a7Gp]))
dropWhile' :: ExpG ((a_a7Go -> Bool) -> [a_a7Go] -> [a_a7Go])
takeWhile' :: ExpG ((a_a7Gn -> Bool) -> [a_a7Gn] -> [a_a7Gn])
splitAt' :: ExpG (Int -> [a_a7Gm] -> ([a_a7Gm], [a_a7Gm]))
drop' :: ExpG (Int -> [a_a7Gl] -> [a_a7Gl])
take' :: ExpG (Int -> [a_a7Gk] -> [a_a7Gk])
cycle' :: ExpG ([a_a7Gj] -> [a_a7Gj])
replicate' :: ExpG (Int -> a_a7Gi -> [a_a7Gi])
repeat' :: ExpG (a_a7Gh -> [a_a7Gh])
iterate' :: ExpG ((a_a7Gg -> a_a7Gg) -> a_a7Gg -> [a_a7Gg])
scanr1' :: ExpG ((a_a7Gf -> a_a7Gf -> a_a7Gf) -> [a_a7Gf] -> [a_a7Gf])
scanl1' :: ExpG ((a_a7Ge -> a_a7Ge -> a_a7Ge) -> [a_a7Ge] -> [a_a7Ge])
scanr' :: ExpG ((a_a7Gc -> b_a7Gd -> b_a7Gd) -> b_a7Gd -> [a_a7Gc] -> [b_a7Gd])
scanl' :: ExpG ((a_a7Ga -> b_a7Gb -> a_a7Ga) -> a_a7Ga -> [b_a7Gb] -> [a_a7Ga])
minimum' :: Ord a_a7G9 => ExpG ([a_a7G9] -> a_a7G9)
maximum' :: Ord a_a7G8 => ExpG ([a_a7G8] -> a_a7G8)
concatMap' :: ExpG ((a_a7G6 -> [b_a7G7]) -> [a_a7G6] -> [b_a7G7])
concat' :: ExpG ([[a_a7cJ]] -> [a_a7cJ])
product' :: Num a_a7G5 => ExpG ([a_a7G5] -> a_a7G5)
sum' :: Num a_a7G4 => ExpG ([a_a7G4] -> a_a7G4)
all' :: ExpG ((a_a7G3 -> Bool) -> [a_a7G3] -> Bool)
any' :: ExpG ((a_a7G2 -> Bool) -> [a_a7G2] -> Bool)
or' :: ExpG ([Bool] -> Bool)
and' :: ExpG ([Bool] -> Bool)
foldr1' :: ExpG ((a_a7G1 -> a_a7G1 -> a_a7G1) -> [a_a7G1] -> a_a7G1)
foldl1' :: ExpG ((a_a4i1 -> a_a4i1 -> a_a4i1) -> [a_a4i1] -> a_a4i1)
foldr' :: ExpG ((a_a7FZ -> b_a7G0 -> b_a7G0) -> b_a7G0 -> [a_a7FZ] -> b_a7G0)
foldl' :: ExpG ((a_a7FX -> b_a7FY -> a_a7FX) -> a_a7FX -> [b_a7FY] -> a_a7FX)
reverse' :: ExpG ([a_a7FW] -> [a_a7FW])
length' :: ExpG ([a_a7FV] -> Int)
null' :: ExpG ([a_a7FU] -> Bool)
init' :: ExpG ([a_a7FT] -> [a_a7FT])
tail' :: ExpG ([a_a7FS] -> [a_a7FS])
last' :: ExpG ([a_a7FR] -> a_a7FR)
head' :: ExpG ([a_a7FQ] -> a_a7FQ)
filter' :: ExpG ((a_a7FP -> Bool) -> [a_a7FP] -> [a_a7FP])
map' :: ExpG ((a_a3Yw -> b_a3Yx) -> [a_a3Yw] -> [b_a3Yx])
undefined' :: ExpG a_a7FO
asTypeOf' :: ExpG (a_a7FN -> a_a7FN -> a_a7FN)
until' :: ExpG ((a_a7FM -> Bool) -> (a_a7FM -> a_a7FM) -> a_a7FM -> a_a7FM)
flip' :: ExpG ((a_a6I0 -> b_a6I1 -> c_a6I2) -> b_a6I1 -> a_a6I0 -> c_a6I2)
const' :: ExpG (a_a7FK -> b_a7FL -> a_a7FK)
id' :: ExpG (a_a4tj -> a_a4tj)
mapM_' :: Monad m_a7FI => ExpG ((a_a7FH -> m_a7FI b_a7FJ) -> [a_a7FH] -> m_a7FI ())
mapM' :: Monad m_a4lg => ExpG ((a_a4lf -> m_a4lg b_a4lh) -> [a_a4lf] -> m_a4lg [b_a4lh])
return' :: Monad m_a3LS => forall a_a4kv. ExpG (a_a4kv -> m_a3LS a_a4kv)
fmap' :: Functor f_a3LO => forall a_a3YD b_a3YE. ExpG ((a_a3YD -> b_a3YE) -> f_a3LO a_a3YD -> f_a3LO b_a3YE)
realToFrac' :: (Real a_a7FD, Fractional b_a7FE) => ExpG (a_a7FD -> b_a7FE)
fromIntegral' :: (Integral a_a7FB, Num b_a7FC) => ExpG (a_a7FB -> b_a7FC)
lcm' :: Integral a_a7FA => ExpG (a_a7FA -> a_a7FA -> a_a7FA)
gcd' :: Integral a_a7Fz => ExpG (a_a7Fz -> a_a7Fz -> a_a7Fz)
odd' :: Integral a_a7Fy => ExpG (a_a7Fy -> Bool)
even' :: Integral a_a7Fx => ExpG (a_a7Fx -> Bool)
subtract' :: Num a_a7Fw => ExpG (a_a7Fw -> a_a7Fw -> a_a7Fw)
atan2' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> a_a7Fv -> a_a7Fv)
isNegativeZero' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)
isIEEE' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)
isDenormalized' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)
isInfinite' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)
isNaN' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)
scaleFloat' :: RealFloat a_a7Fv => ExpG (Int -> a_a7Fv -> a_a7Fv)
significand' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> a_a7Fv)
exponent' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Int)
encodeFloat' :: RealFloat a_a7Fv => ExpG (Integer -> Int -> a_a7Fv)
decodeFloat' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> (Integer, Int))
floatRange' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> (Int, Int))
floatDigits' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Int)
floatRadix' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Integer)
floor' :: RealFrac a_a7Fo => forall b_a7Ft. Integral b_a7Ft => ExpG (a_a7Fo -> b_a7Ft)
ceiling' :: RealFrac a_a7Fo => forall b_a7Fs. Integral b_a7Fs => ExpG (a_a7Fo -> b_a7Fs)
round' :: RealFrac a_a7Fo => forall b_a7Fr. Integral b_a7Fr => ExpG (a_a7Fo -> b_a7Fr)
truncate' :: RealFrac a_a7Fo => forall b_a7Fq. Integral b_a7Fq => ExpG (a_a7Fo -> b_a7Fq)
properFraction' :: RealFrac a_a7Fo => forall b_a7Fp. Integral b_a7Fp => ExpG (a_a7Fo -> (b_a7Fp, a_a7Fo))
atanh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
acosh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
asinh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
tanh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
cosh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
sinh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
atan' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
acos' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
asin' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
tan' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
cos' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
sin' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
logBase' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm -> a_a7Fm)
sqrt' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
log' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
exp' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
pi' :: Floating a_a7Fm => ExpG a_a7Fm
fromRational' :: Fractional a_a7Fk => ExpG (Rational -> a_a7Fk)
recip' :: Fractional a_a7Fk => ExpG (a_a7Fk -> a_a7Fk)
toInteger' :: Integral a_a7Fi => ExpG (a_a7Fi -> Integer)
divMod' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> (a_a7Fi, a_a7Fi))
quotRem' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> (a_a7Fi, a_a7Fi))
mod' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)
div' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)
rem' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)
quot' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)
fromInteger' :: Num a_a4qV => ExpG (Integer -> a_a4qV)
signum' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV)
abs' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV)
negate' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV)
not' :: ExpG (Bool -> Bool)
uncurry' :: ExpG ((a_a7Fe -> b_a7Ff -> c_a7Fg) -> (a_a7Fe, b_a7Ff) -> c_a7Fg)
curry' :: ExpG (((a_a7Fb, b_a7Fc) -> c_a7Fd) -> a_a7Fb -> b_a7Fc -> c_a7Fd)
snd' :: ExpG ((a_a7F9, b_a7Fa) -> b_a7Fa)
fst' :: ExpG ((a_a4r0, b_a4r1) -> a_a4r0)
either' :: ExpG ((a_a7EW -> c_a7EX) -> (b_a7EY -> c_a7EX) -> Either a_a7EW b_a7EY -> c_a7EX)
maybe' :: ExpG (b_a6HN -> (a_a6HO -> b_a6HN) -> Maybe a_a6HO -> b_a6HN)
equal' :: Eq a_a7Gt => ExpG (a_a7Gt -> a_a7Gt -> Bool)
index' :: ExpG ([a_a7WG] -> Int -> a_a7WG)
append' :: ExpG ([a_a4ky] -> [a_a4ky] -> [a_a4ky])
then' :: Monad m_a3LS => forall a_a4kH b_a4kI. ExpG (m_a3LS a_a4kH -> m_a3LS b_a4kI -> m_a3LS b_a4kI)
bind' :: Monad m_a3LS => forall a_a4ke b_a4kf. ExpG (m_a3LS a_a4ke -> (a_a4ke -> m_a3LS b_a4kf) -> m_a3LS b_a4kf)
floatPow' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm -> a_a7Fm)
divide' :: Fractional a_a7Fk => ExpG (a_a7Fk -> a_a7Fk -> a_a7Fk)
mult' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV -> a_a4qV)
add' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV -> a_a4qV)
dot' :: ExpG ((b_a3YA -> c_a3YB) -> (a_a3YC -> b_a3YA) -> a_a3YC -> c_a3YB)
(<>.) :: 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 Num t => Num (ExpG t)

module Language.Haskell.Generate