Haskell
Published: 12:58, Thursday 14 July 2011
Notes
What's this? See my article about Notes.
View as plain text file.
real world haskell:
ghc, ghci, runghc
help: :?
info: :info (+)
include/load file: :l <fname>
reload: :r
quit: :q
prompt: :set prompt "blabla"
load modules: :module + Data.Ratio
import List( nub )
arithmetic functions: + - ^ div mod abs
infix functions: operators 1 + 2
can be used prefix: (+) 1 2
prefix: mod 1 2
can be used infix: 1 `mod` 2
logic operators: True False && || == /= >=
operator precedence ?
temporary definition (in ghci): let e = exp 1
scope:
bind variables
let:
let
fn = expr
...
in
expr
function:
funcionName arg1 arg2
| guard1 = expr1
| guard2 = expr2
| otherwise = exprotherwise
with cases:
xor True False = True
xor False False = False
...
xor True x =
see type: :t fname
maxThreeOccurs n n p = (maxVal, eqCount)
where
maxVal = ...
eqCount = ...
use spaces
tuples/records
pair, triple, 4-tuple, ...
(String, Int, Int)
addPair :: (Int, Int) -> Int
addPair (x,y) = x + y
nested patterns: shift :: ((Int, Int), Int) -> (Int, (Int, Int))
first: fst (x,y;)
patterns
let (a:b:c:[]) = "xyz" in a
let (a:_) = "xyz" in a
grab and pattern match/as-pattern/as pattern:
let abc@(a,b,c) = (10, 20, 30) in (abc,a,b,c)
lists:
[1, 2, 3] []
[1..10] [2,4..10]
["a", "b", "c"]
same type
concat: [1,2,3] ++ [4,5]
prepend: 1 : [2,3]
first element: head list
drop, take
characters: 'a'
strings
"asd\n\t" ['a', 'b', 'c', '\n', '\t']
"" == []
'a':"bc" "foo" ++ "bar"
words string
unwords
see types of expr: :set +t
special variables:
result of last expr: it
rational numbers:
:m +Data.Ratio
11 % 9
comments: -- comment {- comment -}
files: .hs
common basic types: Char Bool Int Integer Double
shorthands for types/type synonyms: type Complex = (Float,Float)
map
map func list
map (+1) [1..5]
right bind:
let
double = (*) 2
doubleList = map double
in
doubleList [1,2,3]
filter half_a_bool_func list
evaluation: from outside in, left to right
upcase: toUpper
folding: foldr
higher level:
fapp f g x = f (g x)
iter 0 f x = x
iter n f x = f (iter (n-1) f x)
composition: (.)
higher order functions:
replicate :: Int -> a -> [a]
curry :: (f -> a -> b -> c) -> f -> (a, b) -> b
zip :: [a] -> [b] -> [(a,b)]
zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
infinite lists:
iterate f x: [x,f x, f (f x), ...]
repeat :: a -> [a] (infinite)
ones
from 1
types:
type Vector = [Int]
type Matrix = [Vector]
classes:
class Eq a where
(==), (/=) :: a -> a -> Bool
x /= y = not (x==y)
instance Eq Bool where
True == True = True
...
instance Eq a => Eq [a] where
[] == [] = True
(x:xs) == (y:ys) = x==y && xs=ys
_ == _ = False
class Eq a => Ord a where
(<), (>), (<=), (>=) :: a -> a -> Bool
max, min :: a -> a -> a
class (Eq a, Show a) => Num a where
(+), (-), (*) :: a -> a -> a
data (algebraic data types):
data Name = Constr Type1 Type2 | ...
data Season = Winter | Spring | Summer | Fall
data People = Person Name Age
type People' = (Name, Age)
type Name = String
type Age = Int
data Foo = D1 | D2 | D3
deriving (Eq, Ord, Enum, Show)
data Expr = Lit Int | Add Expr Expr | Sub Expr Expr
deriving (Show, Eq)
eval :: Expr -> Int
eval (Lit n) = n
eval (Add e1 e2) = (eval e1) + (eval e2)
eval (Sub e1 e2) = (eval e1) - (eval e2)
trees:
data Tree t = Leaf | Node t (Tree t) (Tree t)
deriving (Eq, Show)
treeSum :: Tree -> Int
treeSum Leaf = 0
treeSum (Node n t1 t2) = n + (treeSum t1) + (treeSum t2)
depth :: Tree -> Int
depth Leaf = 0
depth (Node n t1 t2) = 1 + max (depth t1) (depth t2)
with type variables (polymorphic functions!):
data Pair t = MkPair t t
MkPair 2 4 :: Pair Int
MkPair [] [2,3] :: Pair [Int]
MkPair [] [] :: Pair [t]
equalPair :: Eq t => Pair t -> Bool
equalPair (MkPair x y) = (x == y)
treefold:
treeFold :: (a -> b -> b -> b) -> b -> Tree a -> b
treeFold f e Leaf = e
treeFold f e (Node x l r) = f x (treeFold f e l) (treeFold f e r)
to list:
preorder t = treeFold (\x l r -> [x] ++ l ++ r) [] t
inorder t = treeFold (\x l r -> l ++ [x] ++ r) [] t
postorder t = treeFold (\x l r -> l ++ r ++ [x]) [] t
duplicates: List.nub
contains/element of: elem
superstuff:
functor:
class Functor (f a) where
fmap :: (a -> b) -> (f a) -> (f b)
instance Functor List where
fmap = mapList
foldable:
traversable:
prelude:
data Bool = False | True
(&&), (||), not, otherwise
data Maybe a = Nothing | Just a
maybe :
b -> (a -> b) -> Maybe a -> b
safeSecond :: [a] -> Maybe a
safeSecond (_:x:_) = Just x
safeSecond _ = Nothing
data Either a b = Left a | Right b
either :: (a -> c) -> (b -> c) -> Either a b -> c
data Ordering = EQ | EQ | GT
data Char
Prelude.toEnum Prelude.fromEnum
type String = [Char]
fst, snd, curry, uncurry
class Eq a where
(==), (/=)
class Eq a => Ord a where
compare, (<), (>=), (>), (<=), max, min
class Enum a where
succ, pred, toEnum, fromEnum, enumFrom,
enumFromThen, enumFromTo, enumFromThenTo
class Bounded a where
minBound, maxBound
data Int
fixed-precision integer type
data Integer
arbitrary-precision integer
data Float
data Double
type Rational = Ratio Integer
arbitrary-precision rational numbers, construct with %
class (Eq a, Show a) => Num a where
(+), (*), (-), negate, abs, signum, fromInteger
class (Num a, Ord a) => Real a where
toRational
class (Real a, Enum a) => Integral a where
quot, rem, div, mod, quotRem, divMod, toInteger
class Num a => Fractional a where
(/), recip, fromRational
class Fractional a => Floating a where
pi, exp, sqrt, log (**), logBase, sin, tan, cos, asin,
atan, acos, sinh, tanh, cosh, asinh, atanh, acosh
class (Real a, Fractional a) => RealFrac a where
properFraction, truncate, round, ceiling, floor
class (RealFrac a, Floating a) => RealFloat a where
floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat,
exponent, significand, scaleFloat, isNaN, isInfinite, isDenormailzed,
isNegativeZero, isIEEE, atan2
subtract, even, odd, gcd, lcm, (^), (^^), fromIntegral, realToFrac
class Monad m where
(>>=) :: forall a b. m a -> (a -> m b) -> m b
(>>) :: forall a b. m a -> m b -> m b
return :: a -> m a
fail :: String -> m a
required laws:
return >>= k == k a
m >>= return == m
m >>= (\x -> k x >>= h) == (m >>= k) >>= h
for monad and functors:
fmap f xs == xs >>= return . f
class Functor f where
fmap :: (a -> b) -> f a -> fb
laws:
fmap id == id
fmap (f . g) == fmap f . fmap g
mapM: equiv to sequence . map f
mapM_
sequence :: Monad m => [m a] -> m [a]
sequence_ :: Monad m => [m a] -> m ()
(=<<)
misc ops:
id, const, (.), ($), until, asTypeOf, error, undefined, seq, ($!)
switch/reverse/revert arguments: flip
list ops:
map, (++), filter, head, last, tail, init, null, length, (!!), reverse
reducing lists/folds:
foldl, foldl1, foldr, foldr1
and, or, any, all, sum, product, concat, concatMap, maximum, minimum
scans:
scanl, scanl1, scanr, scanr1
infinite lists:
iterate, repeat, replicate, cycle
sublists:
take, drop, splitAt, takeWhile, dropWhile, span, break
search:
elem, notElem, lookup
zipping:
zip, zip3, zipWith, zipWith3, unzip, unzip3
strings:
lines, words, unlines, unwords
type ShowS = String -> String
class Show a where
showsPrec, show, showList
shows, showChar, showString, showParen
convert/parser:
type ReadS a = String -> [(a, String)]
class Read a where
readsPrec, readList
reads, readParen, read, lex
io input/output:
i/o can be performed only by binding it to Main.main
data IO a
output:
putChar, putStr, putStrLn, print
input:
getChar, getLine, getContents, interact
files:
type FilePath = String
readFile :: FilePath -> IO String
writeFile
appendFile
readIO
readLn
exception handling:
type IOError = IOException
ioError, userError, catch
interact:
import System.Environment (getArgs)
interactWith function inputFile outputFile = do
input <- readFile inputFile
writeFile outputFile (function input)
main = mainWith myFunction
where mainWith function = do
args <- getArgs
case args of
[input,output] -> interactWith function input output
_ -> putStrLn "error
exactly two arguments needed"
-- replace "id" with the name of our function below
myFunction = id
data.list:
(++), head, last, tail, init, null, length
map, reverse, intersperse, intercalate, transpose, subequences, permutations
foldl, foldl', foldl1, foldl1', foldr, foldr1
concat, concatMap, and, or, any, all, sum, product, maximum, minimum
scanl, scan1, scanr, scanr1
mapAccumL, mapAccumR
iterate, repeat, replicate, cycle
unfoldr
take, drop, splitAt, takeWhile, dropWhile, span, break, stripPrefix, group
inits, tails
isPrefixOf, isSuffixOf, isInfixOf
elem, notElem, lookup
find, filter, partition
(!!), elemIndex, elemIndices, findIndex, findIndices
zip, zip3, zip4, zip5, zip6, zip7
zipWith ... 7
unzip ... 7
lines, words, unlines, unwords
set operations: nub, delete, (\\), union, intersect
order: sort, insert
nubBy, deleteBy, deleteFirstsBy, unionBy, intersectBy, groupBy
sortBy, insertBy, maximumBy, minimumBy
genericLength, genericTake, genericDrop,
genericSplitAt, genericIndex, genericReplicate
data.char:
type String = [Char]
isControl, isSpace, isLower, isUpper, isAlpha, isPrint, isDigit
isOctDigit, isHexDigit, isLetter, isMark, isNumber, isPunctuation
isSymbol, isSeparator
isAscii, isLatin1, isAsciiUpper, isAsciiLower
data GeneralCategory = UppercaseLetter | ...
generalCategory
toUpper, toLower, toTitle
digitToInt, intToDigit
ord, chr
showLitChar, lexLitChar, readLitChar
Language.Haskell.Parsere
Write a Comment
* These fields are mandatory.