MagicHaskeller.LibExcel

Documentation

succOnlyForNumbers :: Bool

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

tail :: [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)]]

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

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 :: RealFrac a => ([b], a) -> [b]

left :: RealFrac a => ([b], a) -> [b]

left1 :: [a] -> [a]

right1 :: [b] -> [b]

dropLeft :: RealFrac a => [Char] -> a -> [Char]

mid :: (RealFrac a1, RealFrac a2) => ([a], a2, a1) -> [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 a => a -> a -> a

rOUND :: RealFrac a => (Double, a) -> Double

roundup :: RealFrac a => (Double, a) -> Double

rounddown :: RealFrac a => (Double, a) -> Double

trim :: String -> String

fIND :: (RealFrac a, Num b) => (String, String, a) -> 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 :: (Floating r, Ord r) => r -> Maybe r

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

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

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

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

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

combin :: (Enum r, Eq r, Fractional r) => (r, r) -> Maybe r

mOD :: (RealFrac a, RealFrac b, Num c) => (a, b) -> Maybe c

degrees :: Double -> Double

radians :: Double -> Double

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

findIx :: (Num a, RealFrac a1) => [Char] -> [Char] -> a1 -> a

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

char :: Int -> [Char]

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

sUBSTITUTE :: RealFrac a => (String, String, String, a) -> String

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

sUBST4 :: RealFrac a => String -> String -> String -> a -> String

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

gCD'2 :: Int -> Int -> 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]