MagicHaskeller.LibExcel

Documentation

succOnlyForNumbers :: Bool

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

ppExcel :: Exp -> Exp

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

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

leftE :: Exp

rightE :: Exp

lenE :: Exp

absE :: Exp

mkIF :: Exp -> Exp -> Exp -> Exp

mkUncurried :: String -> [Exp] -> Exp

mkSUBST4 :: [Exp] -> Exp

mkVarOp :: Exp -> String -> Exp -> Exp

char7 :: Exp

lit0 :: Exp

lit1 :: Exp

procSucc :: Integer -> Exp -> Exp

nrnds :: Num a => [a]

mkPgExcel :: IO ProgGenSF

mkPgExcels :: Int -> IO ProgGenSF

(<>) :: Eq a => a -> a -> Bool

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

totalGCD :: Integral t => t -> t -> t

curry2 :: ((a, b) -> c) -> a -> b -> c

curry3 :: ((a, b, c) -> d) -> a -> b -> c -> d

curry4 :: ((a, b, c, d) -> e) -> a -> b -> c -> d -> e

curry5 :: ((a, b, c, d, e) -> f) -> a -> b -> c -> d -> e -> f

curry6 :: ((a, b, c, d, e, f) -> g) -> a -> b -> c -> d -> e -> f -> g

iF :: (Bool, a, a) -> a

upper :: [Char] -> [Char]

lower :: [Char] -> [Char]

proper :: [Char] -> [Char]

right :: ([b], Int) -> [b]

left :: ([b], Int) -> [b]

left1 :: [a] -> [a]

right1 :: [b] -> [b]

dropLeft :: [Char] -> Int -> [Char]

mid :: ([a], Int, Int) -> [a]

len :: Num a => String -> a

concatenate :: ([a], [a]) -> [a]

concatenatE :: ([a], [a], [a]) -> [a]

concatenaTE :: ([a], [a], [a], [a]) -> [a]

concatenATE :: ([a], [a], [a], [a], [a]) -> [a]

concateNATE :: ([a], [a], [a], [a], [a], [a]) -> [a]

cEILING :: (Double, Double) -> Double

fLOOR :: (Double, Double) -> Double

mround :: (Double, Double) -> Double

fLOOR0 :: RealFrac p => p -> p -> p

rOUND :: (Double, Int) -> Double

roundup :: (Double, Int) -> Double

rounddown :: (Double, Int) -> Double

trim :: String -> String

fIND :: Num b => (String, String, Int) -> Maybe b

ifERROR :: (Maybe a, a) -> a

aND :: (Bool, Bool) -> Bool

oR :: (Bool, Bool) -> Bool

sign :: Num a => a -> a

power :: RealFloat a => (a, a) -> Maybe a

sQRT :: (Ord a, Floating a) => a -> Maybe a

lOG :: (Ord a, Floating a) => (a, a) -> Maybe a

ln :: (Ord a, Floating a) => a -> Maybe a

pI :: Floating a => () -> a

aTAN2 :: RealFloat a => (a, a) -> a

fact :: (Ord a, Num a, Enum a) => a -> Maybe a

combin :: Integral a => (a, a) -> Maybe a

mOD :: (Int, Int) -> Maybe Int

degrees :: Double -> Double

radians :: Double -> Double

gCD :: (Integral t, RealFrac a1, RealFrac a2) => (a1, a2) -> t

findIx :: Num a => [Char] -> [Char] -> Int -> a

finD :: Num b => (String, String) -> b

char :: Int -> [Char]

sUBsTITUTE :: (String, String, String) -> String

sUBSTITUTE :: (String, String, String, Int) -> String

sUB :: (Ord a, Num a) => [Char] -> [Char] -> [Char] -> a -> [Char]

sUBST4 :: String -> String -> String -> Int -> String

countStr :: Num a => String -> String -> a

gCD'2 :: Double -> Double -> Int

mOD'2 :: Int -> Int -> Maybe Int

combin'2 :: Int -> Int -> Maybe Int

aTAN2'2 :: Double -> Double -> Double

lOG'2 :: Double -> Double -> Maybe Double

power'2 :: Double -> Double -> Maybe Double

oR'2 :: Bool -> Bool -> Bool

aND'2 :: Bool -> Bool -> Bool

ifERROR'2 :: Maybe c -> c -> c

rounddown'2 :: Double -> Int -> Double

roundup'2 :: Double -> Int -> Double

rOUND'2 :: Double -> Int -> Double

mround'2 :: Double -> Double -> Double

cEILING'2 :: Double -> Double -> Double

concatenate'2 :: [a] -> [a] -> [a]

right'2 :: [b] -> Int -> [b]

left'2 :: [b] -> Int -> [b]

concatenatE'3 :: [a] -> [a] -> [a] -> [a]

sUBsTITUTE'3 :: String -> String -> String -> String

fIND'3 :: String -> String -> Int -> Maybe Int

mid'3 :: [a] -> Int -> Int -> [a]

iF'3 :: Bool -> d -> d -> d

concatenaTE'4 :: [a] -> [a] -> [a] -> [a] -> [a]

concatenATE'5 :: [a] -> [a] -> [a] -> [a] -> [a] -> [a]

concateNATE'6 :: [a] -> [a] -> [a] -> [a] -> [a] -> [a] -> [a]