MagicHaskeller.LibTH

Documentation

succOnlyForNumbers :: Bool

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

tail :: [a] -> [a]

gcd :: Integral a => a -> a -> a

enumFromThenTo :: (Enum a, Enum a1, Enum a2, Enum b) => a2 -> a1 -> a -> [b]

initialize :: IO ()

init075 :: IO ()

inittv1 :: IO ()

mall :: ProgramGenerator pg => pg

mlist :: ProgramGenerator pg => pg

mlist' :: ProgramGenerator pg => pg

mnat :: ProgramGenerator pg => pg

mlistnat :: ProgramGenerator pg => pg

mnat_nc :: ProgramGenerator pg => pg

mnatural :: ProgramGenerator pg => pg

mlistnatural :: 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]

list'' :: [Primitive]

list' :: [Primitive]

list :: [Primitive]

bool :: [Primitive]

boolean :: [Primitive]

intinst :: [Primitive]

list1 :: [Primitive]

list1' :: [Primitive]

list2 :: [Primitive]

list3 :: [Primitive]

list3' :: [Primitive]

nats :: [Primitive]

tuple :: [Primitive]

tuple' :: [Primitive]

rich :: [Primitive]

rich' :: [Primitive]

debug :: [Primitive]

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

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

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

iF :: Bool -> a -> a -> a

postprocess :: Exp -> Exp

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

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 => String -> 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

Arguments

:: (Typeable a, Filtrable a)

=> Bool

whether to include functions with unused arguments

-> (a -> Bool)

-> IO ()

newtype Partial a

Constructors

Part

Fields

undef :: a

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

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

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

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

newtype Equivalence a

Constructors

Eq

Fields

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

eq :: Eq a => Equivalence a

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

eqMaybeBy :: (t -> t1 -> Bool) -> Maybe t -> Maybe t1 -> Bool

by1_eqList :: Equivalence a -> Equivalence [a]

eqListBy :: (t -> t1 -> Bool) -> [t] -> [t1] -> Bool

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

eqEitherBy :: (t -> t2 -> Bool) -> (t1 -> t3 -> Bool) -> Either t t1 -> Either t2 t3 -> Bool

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

eqPairBy :: (t -> t2 -> Bool) -> (t1 -> t3 -> Bool) -> (t, t1) -> (t2, t3) -> 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)

newtype Ordered a

Constructors

Ord

Fields

by1_compare :: a -> a -> Ordering

cmp :: Ord a => Ordered a

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

compareMaybeBy :: (t -> t1 -> Ordering) -> Maybe t -> Maybe t1 -> Ordering

by1_cmpList :: Ordered a -> Ordered [a]

compareListBy :: (t -> t1 -> Ordering) -> [t] -> [t1] -> Ordering

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

compareEitherBy :: (t -> t2 -> Ordering) -> (t1 -> t3 -> Ordering) -> Either t t1 -> Either t2 t3 -> Ordering

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

comparePairBy :: (t -> t2 -> Ordering) -> (t1 -> t3 -> Ordering) -> (t, t1) -> (t2, t3) -> Ordering

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

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

dataListOrdRelated :: [[(HValue, Exp, Type)]]

(--#<=) :: Ordered t -> t -> t -> Bool

(--#<) :: Ordered t -> t -> t -> Bool

by1_max :: Ordered t -> t -> t -> t

by1_min :: Ordered t -> t -> t -> t

by1_sort :: Ordered t -> [t] -> [t]

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

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

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

reallyall :: ProgramGenerator pg => pg

nrnds :: Num a => [a]

generator :: StdGen

mix :: ProgramGenerator pg => pg

poormix :: ProgramGenerator pg => pg

soso :: [Primitive]

ra :: ProgramGenerator pg => pg

mx :: ProgramGenerator pg => pg

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