Safe Haskell | None |
---|---|

Language | Haskell2010 |

## Synopsis

- (.) :: (b -> c) -> (a -> b) -> a -> c
- const :: a -> b -> a
- id :: a -> a
- outl :: (a, b) -> a
- outr :: (a, b) -> b
- swap :: (a, b) -> (b, a)
- assocl :: (a, (b, c)) -> ((a, b), c)
- assocr :: ((a, b), c) -> (a, (b, c))
- dupl :: (a, (b, c)) -> ((a, b), (a, c))
- dupr :: ((a, b), c) -> ((a, c), (b, c))
- pair :: (a -> b, a -> c) -> a -> (b, c)
- cross :: (a -> c, b -> d) -> (a, b) -> (c, d)
- cond :: (a -> Bool) -> (a -> b, a -> b) -> a -> b
- curry :: ((a, b) -> c) -> a -> b -> c
- uncurry :: (a -> b -> c) -> (a, b) -> c
- false :: a -> Bool
- true :: a -> Bool
- (&&) :: Bool -> Bool -> Bool
- (||) :: Bool -> Bool -> Bool
- not :: Bool -> Bool
- otherwise :: Bool
- leq :: Ord a => (a, a) -> Bool
- less :: Ord a => (a, a) -> Bool
- eql :: Ord a => (a, a) -> Bool
- neq :: Ord a => (a, a) -> Bool
- gtr :: Ord a => (a, a) -> Bool
- geq :: Ord a => (a, a) -> Bool
- meet :: (a -> Bool, a -> Bool) -> a -> Bool
- join :: (a -> Bool, a -> Bool) -> a -> Bool
- wok :: ((b, a) -> c) -> (a, b) -> c
- zero :: a -> Natural
- succ :: Natural -> Natural
- pred :: Natural -> Natural
- plus :: Num a => (a, a) -> a
- minus :: Num a => (a, a) -> a
- times :: Num a => (a, a) -> a
- divide :: Fractional a => (a, a) -> a
- negative :: (Ord a, Num a) => a -> Bool
- positive :: (Ord a, Num a) => a -> Bool
- (++) :: [a] -> [a] -> [a]
- null :: [a] -> Bool
- nil :: t -> [a]
- wrap :: a -> [a]
- cons :: (a, [a]) -> [a]
- cat :: ([a], [a]) -> [a]
- concat :: [[a]] -> [a]
- snoc :: ([a], a) -> [a]
- head :: [a] -> a
- tail :: [a] -> [a]
- split :: [a] -> (a, [a])
- last :: [a] -> a
- init :: [a] -> [a]
- inits :: [a] -> [[a]]
- tails :: [a] -> [[a]]
- splits :: [a] -> [([a], [a])]
- cpp :: ([a], [b]) -> [(a, b)]
- cpl :: ([a], b) -> [(a, b)]
- cpr :: (a, [b]) -> [(a, b)]
- cplist :: [[a]] -> [[a]]
- minlist :: ((a, a) -> Bool) -> [a] -> a
- bmin :: ((a, a) -> Bool) -> (a, a) -> a
- maxlist :: ((a, a) -> Bool) -> [a] -> a
- bmax :: ((a, a) -> Bool) -> (a, a) -> a
- thinlist :: ((a, a) -> Bool) -> [a] -> [a]
- length :: [a] -> Natural
- sum :: Num a => [a] -> a
- trans :: [[a]] -> [[a]]
- list :: (a -> b) -> [a] -> [b]
- filter :: (a -> Bool) -> [a] -> [a]
- catalist :: (b, (a, b) -> b) -> [a] -> b
- cata1list :: (a -> b, (a, b) -> b) -> [a] -> b
- cata2list :: ((a, a) -> b, (a, b) -> b) -> [a] -> b
- loop :: ((a, b) -> a) -> (a, [b]) -> a
- merge :: ((a, a) -> Bool) -> ([a], [a]) -> [a]
- zip :: ([a], [b]) -> [(a, b)]
- unzip :: [(a, b)] -> ([a], [b])
- words :: String -> [String]
- lines :: String -> [String]
- unwords :: [String] -> String
- unlines :: [String] -> String
- ord :: Char -> Int
- chr :: Int -> Char
- (==) :: Eq a => a -> a -> Bool
- (/=) :: Eq a => a -> a -> Bool
- (<=) :: Ord a => a -> a -> Bool
- (<) :: Ord a => a -> a -> Bool
- (>=) :: Ord a => a -> a -> Bool
- (>) :: Ord a => a -> a -> Bool
- (+) :: Num a => a -> a -> a
- (-) :: Num a => a -> a -> a
- (/) :: Fractional a => a -> a -> a
- div :: Integral a => a -> a -> a
- mod :: Integral a => a -> a -> a
- (*) :: Num a => a -> a -> a
- negate :: Num a => a -> a
- primPrint :: Show a => a -> IO ()
- strict :: (a -> b) -> a -> b
- error :: HasCallStack => [Char] -> a
- show :: Show a => a -> String
- flip :: (a -> b -> c) -> b -> a -> c

# Documentation

divide :: Fractional a => (a, a) -> a Source #

(/) :: Fractional a => a -> a -> a infixl 7 #

fractional division

mod :: Integral a => a -> a -> a infixl 7 #

integer modulus, satisfying

(x `div` y)*y + (x `mod` y) == x

error :: HasCallStack => [Char] -> a #

`error`

stops execution and displays an error message.