Haskell Types Flashcards
(!!)
(!!) :: [a] -> Int -> a
- [1,2,3] !! 1 = 2
- gets you the value at index
($)
($) :: (a -> b) -> a -> b
– elem 2 $ filter (> 2) [1,2,3,4]
– ([a] -> Bool) -> [a] -> Bool
($!)
($!) :: (a -> b) -> a -> b
– “call by value”, “strict evaluation”
(&&)
(&&) :: Bool -> Bool -> Bool
– 1 == 1 && True = True
(||)
(||) :: Bool -> Bool -> Bool
– 1 == 1 || False = True
(*)
(*) :: (Num a) => a -> a -> a
– 2 * 3 = 6
(**)
(**) :: (Floating a) => a -> a -> a
– 2 ** 3 = 8.0
(+)
(+) :: (Num a) => a -> a -> a
– 2 + 3 = 5
(++)
(++) :: [a] -> [a] -> [a]
– [2,3] ++ [1,4,5] = [2,3,1,4,5]
(-)
(-) :: (Num a) => a -> a -> a
– 2 - 3 = -1
(.)
(.) :: (b -> c) -> (a -> b) -> c
– (head . reverse) [1,2,3] = 3
(/)
(/) :: (Fractional a) => a -> a -> a
– 6 / 2 = 3.0
(/=)
(/=) :: (Eq a) => a -> a -> Bool
– 2 /= 2 = False
(
( a -> a -> Bool
– 2 < 3 = True
(<=)
(<=) :: (Ord a) => a -> a -> Bool
– 3 <= 3 = True
(==)
(==) :: (Eq a) => a -> a -> Bool
– 2 == 3 = False
(=
(=< (a -> m b) -> m a -> m b
(>)
(>) :: (Ord a) => a -> a -> Bool
– 2 > 3 = False
(>=)
(>=) :: (Ord a) => a -> a -> Bool
– 3 >= 3 = True
(»)
(») :: Monad m => m a -> m b -> m b
(»=)
(»=) :: Monad m => m a -> (a -> m b) -> m b
(^)
(^) :: (Num a, Integral b) => a -> b -> a
(^^)
(^^) :: (Integral b, Fractional a) => a -> b -> a
abs
abs :: (Num a) => a -> a
– abs (-42) = 42
all
all :: (a -> Bool) -> [a] -> Bool
– all even [2,4] = True
and
and :: [Bool] -> Bool
- and [True, True] = True
- and [True, True, False] = False
any
any :: Foldable t => (a -> Bool -> t a -> Bool
– any even [2,3] = True
break
break :: (a -> Bool) -> [a] -> ([a], [a])
– break even [1,3,4,8,1] = ([1,3], [4,8,1])
ceiling
ceiling :: (Integral b, RealFrac a) => a -> b
– ceiling 2.7 = 3
compare
compare :: Ord a => a -> a -> Ordering
concat
concat :: Foldable t => t [a] -> [a]
– concat [[1,2],[3]] = [1,2,3]
concatMap
concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
– concatMap ( \x -> [(x,2*x)] ) [2,3] = [(2,4),(3,6)]
curry
curry :: ((a,b) -> c) -> a -> b -> c
– curry fst 1 4 = 1
div
div :: Integral a => a -> a -> a
divMod
divMod :: Integral a => a -> a -> (a, a)
– divMod 9 2
drop
drop :: Int -> [a] -> [a]
dropWhile
dropWhile :: (a -> Bool) -> [a] -> [a]
elem
elem :: (Eq a, Foldable t) => a -> t a -> Bool
enumFrom
enumFrom :: Enum a => a -> [a]
– take 4 $ enumFrom 3 = [3,4,5,6]
enumFromThen
enumFromThen :: Enum a => a -> a -> [a]
- take 4 $ enumFromThen 3 5 = [3,5,7,9]
- figures out how many to enum by (rather than just increasing by 1)
enumFromThenTo
enumFromThenTo :: Enum a => a -> a -> a -> [a]
- enumFromThenTo 3 5 9 = [3,5,7,9]
- doesn’t need take because there’s an end
take 4 $ enumFromThen 3 5
take 4 $ enumFromThen 3 5 :: (Num a, Enum a) => [a]
– take 4 $ enumFromThen 3 5 = [3,5,7,9]
error
error :: [Char] -> a
even
even :: Integral a => a -> Bool
exp
exp :: Floating a => a -> a
filter
filter :: (a -> Bool) -> [a] -> [a]
filter (< 3)
filter (< 3) :: (Num a, Ord a) = > [a] -> [a]
flip
flip :: (a -> b -> c) -> b -> a -> c
floor
floor :: (Integral b, RealFrac a) => a -> b
fmap
fmap :: Functor f => (a -> b) -> f a -> f b
foldl
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
foldr
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
fromEnum
fromEnum :: Enum a => a -> Int
– fromEnum ‘b’ = 98
fromInteger
fromInteger :: Num a => Integer -> a
fromIntegral
fromIntegral :: (Num b, Integral a) => a -> b
fromRational
fromRational :: Fractional a => Rational -> a
fst
fst :: (a, b) -> a
gcd
gcd :: Integral a => a -> a -> a
– gcd 15 20 = 5
getLine
getLine :: IO String
> getLine
input: > hello
output: > “hello”
head
head :: [a] -> a
– head [1,2,3] = 1
id
id :: a -> a
init
init :: [a] -> a
– init [1,2,3,4,5] = [1,2,3,4]
last
last :: [a] -> a
– last [1,2,3,4,5] = 5
lcm
lcm :: Integral a => a -> a ->
- lcm x y is the smallest positive integer that both x and y divide
- lcm 5 3 = 15
length
length :: Foldable t => t a -> Int
lines
lines :: String -> [String]
- line “break me\nup” = [“break me”, “up]
- breaks up on \n
log
log :: Floating a => a -> a
logBase
logBase :: Floating a => a -> a -> a
lookup
lookup :: Eq a => a -> [(a, b)] -> Maybe b
map
map :: (a -> b) -> [a] -> [b]
max
max :: Ord a => a -> a -> a
– max ‘b’ ‘a’ = ‘b’
maxBound
maxBound :: Bounded a => a
maximum
maximum :: (Ord a, Foldable t) => t a -> a
– maximum “maximum” = ‘x’
maybe
maybe :: b -> (a -> b) -> Maybe a -> b
min
min :: Ord a => a -> a -> a
minBound
minBound :: Bounded a => a
minimum
minimum :: (Ord a, Foldable t) => t a -> a
mod
mod :: Integral a => a -> a -> a
negate
negate :: Num a => a -> a
not
not :: Bool -> Bool
notElem
notElem (Eq a, Foldable t) -> t a -> Bool
null
null :: Foldable t => t a -> Bool
– null [] = True
or
or :: Foldable t => t Bool -> Bool
otherwise
otherwise :: Bool
pi
pi :: Floating a => a
pred
pred :: Enum a => a -> a
- pred ‘b’ = ‘a’
- pred 3 = 2
print :: Show a => a -> IO ()
> print “Hello”
“Hello”
product
product :: (Num a, Foldable t) => t a -> a
putStr
putStr :: String -> IO ()
– same as putStrLn just without a \n after it
putStrLn
putStrLn :: String -> IO ()
> putStrLn “hello”
hello
– notice that it doens’t have “ “ around hello like print does
quot
quot :: Integral a => a -> a -> a
– quot 8 3 = 2
quotRem
quotRem :: Integral a => a -> a -> (a, a)
- quotRem 8 3 = (2, 2)
- quotRem 4 2 = (2, 0)
read
read :: Read a => String -> a
rem
rem :: Integral a => a -> a -> a
- rem 8 3 = 2
- rem 4 2 = 0
repeat
repeat :: a -> [a]
– take 3 $ repeat 5 = [5,5,5]
replicate
replicate :: Int -> a -> [a]
- replicate 3 5 = [5, 5, 5]
- similar to take 3 $ repeat 5, just shorter and simpler
return
return :: Monad m => a -> m a
reverse
reverse :: [a] -> [a]
round
round :: (Integral b, RealFrac a) => a -> b
- round 2.5 = 2
- round 2.399 = 2
- round (-1.2) = (-1)
- round 2.9 = 3
show
show :: Show a => a -> String
- show “hello” = “"hello"”
- show 4 = “4”
- show ‘a’ = “‘a’”
snd
snd :: (a, b) -> b
span
span :: (a -> Bool) -> [a] -> ([a], [a])
splitAt
splitAt :: Int -> [a] -> ([a], [a])
– splitAt 3 [1,2,3,4] = ([1,2,3], [4])
sqrt
sqrt :: Floating a => a -> a
subtract
subtract :: Num a => a -> a -> a
succ
succ :: Enum a => a -> a
sum
sum :: (Num a, Foldable t) => t a -> a
tail
tail :: [a] -> [a]
– tail [1,2,3] = [2,3]
take
take :: Int -> [a] -> [a]
takeWhile
takeWhile :: (a -> Bool) -> [a] -> [a]
- takeWhile (> 0) [1,2,-3,4] = [1,2]
- takeWhile (> 0) [1,-2,3,4] = [1]
– stops taking and ignores the rest of list when hits first false
toEnum
toEnum :: Enum a => Int -> a
truncate
truncate :: (Integral b, RealFrac a) => a -> b
- truncate 2.9 = 2
- truncate (-1.999) = -1
uncurry
uncurry :: (a -> b -> c) -> (a, b) -> c
– uncurry div (9,2) = 4
undefined
undefined :: a
unlines
unlines :: [String] -> String
– unlines [“ab”, “cd”] = “ab\ncd\n”
until
until :: (a -> Bool) -> (a -> a) -> a -> a
unzip
unzip :: [(a, b)] -> ([a], [b])
- unzip [(1,2,3), (4,5,6)] = error, can’t match (a,b) with (Integer, Integer, Integer)
- unzip [(1,2), (4,5)] = ([1,4], [2,5])
- unzip [(1,2), (4,5), (6,7), (0, -10)] = ([1,4,6,0], [2,5,7,-10])
unzip3
unzip3 :: [(a, b, c)] - > ([a], [b], [c])
– unzip [(1,2,3), (4,5,6), (9,8,1)] = ([1,4,9], [2,5,8], [3,6,1])
words
words :: String -> [String]
– words “some words” = [“some”, “words”]
zip
zip :: [a] -> [b] -> [(a, b)]
– zip [1,2,3] [4,5,6] = [(1,4), (2,5), (3,6)]
zip3
zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
– zip3 [1,2] [4,5] [9,8] = [(1,4,9), (2,5,8)]
zipWith
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
(\x -> x)
(\x -> x) :: t -> t
(True:True)
Error
(:[]) 3
Num a => [a]
(:[]) [1,2,3]
Num t => [[t]]
filter ((==2) . length) [[1,2,3,4,5,6],[1,2]]
Num a => [[a]]
filter (length . (==2)) [[1,2,3,4,5,6],[1,2]]
Error
Just a
Maybe [Char]
Just []
Maybe [t]
Just 2
Num a => Maybe a
Just [1,2,3]
Num t => Maybe [t]
maybe []
(a -> [t]) -> Maybe a -> [t]
maybe 3
Num b => (a -> b) -> Maybe a -> b
