Haskell Tour (Part 3)

HaskellA Whirlwind Tour

(Part III)William Taysom ~ 2011

Haskell is a non-strict, purely functional programming language with strong,static type inference.

Review

Recursive Data

data Color = Red | Green | Blue | Mix Color Color

hue :: Color -> Maybe Doublehue Red = Just 0hue Green = Just 120hue Blue = Just 240

Recursive Functions

hue (Mix c c') = case (hue c, hue c') of (Just h, Just h') -> let m = average h h' m' = norm (m + 180) d = distance h m in case compare d 90 of LT -> Just m EQ -> Nothing GT -> Just m' _ -> Nothing

Parametric Data

data (a, b) = (a, b)data Either a b = Left a | Right bdata Maybe a = Nothing | Just adata [a] = [] | a:[a]

type String = [Char]

Parametric Functions

(.) :: (b -> c) -> (a -> b) -> a -> cinfixr . -- defaults to 9(f . g) x = f (g x)

map :: (a -> b) -> [a] -> [b]map f [] = []map f (x:xs) = f x : map f xs

List Comprehensions

primitivePythagoreanTriples = [ (a, b, c) | c <- nats, b <- [1..c], a <- [1..b], a^2 + b^2 == c^2, gcd a b == 1]

primes = sieve [2..] where sieve (p:xs) = p : sieve [x | x <- xs, rem x p /= 0]

Type Classes

Membership Test

infix 4 `elem`x `elem` xs = case filter (== x) xs of [] -> False _ -> True

'q' `elem` a_z --> True'8' `elem` a_z --> False

Membership Test

elem :: a -> [a] -> Boolinfix 4 `elem`x `elem` xs = case filter (== x) xs of [] -> False _ -> True

Membership Test

(==) :: Eq a => a -> a -> Bool

Membership Test

(==) :: Eq a => a -> a -> Bool

Membership Test

elem :: Eq a => a -> [a] -> Boolinfix 4 `elem`x `elem` xs = case filter (== x) xs of [] -> False _ -> True

Membership Test

elem :: Eq a => a -> [a] -> Boolinfix 4 `elem`x `elem` xs = case filter (== x) xs of [] -> False _ -> True

Eq Instance

instance Eq Color where Red == Red = True Green == Green = True Blue == Blue = True Mix c c' == Mix d d' = c == d && c' == d' _ == _ = False

Eq Instance

instance Eq Color where Red == Red = True Green == Green = True Blue == Blue = True Mix c c' == Mix d d' = c == d && c' == d' _ == _ = False

Eq Instanceghci> :i Color

ghci> :i Colordata Color = Red | Green | Blue | Mix Color Color !-- Defined at example.hs:1:6-10instance Eq Color -- Defined at example.hs:3:10-17ghci>

ghci> :i Colordata Color = Red | Green | Blue | Mix Color Color !-- Defined at example.hs:1:6-10instance Eq Color -- Defined at example.hs:3:10-17ghci> :i Eq

Default Definitions

class Eq a where (==), (/=) :: a -> a -> Bool x /= y = not (x == y) x == y = not (x /= y)

ghci> :i Colordata Color = Red | Green | Blue | Mix Color Color !-- Defined at example.hs:1:6-10instance Eq Color -- Defined at example.hs:3:10-17ghci> :i Eqclass Eq a where (==) :: a -> a -> Bool (/=) :: a -> a -> Bool !-- Defined in GHC.Classes... followed by 26 instances ...

Default Definitions

ghci> :i Colordata Color = Red | Green | Blue | Mix Color Color !-- Defined at example.hs:1:6-10instance Eq Color -- Defined at example.hs:3:10-17ghci> :i Eqclass Eq a where (==) :: a -> a -> Bool (/=) :: a -> a -> Bool !-- Defined in GHC.Classes... followed by 26 instances ...

... some Eq instances ...instance Eq Colorinstance Eq Boolinstance Eq Char

instance Eq a => Eq [a]instance (Eq a, Eq b) => Eq (a, b)

ghci> :t compare

ghci> :t comparecompare :: Ord a => a -> a -> Orderingghci>

ghci> :t comparecompare :: Ord a => a -> a -> Orderingghci> :i Ord

instance Ord Color where Red <= _ = True Green <= Red = False Green <= _ = True Blue <= Red = False Blue <= Green = False Blue <= _ = True Mix c c' <= Mix d d' | c == d = c' <= d' | otherwise = c <= d _ <= _ = False

Ord Instanceghci> :t comparecompare :: Ord a => a -> a -> Orderingghci> :i Ordclass Eq a => Ord a where! compare :: a -> a -> Ordering! (<) :: a -> a -> Bool! (>=) :: a -> a -> Bool! (>) :: a -> a -> Bool! (<=) :: a -> a -> Bool! max :: a -> a -> a! min :: a -> a -> a -- Defined in GHC.Classes

Ord Instance

Derived Instances

data Color = Red | Green | Blue | Mix Color Color deriving (Eq, Ord, Read, Show)

Derived Instances

ghci> show (Mix Red Green)

ghci> show (Mix Red Green)"Mix Red Green"ghci>

ghci> show (Mix Red Green)"Mix Red Green"ghci> read "Mix Red Green"

ghci> show (Mix Red Green)"Mix Red Green"ghci> read "Mix Red Green"<interactive>:1:1: Ambiguous type variable `a0' in the constraint: (Read a0) arising from a use of `read' Probable fix: add a type signature that fixes these type variable(s) In the expression: read "Mix Red Green" In an equation for `it': it = read "Mix Red Green"

ghci> :t read

ghci> :t readread :: Read a => String -> aghci>

ghci> :t readread :: Read a => String -> aghci> hue (read "Mix Red Green")

ghci> :t readread :: Read a => String -> aghci> hue (read "Mix Red Green")60.0ghci>

ghci> :t readread :: Read a => String -> aghci> hue (read "Mix Red Green")60.0ghci> read "Mix Red Green"

ghci> :t readread :: Read a => String -> aghci> hue (read "Mix Red Green")60.0ghci> read "Mix Red Green" :: Color

Type Classes Comparedghci> :t readread :: Read a => String -> aghci> hue (read "Mix Red Green")60.0ghci> read "Mix Red Green" :: ColorMix Red Greenghci>

Type Classes Compared

OO Class Type Class

Instance Object Type(Not Value)

Dispatch Dynamic on Receiver

Static on Any Part(Like Overloading)

Extension Subclassing Class Conditions(No Subtypes)

Reuse Inheritance Default(No Overriding)

OO Class Type Class

intFromHexString :: String -> IntintFromHexString [] = 0intFromHexString (c:cs) = digitToInt c * 16 ^ length cs + intFromHexString cs

numberFromString :: Num a => String -> anumberFromString [] = 0numberFromString (c:cs) = fromIntegral (digitToInt c) * 10 ^ fromIntegral (length cs) + integerFromString cs

fromIntegral :: (Num b, Integral a) => a -> b

Monads

Monad Class

class Monad m where return :: a -> m a (>>=) :: m a -> (a -> m b) -> m b (>>) :: m a -> m b -> m b m >> n = m >>= \_ -> n

Maybe (Failure)

instance Monad Maybe where return = Just Nothing >>= k = Nothing Just x >>= k = k x

hue (Mix c c') = case (hue c, hue c') of (Just h, Just h') -> let m = average h h' m' = norm (m + 180) d = distance h m in case compare d 90 of LT -> Just m EQ -> Nothing GT -> Just m' _ -> Nothing

hue (Mix c c') = case (hue c, hue c') of (Just h, Just h') -> ... _ -> Nothing

hue (Mix c c') = case hue c of Just h -> case hue c' of Just h' -> ... Nothing -> Nothing Nothing -> Nothing

hue (Mix c c') = case hue c of Just h -> hue c' >>= \h' -> ... Nothing -> Nothing

hue (Mix c c') = hue c >>= \h -> hue c' >>= \h' -> ...

hue (Mix c c') = hue c >>= \h -> do h' <- hue c'; ...

hue (Mix c c') = do h <- hue c do h' <- hue c'; ...

hue (Mix c c') = do h <- hue c h' <- hue c' ...

hue (Mix c c') = do h <- hue c h' <- hue c' let m = average h h' m' = norm (m + 180) d = distance h m in case compare d 90 of LT -> Just m EQ -> Nothing GT -> Just m'

hue (Mix c c') = do h <- hue c h' <- hue c' let m = average h h' m' = norm (m + 180) d = distance h m case compare d 90 of LT -> Just m EQ -> Nothing GT -> Just m'

instance Monad [] where return x = [x] xs >>= k = concat (map k xs)

List (Nondeterminism)

[ (a, b, c) | c <- nats, b <- [1..c], a <- [1..b]]

do c <- nats b <- [1..c] a <- [1..b] return (a, b, c)

(<$>) :: Monad m => (a -> b) -> m a -> m bf <$> m = m >>= return . f

ord <$> "abc" --> [97, 98, 99]

Generalized Map

Constant Map

(<$) :: Monad m => a -> m b -> m a(<$) = (<$>) . const

'x' <$ "abc" --> "xxx"

[ (a, b, c) | c <- nats, b <- [1..c], a <- [1..b]]

do c <- nats b <- [1..c] a <- [1..b] return (a, b, c)

[ (a, b, c) | c <- nats, b <- [1..c], a <- [1..b], a^2 + b^2 == c^2]

do c <- nats b <- [1..c] a <- [1..b] guard $ a^2 + b^2 == c^2 return (a, b, c)

class Monad m => MonadPlus m where mzero :: m a mplus :: m a -> m a -> m a

MonadPlus Class

instance MonadPlus [] where mzero = [] mplus = (++)

List (Nondeterminism)

guard :: MonadPlus m => Bool -> m ()guard True = return ()guard False = mzero

Getter

data Getter a = Getter (String -> (a, String))

get :: Getter a -> String -> (a, String)get (Getter g) = g

Getter

instance Monad Getter where return x = Getter $ \s -> (x, s) g >>= k = Getter $ \s -> let (x, s') = get g s in get (k x) s'

Primitive Action

getChar :: Getter ChargetChar = Getter $ \s -> case s of c:cs -> (c , cs) "" -> ('\0', "")

Derived Action

getLine :: Getter StringgetLine = do c <- getChar if c == '\n' || c == '\0' then return "" else do s <- getLine return $ c:s

get getLine "hello\nworld" --> ("hello", "world")

data IO a = IO (RealWorld -> (a, RealWorld))

putChar :: Char -> IO ()

Print Functions

putStr :: String -> IO ()putStr "" = return ()putStr (c:cs) = do putChar c putStr cs

Print Functions

putStrLn :: String -> IO ()putStrLn s = do putStr s putChar '\n'

Main Point

“The business of the program is to construct one gianormous action which is then performed.”

— Simon Peyton-Jones

hello.hs

main = putStrLn "hello, world"

Parsers

data Parser a = Parser (String -> [(a, String)])

parse :: Parser a -> String -> [(a, String)]parse (Parser p) = p

Parsers

instance Monad Parser where return x = Parser $ \s -> [(x, s)] p >>= k = Parser $ \s -> concat [parse (k x) s' | (x, s') <- parse p s]

Parsers

instance MonadPlus Parser where mzero = Parser $ \s -> [] mplus p q = Parser $ \s -> parse p s ++ parse q s

Parsers

instance MonadPlus Parser where mzero = Parser $ \s -> [] mplus p q = Parser $ \s -> parse p s ++ parse q s

(<|>) :: Parser a -> Parser a -> Parser ainfixr 1 <|>(<|>) = mplus

Primitive Actions

anyChar :: Parser CharanyChar = Parser $ \s -> case s of c:cs -> [(c, cs)] "" -> []

eof :: Parser ()eof = Parser $ \s -> case s of c:cs -> [] "" -> [((), "")]

Derived Actions

satisfy :: (Char -> Bool) -> Parser Charsatisfy f = do c <- anyChar if f c then return c else mzero

Derived Actions

char :: Char -> Parser Charchar c = satisfy (== c)

Derived Actions

string :: String -> Parser Stringstring "" = return ""string s@(c:cs) = do char c string cs return s

Backtracking

hiHeHello = string "hi" <|> string "he" <|> string "hello"

Backtracking

parse hiHeHello "hello" --> [("he","llo"), ("hello","")]

Parsec

type Parser = Parsec String ()

Parsec

type Parser = Parsec String ()

parseTest hiHeHello "hello" >>-> unexpected "e" expecting "hi"

Optional Backtracking

try :: Parser a -> Parser a

hiHeHello' = try (string "hi") <|> string "he" <|> string "hello"

parseTest hiHeHello' "hello" >>-> "he"

Error Messages

(<?>) :: Parser a -> String -> Parser a

Error Messages

(<?>) :: Parser a -> String -> Parser a

space :: Parser Charspace = satisfy isSpace <?> "space"

digit :: Parser Chardigit = satisfy isDigit <?> "digit"

hexDigit :: Parser CharhexDigit = satisfy isHexDigit <?> "hexadecimal digit"

Error Messages

parseTest (space <|> digit <|> hexDigit) "hello" >>-> unexpected "h" expecting space, digit or hexadecimal digit

Parser Combinators

oneOf :: String -> Parser Char

-- ExampleeE = oneOf "eE"

Parser Combinators

noneOf :: String -> Parser Char

-- ExamplenotDoubleQuote = noneOf "\""

Parser Combinators

between :: Parser a -> Parser b -> Parser c -> Parser c

-- Definitionbetween open close p = do open x <- p close return x

Parser Combinators

option :: a -> Parser a -> Parser a

-- Definitionoption x p = p <|> return x

Parser Combinators

count :: Int -> Parser a -> Parser [a]

-- ExamplehexDigit4 = count 4 hexDigit

Parser Combinators

many, many1 :: Parser a -> Parser [a]

-- Exampledigits = many1 digit

Parser Combinators

skipMany :: Parser a -> Parser ()

-- ExampleskipMany p = many p >> return ()

Parser Combinators

spaces :: Parser ()

-- Definitionspaces = skipMany space

Parser Combinators

sepBy :: Parser a -> Parser b -> Parser [a]

-- Examplewords = (many1 . satisfy) (not . isSpace) `sepBy` spaces

Space Management

justOne :: Parser a -> Parser ajustOne = between spaces (spaces >> eof)

Space Management

char_sp :: Char -> Parser ()char_sp c = do char c spaces

sp_char_sp :: Char -> Parser ()sp_char_sp c = do spaces char_sp c

Space Management

commaGroup :: Char -> Parser a -> Char -> Parser [a]

commaGroup open item close = between (char_sp open) (sp_char_sp close) $ item `sepBy` sp_char_sp ','

Parse String

jsstring :: Parser Stringjsstring = between doubleQuote doubleQuote $ many character

Parse String

doubleQuote :: Parser ChardoubleQuote = char '"'

Parse String

doubleQuote :: Parser ChardoubleQuote = char '"'

character :: Parser Charcharacter = (char '\\' >> escapeChar) <|> notDoubleQuote

unicode :: Parser Charunicode = do char 'u' digits <- hexDigit4 let n = intFromHexString digits return $ chr n

Parse Number

number :: Parser Doublenumber = do s <- sign n <- int f <- frac e <- expon return $ s * (n + f) * e

sign :: Parser Doublesign = option 1 $ (-1) <$ char '-'

int :: Parser Doubleint = 0 <$ char '0' <|> numberFromString <$> digits

frac :: Parser Doublefrac = option 0 $ do char '.' n <- digits return $ numberFromString n / 10 ^^ length n

expon :: Parser Doubleexpon = option 1 $ do eE s <- sign n <- digits return $ s * 10 ** numberFromString n

Parse JSON

data Value = String String | Number Double | Object [(String, Value)] | Array [Value] | Bool Bool

| Null

Parse JSON

value = String <$> jsstring <|> Number <$> number <|> Object <$> commaGroup '{' pair '}' <|> Array <$> commaGroup '[' value ']' <|> Bool True <$ string "true" <|> Bool False <$ string "false" <|> Null <$ string "null"

Parse JSON

data Value = String String | Number Double | Object [(String, Value)] | Array [Value] | Bool Bool

| Null

Parse JSON

value = String <$> jsstring <|> Number <$> number <|> Object <$> commaGroup '{' pair '}' <|> Array <$> commaGroup '[' value ']' <|> Bool True <$ string "true" <|> Bool False <$ string "false" <|> Null <$ string "null"

Parse JSON

pair :: Parser (String, Value)pair = do s <- jsstring sp_char_sp ':' v <- value spaces return (s, v)

parseJSON :: String -> ValueparseJSON s = case parse (justOne value) "" s of Left err -> error $ "JSON parse error " ++ show err Right v -> v

parseJSON "{\"just\": [\"some\", 4, \"\\u24E4\"]}" --> Object [("just", Array [String "some", Number 4.0, String "\9444"])]

parseJSON "{\"just\": [\"some\", 4 \"\\u24E4\"]}" >>-> *** Exception: JSON parse error (line 1, column 21): unexpected "\"" expecting space or ","

Summary

Parsers

Monads

Type Classes

Parametric Types

Functions and Data Types

Summary

Parsers

Monads

Type Classes

Parametric Types

Summary

Parsers

Monads

Type Classes

Parametric Types

Summary

Parsers

Monads

Type Classes

Parametric Types

Summary

Parsers

Monads

Type Classes

Parametric Types

Haskell is a non-strict, purely functional programming language with strong,static type inference.

Thank You

Haskell Tour (Part 3)

Technology

Transcript of Haskell Tour (Part 3)

Functional Programming in Haskell Part I : Basicsmadhavan/presentations/mcc-haskell/lecture… · Functional programming Program , set of function deﬁnitions Function deﬁnition

Part 2Eb on Tour

0 REVIEW OF HASKELL A lightening tour in 45 minutes.

Haskell Tour (Part 2)

xmonad - A Haskell Success Story · xmonad Haskell xmonad + Haskell = ~ Conclusion xmonad A Haskell Success Story Brent Yorgey March 22, 2008 FringeDC Brent Yorgey xmonad

Typing Haskell in Haskell - web.cecs.pdx.eduweb.cecs.pdx.edu/~mpj/thih/thih.pdf · Typing Haskell in Haskell ... This paper presents a formal description of the Haskell type system

Neil Leslie Outline Haskell Ipds4.egloos.com/pds/200707/03/69/haskell1.pdf · 3 Writing Haskell Programs Scripts 4 Mastering Haskell Programming 5 Summary Neil Leslie Haskell I. Haskell

Bloodborne Pathogens Standard 29 CFR Part 1910.1030 Presented by: Bailey Haskell & LaLonde, Inc.

10 Haskell Part 2 - University of Texas at Austincannata/cs345/Class Notes/10 Haskell Part 2.pdfDr. Philip Cannata 2 A programming language is a language with a well-defined syntax

Just Enough Category Theory for Haskell, part 1

Parallel and Concurrent Haskell Part I Simon Marlow (Microsoft Research, Cambridge, UK)

Haskell Vineyards - Helderberg Mountain Range, Stellenbosch...HASKELL ANVIL LONGTABLE AT HASKELL VINEYARDS BREAKFAST WITH A VIEW Wednesday to Sunday - From R 85.00 pp NE HASKELL VINEYARDS

The Creative Couple behind the Haskell Collection Part 2

Haskell - CS Homecs331/group2/Haskell.pdfTimeline Timeline 1987 FPCA meeting in Portland, Oregon Named for Haskell Curry 1990 Haskell 1.0 Specification Released 1997 Haskell 98 Specification

Part Four - City Tour

Part Three - City Tour

Parallel and Concurrent Haskell Part I

Part Six - City Tour

Typing Haskell in Haskell∗

Gentle Introduction to Haskell 98 Online Supplementwiki.haskell.org/wikiupload/5/5d/A_gentle_introduction_to_Haskell98... · Gentle Introduction to Haskell 98, Online Supplement Part