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


-- | haskell-generate
--   
@package haskell-generate
@version 0.2.1

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_a7td)
true' :: ExpG Bool
false' :: ExpG Bool
right' :: ExpG (b_a9Bt -> Either a_a9Bs b_a9Bt)
left' :: ExpG (a_a9Bl -> Either a_a9Bl b_a9Bm)
just' :: ExpG (a_a7tj -> Maybe a_a7tj)
readLn' :: Read a_aeih => ExpG (IO a_aeih)
readIO' :: Read a_aeig => ExpG (String -> IO a_aeig)
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_aegG => ExpG (a_aegG -> IO ())
putStrLn' :: ExpG (String -> IO ())
putStr' :: ExpG (String -> IO ())
putChar' :: ExpG (Char -> IO ())
show' :: Show a_aagk => ExpG (a_aagk -> String)
read' :: Read a_ae54 => ExpG (String -> a_ae54)
unwords' :: ExpG ([String] -> String)
unlines' :: ExpG ([String] -> String)
words' :: ExpG (String -> [String])
lines' :: ExpG (String -> [String])
unzip3' :: ExpG ([(a_ae51, b_ae52, c_ae53)] -> ([a_ae51], [b_ae52], [c_ae53]))
unzip' :: ExpG ([(a_ae4Z, b_ae50)] -> ([a_ae4Z], [b_ae50]))
zipWith3' :: ExpG ((a_ae4V -> b_ae4W -> c_ae4X -> d_ae4Y) -> [a_ae4V] -> [b_ae4W] -> [c_ae4X] -> [d_ae4Y])
zipWith' :: ExpG ((a_ae4S -> b_ae4T -> c_ae4U) -> [a_ae4S] -> [b_ae4T] -> [c_ae4U])
zip3' :: ExpG ([a_ae4P] -> [b_ae4Q] -> [c_ae4R] -> [(a_ae4P, b_ae4Q, c_ae4R)])
zip' :: ExpG ([a_ae4N] -> [b_ae4O] -> [(a_ae4N, b_ae4O)])
lookup' :: Eq a_ae4L => ExpG (a_ae4L -> [(a_ae4L, b_ae4M)] -> Maybe b_ae4M)
notElem' :: Eq a_ae4K => ExpG (a_ae4K -> [a_ae4K] -> Bool)
elem' :: Eq a_ae4D => ExpG (a_ae4D -> [a_ae4D] -> Bool)
break' :: ExpG ((a_ae4C -> Bool) -> [a_ae4C] -> ([a_ae4C], [a_ae4C]))
span' :: ExpG ((a_ae4B -> Bool) -> [a_ae4B] -> ([a_ae4B], [a_ae4B]))
dropWhile' :: ExpG ((a_ae4A -> Bool) -> [a_ae4A] -> [a_ae4A])
takeWhile' :: ExpG ((a_ae4z -> Bool) -> [a_ae4z] -> [a_ae4z])
splitAt' :: ExpG (Int -> [a_ae4y] -> ([a_ae4y], [a_ae4y]))
drop' :: ExpG (Int -> [a_ae4x] -> [a_ae4x])
take' :: ExpG (Int -> [a_ae4w] -> [a_ae4w])
cycle' :: ExpG ([a_ae4v] -> [a_ae4v])
replicate' :: ExpG (Int -> a_ae4u -> [a_ae4u])
repeat' :: ExpG (a_ae4t -> [a_ae4t])
iterate' :: ExpG ((a_ae4s -> a_ae4s) -> a_ae4s -> [a_ae4s])
scanr1' :: ExpG ((a_ae4r -> a_ae4r -> a_ae4r) -> [a_ae4r] -> [a_ae4r])
scanl1' :: ExpG ((a_ae4q -> a_ae4q -> a_ae4q) -> [a_ae4q] -> [a_ae4q])
scanr' :: ExpG ((a_ae4o -> b_ae4p -> b_ae4p) -> b_ae4p -> [a_ae4o] -> [b_ae4p])
scanl' :: ExpG ((b_ae4m -> a_ae4n -> b_ae4m) -> b_ae4m -> [a_ae4n] -> [b_ae4m])
minimum' :: Ord a_ae4l => ExpG ([a_ae4l] -> a_ae4l)
maximum' :: Ord a_ae4k => ExpG ([a_ae4k] -> a_ae4k)
concatMap' :: ExpG ((a_ae4i -> [b_ae4j]) -> [a_ae4i] -> [b_ae4j])
concat' :: ExpG ([[a_adQi]] -> [a_adQi])
product' :: Num a_ae4h => ExpG ([a_ae4h] -> a_ae4h)
sum' :: Num a_ae4g => ExpG ([a_ae4g] -> a_ae4g)
all' :: ExpG ((a_ae4f -> Bool) -> [a_ae4f] -> Bool)
any' :: ExpG ((a_ae4e -> Bool) -> [a_ae4e] -> Bool)
or' :: ExpG ([Bool] -> Bool)
and' :: ExpG ([Bool] -> Bool)
foldr1' :: ExpG ((a_ae4d -> a_ae4d -> a_ae4d) -> [a_ae4d] -> a_ae4d)
foldl1' :: ExpG ((a_aab7 -> a_aab7 -> a_aab7) -> [a_aab7] -> a_aab7)
foldr' :: ExpG ((a_ae4b -> b_ae4c -> b_ae4c) -> b_ae4c -> [a_ae4b] -> b_ae4c)
foldl' :: ExpG ((b_ae49 -> a_ae4a -> b_ae49) -> b_ae49 -> [a_ae4a] -> b_ae49)
reverse' :: ExpG ([a_ae48] -> [a_ae48])
length' :: ExpG ([a_ae47] -> Int)
null' :: ExpG ([a_ae46] -> Bool)
init' :: ExpG ([a_ae45] -> [a_ae45])
tail' :: ExpG ([a_ae44] -> [a_ae44])
last' :: ExpG ([a_ae43] -> a_ae43)
head' :: ExpG ([a_ae42] -> a_ae42)
filter' :: ExpG ((a_ae41 -> Bool) -> [a_ae41] -> [a_ae41])
map' :: ExpG ((a_a9Ap -> b_a9Aq) -> [a_a9Ap] -> [b_a9Aq])
undefined' :: ExpG a_12
asTypeOf' :: ExpG (a_ae40 -> a_ae40 -> a_ae40)
until' :: ExpG ((a_ae3Z -> Bool) -> (a_ae3Z -> a_ae3Z) -> a_ae3Z -> a_ae3Z)
flip' :: ExpG ((a_adsg -> b_adsh -> c_adsi) -> b_adsh -> a_adsg -> c_adsi)
const' :: ExpG (a_ae3X -> b_ae3Y -> a_ae3X)
id' :: ExpG (a_aazK -> a_aazK)
mapM_' :: Monad m_ae3V => ExpG ((a_ae3U -> m_ae3V b_ae3W) -> [a_ae3U] -> m_ae3V ())
mapM' :: Monad m_aai4 => ExpG ((a_aai3 -> m_aai4 b_aai5) -> [a_aai3] -> m_aai4 [b_aai5])
return' :: Monad m_a8vl => forall a_a9qD. ExpG (a_a9qD -> m_a8vl a_a9qD)
fmap' :: Functor f_a9aQ => forall a_a9bg b_a9bh. ExpG ((a_a9bg -> b_a9bh) -> f_a9aQ a_a9bg -> f_a9aQ b_a9bh)
realToFrac' :: (Real a_ae3L, Fractional b_ae3M) => ExpG (a_ae3L -> b_ae3M)
fromIntegral' :: (Integral a_ae3J, Num b_ae3K) => ExpG (a_ae3J -> b_ae3K)
lcm' :: Integral a_ae3I => ExpG (a_ae3I -> a_ae3I -> a_ae3I)
gcd' :: Integral a_ae3H => ExpG (a_ae3H -> a_ae3H -> a_ae3H)
odd' :: Integral a_ae3G => ExpG (a_ae3G -> Bool)
even' :: Integral a_ae3F => ExpG (a_ae3F -> Bool)
subtract' :: Num a_ae3E => ExpG (a_ae3E -> a_ae3E -> a_ae3E)
atan2' :: RealFloat a_ae3l => ExpG (a_ae3l -> a_ae3l -> a_ae3l)
isNegativeZero' :: RealFloat a_ae3l => ExpG (a_ae3l -> Bool)
isIEEE' :: RealFloat a_ae3l => ExpG (a_ae3l -> Bool)
isDenormalized' :: RealFloat a_ae3l => ExpG (a_ae3l -> Bool)
isInfinite' :: RealFloat a_ae3l => ExpG (a_ae3l -> Bool)
isNaN' :: RealFloat a_ae3l => ExpG (a_ae3l -> Bool)
scaleFloat' :: RealFloat a_ae3l => ExpG (Int -> a_ae3l -> a_ae3l)
significand' :: RealFloat a_ae3l => ExpG (a_ae3l -> a_ae3l)
exponent' :: RealFloat a_ae3l => ExpG (a_ae3l -> Int)
encodeFloat' :: RealFloat a_ae3l => ExpG (Integer -> Int -> a_ae3l)
decodeFloat' :: RealFloat a_ae3l => ExpG (a_ae3l -> (Integer, Int))
floatRange' :: RealFloat a_ae3l => ExpG (a_ae3l -> (Int, Int))
floatDigits' :: RealFloat a_ae3l => ExpG (a_ae3l -> Int)
floatRadix' :: RealFloat a_ae3l => ExpG (a_ae3l -> Integer)
floor' :: RealFrac a_ae35 => forall b_ae3j. Integral b_ae3j => ExpG (a_ae35 -> b_ae3j)
ceiling' :: RealFrac a_ae35 => forall b_ae3i. Integral b_ae3i => ExpG (a_ae35 -> b_ae3i)
round' :: RealFrac a_ae35 => forall b_ae3h. Integral b_ae3h => ExpG (a_ae35 -> b_ae3h)
truncate' :: RealFrac a_ae35 => forall b_ae3g. Integral b_ae3g => ExpG (a_ae35 -> b_ae3g)
properFraction' :: RealFrac a_ae35 => forall b_ae3f. Integral b_ae3f => ExpG (a_ae35 -> (b_ae3f, a_ae35))
atanh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
acosh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
asinh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
tanh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
cosh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
sinh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
atan' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
acos' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
asin' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
tan' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
cos' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
sin' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
logBase' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I -> a_ae2I)
sqrt' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
log' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
exp' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
pi' :: Floating a_ae2I => ExpG a_ae2I
fromRational' :: Fractional a_ae2A => ExpG (Rational -> a_ae2A)
recip' :: Fractional a_ae2A => ExpG (a_ae2A -> a_ae2A)
toInteger' :: Integral a_ae2n => ExpG (a_ae2n -> Integer)
divMod' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> (a_ae2n, a_ae2n))
quotRem' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> (a_ae2n, a_ae2n))
mod' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> a_ae2n)
div' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> a_ae2n)
rem' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> a_ae2n)
quot' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> a_ae2n)
fromInteger' :: Num a_aajz => ExpG (Integer -> a_aajz)
signum' :: Num a_aajz => ExpG (a_aajz -> a_aajz)
abs' :: Num a_aajz => ExpG (a_aajz -> a_aajz)
negate' :: Num a_aajz => ExpG (a_aajz -> a_aajz)
not' :: ExpG (Bool -> Bool)
uncurry' :: ExpG ((a_ae2j -> b_ae2k -> c_ae2l) -> (a_ae2j, b_ae2k) -> c_ae2l)
curry' :: ExpG (((a_ae2g, b_ae2h) -> c_ae2i) -> a_ae2g -> b_ae2h -> c_ae2i)
snd' :: ExpG ((a_ae2e, b_ae2f) -> b_ae2f)
fst' :: ExpG ((a_aajZ, b_aak0) -> a_aajZ)
either' :: ExpG ((a_ae2b -> c_ae2c) -> (b_ae2d -> c_ae2c) -> Either a_ae2b b_ae2d -> c_ae2c)
maybe' :: ExpG (b_adrL -> (a_adrM -> b_adrL) -> Maybe a_adrM -> b_adrL)
equal' :: Eq a_ae4F => ExpG (a_ae4F -> a_ae4F -> Bool)
index' :: ExpG ([a_af3F] -> Int -> a_af3F)
append' :: ExpG ([a_aagh] -> [a_aagh] -> [a_aagh])
then' :: Monad m_a8vl => forall a_a9qx b_a9qy. ExpG (m_a8vl a_a9qx -> m_a8vl b_a9qy -> m_a8vl b_a9qy)
bind' :: Monad m_a8vl => forall a_a9qr b_a9qs. ExpG (m_a8vl a_a9qr -> (a_a9qr -> m_a8vl b_a9qs) -> m_a8vl b_a9qs)
floatPow' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I -> a_ae2I)
divide' :: Fractional a_ae2A => ExpG (a_ae2A -> a_ae2A -> a_ae2A)
mult' :: Num a_aajz => ExpG (a_aajz -> a_aajz -> a_aajz)
add' :: Num a_aajz => ExpG (a_aajz -> a_aajz -> a_aajz)
dot' :: ExpG ((b_a9AA -> c_a9AB) -> (a_a9AC -> b_a9AA) -> a_a9AC -> c_a9AB)
(<>.) :: 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