Safe Haskell	None
Language	Haskell2010

MagicHaskeller.LibTH

Synopsis

newtype Ordered a = Ord {
- by1_compare :: a -> a -> Ordering
}
newtype Equivalence a = Eq {
- (--#==) :: a -> a -> Bool
}
newtype Partial a = Part {
- undef :: a
}
succOnlyForNumbers :: Bool
last' :: a -> [a] -> a
tail :: [a] -> [a]
gcd :: Integral t => t -> t -> t
enumFromThenTo :: (Enum b, Enum a1, Enum a2, Enum a3) => a3 -> a2 -> a1 -> [b]
initialize :: IO ()
init075 :: IO ()
inittv1 :: IO ()
tuple :: [Primitive]
tuple' :: [Primitive]
mall :: ProgramGenerator pg => pg
mlist :: ProgramGenerator pg => pg
mlist' :: ProgramGenerator pg => pg
mnat :: ProgramGenerator pg => pg
mnatural :: ProgramGenerator pg => pg
mlistnat :: ProgramGenerator pg => pg
mlistnatural :: ProgramGenerator pg => pg
mnat_nc :: ProgramGenerator pg => pg
hd :: [a] -> Maybe a
mb :: [Primitive]
mb' :: [Primitive]
nat :: [Primitive]
natural :: [Primitive]
nat' :: [Primitive]
nat'woPred :: [Primitive]
natural' :: [Primitive]
plusInt :: [Primitive]
plusInteger :: [Primitive]
nat_para :: Integral i => i -> a -> (i -> a -> a) -> a
nat_cata :: Integral i => i -> a -> (a -> a) -> a
list'' :: [Primitive]
list' :: [Primitive]
list :: [Primitive]
list_para :: [b] -> a -> (b -> [b] -> a -> a) -> a
bool :: [Primitive]
iF :: Bool -> a -> a -> a
postprocess :: Exp -> Exp
byMap :: IntMap (Exp -> Exp -> Exp)
byEqs :: [(Int, Exp -> Exp -> Exp)]
byOrds :: [(Int, Exp -> Exp -> Exp)]
skip :: String -> String -> Exp -> Exp -> Exp
skipEq :: String -> Exp -> Exp -> Exp
skipOrd :: String -> Exp -> Exp -> Exp
appearsIn :: Data a => [Char] -> a -> Bool
ppLambda :: [Pat] -> Exp -> Exp
ppv :: Exp -> Exp
ppopn :: Name -> Name
ppdrop :: Integer -> Exp -> Exp
constE :: Exp
flipE :: Exp
plusE :: Exp
dropE :: Exp
reverseE :: Exp
lengthE :: Exp
sumE :: Exp
productE :: Exp
procSucc :: Integer -> Exp -> Exp
postprocessQ :: Exp -> ExpQ
exploit :: (Typeable a, Filtrable a) => Bool -> (a -> Bool) -> IO ()
boolean :: [Primitive]
undefs :: [((HValue, Exp, Type), (HValue, Exp, Type))]
by1_head :: Partial a -> [a] -> a
(--#!!) :: Partial a -> [a] -> Int -> a
prelPartial :: [(HValue, Exp, Type)]
eq :: Eq a => Equivalence a
by1_eqMaybe :: Equivalence a -> Equivalence (Maybe a)
eqMaybeBy :: (t1 -> t2 -> Bool) -> Maybe t1 -> Maybe t2 -> Bool
by1_eqList :: Equivalence a -> Equivalence [a]
eqListBy :: (t1 -> t2 -> Bool) -> [t1] -> [t2] -> Bool
by2_eqEither :: Equivalence a -> Equivalence b -> Equivalence (Either a b)
eqEitherBy :: (t1 -> t2 -> Bool) -> (t3 -> t4 -> Bool) -> Either t1 t3 -> Either t2 t4 -> Bool
by2_eqPair :: Equivalence a -> Equivalence b -> Equivalence (a, b)
eqPairBy :: (t1 -> t2 -> Bool) -> (t3 -> t4 -> Bool) -> (t1, t3) -> (t2, t4) -> Bool
eqs :: [(HValue, Exp, Type)]
prelEqRelated :: [[(HValue, Exp, Type)]]
dataListEqRelated :: [[(HValue, Exp, Type)]]
(--#/=) :: Equivalence a -> a -> a -> Bool
by1_elem :: Equivalence a -> a -> [a] -> Bool
by1_group :: Equivalence a -> [a] -> [[a]]
by1_nub :: Equivalence a -> [a] -> [a]
by1_isPrefixOf :: Equivalence a -> [a] -> [a] -> Bool
by1_isSuffixOf :: Equivalence a -> [a] -> [a] -> Bool
by1_isInfixOf :: Equivalence a -> [a] -> [a] -> Bool
by1_stripPrefix :: Equivalence a -> [a] -> [a] -> Maybe [a]
by1_lookup :: Equivalence a -> a -> (->) [(a, b)] (Maybe b)
cmp :: Ord a => Ordered a
by1_cmpMaybe :: Ordered a -> Ordered (Maybe a)
compareMaybeBy :: (t1 -> t2 -> Ordering) -> Maybe t1 -> Maybe t2 -> Ordering
by1_cmpList :: Ordered a -> Ordered [a]
compareListBy :: (t1 -> t2 -> Ordering) -> [t1] -> [t2] -> Ordering
by2_cmpEither :: Ordered a -> Ordered b -> Ordered (Either a b)
compareEitherBy :: (t1 -> t2 -> Ordering) -> (t3 -> t4 -> Ordering) -> Either t1 t3 -> Either t2 t4 -> Ordering
by2_cmpPair :: Ordered a -> Ordered b -> Ordered (a, b)
comparePairBy :: (t1 -> t2 -> Ordering) -> (t3 -> t4 -> Ordering) -> (t1, t3) -> (t2, t4) -> Ordering
ords :: [(HValue, Exp, Type)]
prelOrdRelated :: [[(HValue, Exp, Type)]]
dataListOrdRelated :: [[(HValue, Exp, Type)]]
(--#<=) :: Ordered a -> a -> a -> Bool
(--#<) :: Ordered a -> a -> a -> Bool
by1_max :: Ordered p -> p -> p -> p
by1_min :: Ordered p -> p -> p -> p
by1_sort :: Ordered a -> [a] -> [a]
intinst :: [Primitive]
intinst1 :: [(HValue, Exp, Type)]
intpartials :: [(HValue, Exp, Type)]
intinst2 :: [(HValue, Exp, Type)]
list1 :: [Primitive]
list1' :: [Primitive]
list2 :: [Primitive]
list3 :: [Primitive]
list3' :: [Primitive]
nats :: [Primitive]
reallyall :: ProgramGenerator pg => pg
nrnds :: Num a => [a]
generator :: StdGen
mix :: ProgramGenerator pg => pg
soso :: [Primitive]
rich :: [Primitive]
poormix :: ProgramGenerator pg => pg
ra :: ProgramGenerator pg => pg
rich' :: [Primitive]
mx :: ProgramGenerator pg => pg
debug :: [Primitive]
pgfull :: ProgGenSF
pgfulls :: [ProgGenSF]
mkPgFull :: IO ProgGenSF
mkPgTotal :: IO ProgGenSF
mkDebugPg :: IO ProgGenSF
deb :: [[(HValue, Exp, Type)]]
pgfullIO :: IO ProgGenSFIORef
full :: [[(HValue, Exp, Type)]]
clspartialss :: [(Primitive, Primitive)]
tupartialss :: [[(Primitive, Primitive)]]
tupartialssNormal :: [[(Primitive, Primitive)]]
literals :: [[(HValue, Exp, Type)]]
fromPrelude :: [[Primitive]]
fromDataList :: [[(HValue, Exp, Type)]]
fromDataChar :: [[(HValue, Exp, Type)]]
fromDataMaybe :: [[(HValue, Exp, Type)]]
pgWithDoubleRatio :: ProgGenSF
pgWithDoubleRatios :: [ProgGenSF]
withDoubleRatio :: [[(HValue, Exp, Type)]]
pgWithRatio :: ProgGenSF
pgWithRatios :: [ProgGenSF]
pgRatio :: ProgGenSF
pgRatios :: [ProgGenSF]
withRatio :: [[(HValue, Exp, Type)]]
ratioCls :: [(HValue, Exp, Type)]
fromPrelRatio :: [[(HValue, Exp, Type)]]
fromDataRatio :: [[(HValue, Exp, Type)]]
pgWithDouble :: ProgGenSF
pgWithDoubles :: [ProgGenSF]
mkPgWithDouble :: IO ProgGenSF
withDouble :: [[(HValue, Exp, Type)]]
doubleCls :: [(HValue, Exp, Type)]
fromPrelDouble :: [[(HValue, Exp, Type)]]
module MagicHaskeller

Documentation

newtype Ordered a Source #

Constructors

Ord
Fields by1_compare :: a -> a -> Ordering

newtype Equivalence a Source #

Constructors

Eq
Fields (--#==) :: a -> a -> Bool

newtype Partial a Source #

Constructors

Part
Fields undef :: a

succOnlyForNumbers :: Bool Source #

last' :: a -> [a] -> a Source #

tail :: [a] -> [a] Source #

gcd :: Integral t => t -> t -> t Source #

enumFromThenTo :: (Enum b, Enum a1, Enum a2, Enum a3) => a3 -> a2 -> a1 -> [b] Source #

initialize :: IO () Source #

init075 :: IO () Source #

inittv1 :: IO () Source #

tuple :: [Primitive] Source #

tuple' :: [Primitive] Source #

mall :: ProgramGenerator pg => pg Source #

mlist :: ProgramGenerator pg => pg Source #

mlist' :: ProgramGenerator pg => pg Source #

mnat :: ProgramGenerator pg => pg Source #

mnatural :: ProgramGenerator pg => pg Source #

mlistnat :: ProgramGenerator pg => pg Source #

mlistnatural :: ProgramGenerator pg => pg Source #

mnat_nc :: ProgramGenerator pg => pg Source #

hd :: [a] -> Maybe a Source #

mb :: [Primitive] Source #

mb' :: [Primitive] Source #

nat :: [Primitive] Source #

natural :: [Primitive] Source #

nat' :: [Primitive] Source #

nat'woPred :: [Primitive] Source #

natural' :: [Primitive] Source #

plusInt :: [Primitive] Source #

plusInteger :: [Primitive] Source #

nat_para :: Integral i => i -> a -> (i -> a -> a) -> a Source #

nat_cata :: Integral i => i -> a -> (a -> a) -> a Source #

list'' :: [Primitive] Source #

list' :: [Primitive] Source #

list :: [Primitive] Source #

list_para :: [b] -> a -> (b -> [b] -> a -> a) -> a Source #

bool :: [Primitive] Source #

iF :: Bool -> a -> a -> a Source #

postprocess :: Exp -> Exp Source #

postprocess replaces uncommon functions like catamorphisms with well-known functions.

byMap :: IntMap (Exp -> Exp -> Exp) Source #

byEqs :: [(Int, Exp -> Exp -> Exp)] Source #

byOrds :: [(Int, Exp -> Exp -> Exp)] Source #

skip :: String -> String -> Exp -> Exp -> Exp Source #

skipEq :: String -> Exp -> Exp -> Exp Source #

skipOrd :: String -> Exp -> Exp -> Exp Source #

appearsIn :: Data a => [Char] -> a -> Bool Source #

ppLambda :: [Pat] -> Exp -> Exp Source #

ppv :: Exp -> Exp Source #

ppopn :: Name -> Name Source #

ppdrop :: Integer -> Exp -> Exp Source #

constE :: Exp Source #

flipE :: Exp Source #

plusE :: Exp Source #

dropE :: Exp Source #

reverseE :: Exp Source #

lengthE :: Exp Source #

sumE :: Exp Source #

productE :: Exp Source #

procSucc :: Integer -> Exp -> Exp Source #

postprocessQ :: Exp -> ExpQ Source #

exploit Source #

Arguments

:: (Typeable a, Filtrable a)
=> Bool	whether to include functions with unused arguments
-> (a -> Bool)
-> IO ()

boolean :: [Primitive] Source #

undefs :: [((HValue, Exp, Type), (HValue, Exp, Type))] Source #

by1_head :: Partial a -> [a] -> a Source #

(--#!!) :: Partial a -> [a] -> Int -> a Source #

prelPartial :: [(HValue, Exp, Type)] Source #

eq :: Eq a => Equivalence a Source #

by1_eqMaybe :: Equivalence a -> Equivalence (Maybe a) Source #

eqMaybeBy :: (t1 -> t2 -> Bool) -> Maybe t1 -> Maybe t2 -> Bool Source #

by1_eqList :: Equivalence a -> Equivalence [a] Source #

eqListBy :: (t1 -> t2 -> Bool) -> [t1] -> [t2] -> Bool Source #

by2_eqEither :: Equivalence a -> Equivalence b -> Equivalence (Either a b) Source #

eqEitherBy :: (t1 -> t2 -> Bool) -> (t3 -> t4 -> Bool) -> Either t1 t3 -> Either t2 t4 -> Bool Source #

by2_eqPair :: Equivalence a -> Equivalence b -> Equivalence (a, b) Source #

eqPairBy :: (t1 -> t2 -> Bool) -> (t3 -> t4 -> Bool) -> (t1, t3) -> (t2, t4) -> Bool Source #

eqs :: [(HValue, Exp, Type)] Source #

prelEqRelated :: [[(HValue, Exp, Type)]] Source #

dataListEqRelated :: [[(HValue, Exp, Type)]] Source #

(--#/=) :: Equivalence a -> a -> a -> Bool Source #

by1_elem :: Equivalence a -> a -> [a] -> Bool Source #

by1_group :: Equivalence a -> [a] -> [[a]] Source #

by1_nub :: Equivalence a -> [a] -> [a] Source #

by1_isPrefixOf :: Equivalence a -> [a] -> [a] -> Bool Source #

by1_isSuffixOf :: Equivalence a -> [a] -> [a] -> Bool Source #

by1_isInfixOf :: Equivalence a -> [a] -> [a] -> Bool Source #

by1_stripPrefix :: Equivalence a -> [a] -> [a] -> Maybe [a] Source #

by1_lookup :: Equivalence a -> a -> (->) [(a, b)] (Maybe b) Source #

cmp :: Ord a => Ordered a Source #

by1_cmpMaybe :: Ordered a -> Ordered (Maybe a) Source #

compareMaybeBy :: (t1 -> t2 -> Ordering) -> Maybe t1 -> Maybe t2 -> Ordering Source #

by1_cmpList :: Ordered a -> Ordered [a] Source #

compareListBy :: (t1 -> t2 -> Ordering) -> [t1] -> [t2] -> Ordering Source #

by2_cmpEither :: Ordered a -> Ordered b -> Ordered (Either a b) Source #

compareEitherBy :: (t1 -> t2 -> Ordering) -> (t3 -> t4 -> Ordering) -> Either t1 t3 -> Either t2 t4 -> Ordering Source #

by2_cmpPair :: Ordered a -> Ordered b -> Ordered (a, b) Source #

comparePairBy :: (t1 -> t2 -> Ordering) -> (t3 -> t4 -> Ordering) -> (t1, t3) -> (t2, t4) -> Ordering Source #

ords :: [(HValue, Exp, Type)] Source #

prelOrdRelated :: [[(HValue, Exp, Type)]] Source #

(--#<=) :: Ordered a -> a -> a -> Bool Source #

(--#<) :: Ordered a -> a -> a -> Bool Source #

by1_max :: Ordered p -> p -> p -> p Source #

by1_min :: Ordered p -> p -> p -> p Source #

by1_sort :: Ordered a -> [a] -> [a] Source #

intinst :: [Primitive] Source #

intinst1 :: [(HValue, Exp, Type)] Source #

intpartials :: [(HValue, Exp, Type)] Source #

intinst2 :: [(HValue, Exp, Type)] Source #

list1 :: [Primitive] Source #

list1' :: [Primitive] Source #

list2 :: [Primitive] Source #

list3 :: [Primitive] Source #

list3' :: [Primitive] Source #

nats :: [Primitive] Source #

reallyall :: ProgramGenerator pg => pg Source #

nrnds :: Num a => [a] Source #

generator :: StdGen Source #

mix :: ProgramGenerator pg => pg Source #

soso :: [Primitive] Source #

rich :: [Primitive] Source #

poormix :: ProgramGenerator pg => pg Source #

ra :: ProgramGenerator pg => pg Source #

rich' :: [Primitive] Source #

mx :: ProgramGenerator pg => pg Source #

debug :: [Primitive] Source #

pgfull :: ProgGenSF Source #

Library used by the program server backend

pgfulls :: [ProgGenSF] Source #

mkPgFull :: IO ProgGenSF Source #

mkPgTotal :: IO ProgGenSF Source #

mkDebugPg :: IO ProgGenSF Source #

deb :: [[(HValue, Exp, Type)]] Source #

pgfullIO :: IO ProgGenSFIORef Source #

full :: [[(HValue, Exp, Type)]] Source #

clspartialss :: [(Primitive, Primitive)] Source #

tupartialss :: [[(Primitive, Primitive)]] Source #

tupartialssNormal :: [[(Primitive, Primitive)]] Source #

literals :: [[(HValue, Exp, Type)]] Source #

fromPrelude :: [[Primitive]] Source #

fromDataList :: [[(HValue, Exp, Type)]] Source #

fromDataChar :: [[(HValue, Exp, Type)]] Source #

fromDataMaybe :: [[(HValue, Exp, Type)]] Source #

pgWithDoubleRatio :: ProgGenSF Source #

pgWithDoubleRatios :: [ProgGenSF] Source #

withDoubleRatio :: [[(HValue, Exp, Type)]] Source #

pgWithRatio :: ProgGenSF Source #

pgWithRatios :: [ProgGenSF] Source #

pgRatio :: ProgGenSF Source #

pgRatios :: [ProgGenSF] Source #

withRatio :: [[(HValue, Exp, Type)]] Source #

ratioCls :: [(HValue, Exp, Type)] Source #

fromPrelRatio :: [[(HValue, Exp, Type)]] Source #

fromDataRatio :: [[(HValue, Exp, Type)]] Source #

pgWithDouble :: ProgGenSF Source #

pgWithDoubles :: [ProgGenSF] Source #

mkPgWithDouble :: IO ProgGenSF Source #

withDouble :: [[(HValue, Exp, Type)]] Source #

doubleCls :: [(HValue, Exp, Type)] Source #

fromPrelDouble :: [[(HValue, Exp, Type)]] Source #

module MagicHaskeller