class: center, middle
Famous code snippet is quick sort
quickSort :: Ord a => [a] -> [a]
quickSort [] = []
quickSort (x:xs) = quickSort[a | a <- xs, a < x]
++ [x]
++ quickSort [b | b <- xs, b >= x]
Type inference (Could be Hindley Milner, System F, or System Fw)
Prelude> :t (1+1)
(1+1) :: Num a => a
Prelude> :t (1+1.0)
(1+1.0) :: Fractional a => aAlgebraic data types (recursively defined types)
data List a = Nil | Cons a (List a)Parametric Type variale
data Maybe a = Just a | NothingAn evaluation strategy which delays the evaluation of an expression until its value is needed (lazy evaluation) and which also avoids repeated evaluations (sharing)
if a then b else cevaluates (a), then if and only if (a) evaluates to true does it evaluate (b), otherwise it evaluates (c). That is, either (b) or (c) will not be evaluated.
Create a file called hello.hs with the following contents:
main = putStrLn "Hello, world!"Compile your program to a native executable like this:
$ ghc --make hello
[1 of 1] Compiling Main ( hello.hs, hello.o )
Linking hello ...
$ ./hello
Hello, world!Haskell uses the = sign to declare bindings:
x = 2 -- Two hyphens introduce a comment
y = 3 -- ...that continues to end of line.
main = let z = x + y -- let introduces local bindings
in print z -- program will print 5add arg1 arg2 = arg1 + arg2 -- defines function add
five = add 2 3 -- invokes function addParentheses can wrap compound expressions, must do so for arguments
bad = print add 2 3 -- error! (print should have only 1 argument)main = print (add 2 3) -- ok, calls print with 1 argument, 5x = 5
x = 6 -- error, cannot re-bind xsafeDiv x y =
let q = div x y -- safe as q never evaluated if y == 0
in if y == 0 then 0 else q
main = print (safeDiv 1 0) -- prints 0recursive - the bound symbol is in scope within its own definition
x = 5 -- this x is not used in main
main = let x = x + 1 -- introduces new x, defined in terms of itself
in print x -- program "diverges" (i.e., loops forever)In C, we use mutable variables to create loops:
long factorial (int n)
{
long result = 1;
while (n > 1)
result *= n--;
return result;
}In Haskell, can use recursion to "re-bind" argument symbols in new scope
factorial n = if n > 1
then n * factorial (n-1)
else 1This Haskell code requires n stack frames
factorial n = if n > 1 then n * factorial (n-1) else 1factorial n multiplies by n after evaluating factorial (n-1)Idea: use accumulator argument to make calls tail recursive
factorial n = let loop acc n' = if n' > 1
then loop (acc * n') (n' - 1)
else acc
in loop 1 nloop is tail recursive, compiles to an actual loopBool - either True or FalseChar - a unicode code point (i.e., a character)Int - fixed-size integerInteger - an arbitrary-size integerDouble - an IEEE double-precision floating-point number-> type2 - a function from type1 to type2(type1, type2, ..., typeN) - a tuple() - a zero-tuple, pronounced unit (kind of like void in C); there only one value of this type, also written ()You can declare the type of a symbol or expression with ::
x :: Integer
x = (1 :: Integer) + (1 :: Integer) :: Integer:: has lower precedence than any function operators (including +)Function application happens one argument at a time (a.k.a. "currying")
add :: Integer -> (Integer -> Integer)
add arg1 arg2 = arg1 + arg2add 2 3 is equivalent to (add 2) 3(add 2) takes 3 returns 5, so (add 2) has type Integer -> Integer-> associates to the right, so parens usually omitted in multi-argument function types:fn :: argType1 -> argType2 -> ... -> argTypeN -> resultType:t*Main> :t add
add :: Integer -> Integer -> IntegerThe data keyword declares user-defined data types (like struct in C), E.g.:
data PointT = PointC Double Double deriving ShowPointT, and constructor, PointCPointT contains two Doublesderiving Show means you can print the type (helpful in GHCI)Note that data types and constructors must start with capital letters
Types and constructors can use the same name (often do), E.g.:
data Point = Point Double Double deriving ShowOne type can have multiple constructors (like a tagged union):
data Point = Cartesian Double Double
| Polar Double Double
deriving Showdata Color = Red | Green | Blue | Indigo | Violet deriving ShowConstructors act like functions producing values of their types
data Point = Point Double Double deriving Show
myPoint :: Point
myPoint = Point 1.0 1.0data Color = Red | Green | Blue | Indigo | Violet deriving Show
myColor :: Color
myColor = Redcase statements & function bindings "de-construct" values with patterns
getX, getMaxCoord :: Point -> Double
getX point = case point of
Point x y -> x
getMaxCoord (Point x y) | x > y = x
| otherwise = yisRed :: Color -> Bool
isRed Red = True -- Only matches constructor Red
isRed c = False -- Lower-case c just a variabledata Maybe a = Just a
| Nothingdata Either a b = Left a
| Right bYou can see these at work in GHCI:
Prelude> :t Just True
Just True :: Maybe Bool
Prelude> :t Left True
Left True :: Either Bool b Left True contains a type variable, b
Left True can be of type Either Bool b for any type b_" can be bound but not used
isJust :: Maybe a -> Bool -- note parametric polymorphism
isJust (Just _) = True
isJust Nothing = FalseisRed Red = True
isRed _ = False -- we don't need the non-red value_ avoids thisWe could define homogeneous lists with the data keyword
data List a = Cons a (List a) | Nil
oneTwoThree = (Cons 1 (Cons 2 (Cons 3 Nil))) :: List IntegerList Integer, the type is written [Integer]Cons, the constructor is called : and is infixNil, the empty list is called []oneTwoThree = 1:2:3:[] :: [Integer]oneTwoThree' = [1, 2, 3] -- comma-separated elements within brackets
oneTwoThree'' = [1..3] -- define list by a rangeString is just a list of Char, so ['a', 'b', 'c'] == "abc"head :: [a] -> a
head (x:_) = x
head [] = error "head: empty list"tail :: [a] -> a -- all but first element
tail (_:xs) = xs
tail [] = error "tail: empty list"a ++ b :: [a] -> [a] -> [a] -- infix operator concatenate lists
[] ++ ys = ys
(x:xs) ++ ys = x : xs ++ yslength :: [a] -> Int -- This code is from language spec
length [] = 0 -- GHC implements differently, why?
length (_:l) = 1 + length lfilter :: (a -> Bool) -> [a] -> [a]
filter pred [] = []
filter pred (x:xs)
| pred x = x : filter pred xs
| otherwise = filter pred xsNote function error :: String -> a reports assertion failures
\variable(s) -> body (where \ is pronounced "lambda")Example:
countLowercaseAndDigits :: String -> Int
countLowercaseAndDigits = length . filter (\c -> isLower c || isDigit c)