Haskell is a non-strict, purely functional programming language with strong static type inference. It supports recursive data types like Color, recursive functions on those types, parametric polymorphism with types like lists and Maybe, type classes for concepts like equality and ordering, and default definitions for type class methods. Type classes provide ad-hoc polymorphism and are more static than object-oriented classes.

1. Haskell
A Whirlwind Tour
(Part III)
William Taysom ~ 2011

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

4. Review

5. Recursive Data
data Color = Red | Green | Blue
| Mix Color Color

6. Recursive Functions
hue :: Color -> Maybe Double
hue Red = Just 0
hue Green = Just 120
hue Blue = Just 240

7. 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

8. Parametric Data
data (a, b) = (a, b)
data Either a b = Left a | Right b
data Maybe a = Nothing | Just a
data [a] = [] | a:[a]
type String = [Char]

9. Parametric Functions
(.) :: (b -> c) -> (a -> b) -> a -> c
infixr . -- 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

10. 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]

11. Type Classes

12. 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

13. Membership Test
elem :: a -> [a] -> Bool
infix 4 `elem`
x `elem` xs = case filter (== x) xs of
[] -> False
_ -> True
'q' `elem` a_z --> True
'8' `elem` a_z --> False

14. Membership Test
elem :: a -> [a] -> Bool
infix 4 `elem`
x `elem` xs = case filter (== x) xs of
[] -> False
_ -> True
'q' `elem` a_z --> True
'8' `elem` a_z --> False

15. Membership Test
elem :: a -> [a] -> Bool
infix 4 `elem`
x `elem` xs = case filter (== x) xs of
[] -> False
_ -> True
'q' `elem` a_z --> True
'8' `elem` a_z --> False

16. Membership Test
elem :: a -> [a] -> Bool
infix 4 `elem`
x `elem` xs = case filter (== x) xs of
[] -> False
_ -> True
'q' `elem` a_z --> True
'8' `elem` a_z --> False

17. Membership Test
elem :: a -> [a] -> Bool
infix 4 `elem`
x `elem` xs = case filter (== x) xs of
[] -> False
(==) :: Eq a => a -> a -> Bool
_ -> True
'q' `elem` a_z --> True
'8' `elem` a_z --> False

18. Membership Test
elem :: a -> [a] -> Bool
infix 4 `elem`
x `elem` xs = case filter (== x) xs of
[] -> False
(==) :: Eq a => a -> a -> Bool
_ -> True
'q' `elem` a_z --> True
'8' `elem` a_z --> False

19. Membership Test
elem :: a -> [a] -> Bool
infix 4 `elem`
x `elem` xs = case filter (== x) xs of
[] -> False
_ -> True
'q' `elem` a_z --> True
'8' `elem` a_z --> False

20. Membership Test
elem :: Eq a => a -> [a] -> Bool
infix 4 `elem`
x `elem` xs = case filter (== x) xs of
[] -> False
_ -> True
'q' `elem` a_z --> True
'8' `elem` a_z --> False

21. Membership Test
elem :: Eq a => a -> [a] -> Bool
infix 4 `elem`
x `elem` xs = case filter (== x) xs of
[] -> False
_ -> True
'q' `elem` a_z --> True
'8' `elem` a_z --> False

22. 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

23. 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

24. Eq Instance
ghci> :i Color
instance Eq Color where
Red == Red = True
Green == Green = True
Blue == Blue = True
Mix c c' == Mix d d' = c == d && c' == d'
_ == _ = False

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

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

27. Default Definitions
ghci> :i Color
data Color = Red | Green | Blue | Mix
Color Color
! Eq a where example.hs:1:6-10
-- Defined at
class
instance Eq Color -- Defined at
(==), (/=) :: a -> a -> Bool
example.hs:3:10-17
ghci> :i=Eq (x == y)
x /= y not
class Eq=anot (x /= y)
x == y where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
! Defined in GHC.Classes
--
... followed by 26 instances ...

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

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

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

31. Default Definitions
ghci> :i Color
data Color = Red | Green | Blue | Mix
Color Color
! Eq a where example.hs:1:6-10
-- Defined at
class
instance Eq Color -- Defined at
(==), (/=) :: a -> a -> Bool
example.hs:3:10-17
ghci> :i=Eq (x == y)
x /= y not
class Eq=anot (x /= y)
x == y where
(==) :: a -> a -> Bool
(/=) :: a -> a -> Bool
! Defined in GHC.Classes
--
... followed by 26 instances ...

32. ... some Eq instances ...
instance Eq Color
instance Eq Bool
instance Eq Char

33. ... some Eq instances ...
instance Eq Color
instance Eq Bool
instance Eq Char
instance Eq a => Eq [a]
instance (Eq a, Eq b) => Eq (a, b)

34. ghci> :t compare

35. ghci> :t compare
compare :: Ord a => a -> a -> Ordering
ghci>

36. ghci> :t compare
compare :: Ord a => a -> a -> Ordering
ghci> :i Ord

37. Ord Instance
ghci> :t compare
compare :: Ord a => a -> a -> Ordering
ghci> :i Ord
class Eq a Color where
instance Ord => Ord a where
! Red
compare :: a -> a -> Ordering
<= _ = True
! Green::<= -> a -> = False
(<) a Red Bool
! Green :: a_-> a -> Bool
(>=) <= = True
! Blue ::<= -> a -> = False
(>) a Red Bool
! Blue :: aGreen -> Bool
(<=) <= -> a = False
Blue <= _ = True
! max :: a -> a -> a
Mix c c' <= Mix d d'
! min :: a -> a -> a
| c == d = c' <= d'
-- Defined in GHC.Classes
| otherwise = c <= d
_ <= _ = False

38. Ord Instance
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

39. Ord Instance
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

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

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

42. Derived Instances
ghci> show (Mix Red Green)
data Color = Red | Green | Blue
| Mix Color Color
deriving (Eq, Ord, Read, Show)

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

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

45. 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"

46. 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"

47. 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"

49. ghci> :t read

50. ghci> :t read
read :: Read a => String -> a
ghci>

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

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

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

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

55. Type Classes Compared
ghci> :t read
read :: Read a => String -> a
ghci> hue (read "Mix Red Green")
60.0
ghci> read "Mix Red Green" :: Color
Mix Red Green
ghci>

56. Type Classes Compared

57. Type Classes Compared

58. Type Classes Compared
OO Class Type Class
Type
Instance Object
(Not Value)
Dynamic Static on Any Part
Dispatch
on Receiver (Like Overloading)
Class Conditions
Extension Subclassing
(No Subtypes)
Default
Reuse Inheritance
(No Overriding)

59. Type Classes Compared
OO Class Type Class
Type
Instance Object
(Not Value)
Dynamic Static on Any Part
Dispatch
on Receiver (Like Overloading)
Class Conditions
Extension Subclassing
(No Subtypes)
Default
Reuse Inheritance
(No Overriding)

60. Type Classes Compared
OO Class Type Class
Type
Instance Object
(Not Value)
Dynamic Static on Any Part
Dispatch
on Receiver (Like Overloading)
Class Conditions
Extension Subclassing
(No Subtypes)
Default
Reuse Inheritance
(No Overriding)

61. Type Classes Compared
OO Class Type Class
Type
Instance Object
(Not Value)
Dynamic Static on Any Part
Dispatch
on Receiver (Like Overloading)
Class Conditions
Extension Subclassing
(No Subtypes)
Default
Reuse Inheritance
(No Overriding)

62. Type Classes Compared
OO Class Type Class
Type
Instance Object
(Not Value)
Dynamic Static on Any Part
Dispatch
on Receiver (Like Overloading)
Class Conditions
Extension Subclassing
(No Subtypes)
Default
Reuse Inheritance
(No Overriding)

63. Type Classes Compared
OO Class Type Class
Type
Instance Object
(Not Value)
Dynamic Static on Any Part
Dispatch
on Receiver (Like Overloading)
Class Conditions
Extension Subclassing
(No Subtypes)
Default
Reuse Inheritance
(No Overriding)

64. Type Classes Compared
OO Class Type Class
Type
Instance Object
(Not Value)
Dynamic Static on Any Part
Dispatch
on Receiver (Like Overloading)
Class Conditions
Extension Subclassing
(No Subtypes)
Default
Reuse Inheritance
(No Overriding)

65. Type Classes Compared
OO Class Type Class
Type
Instance Object
(Not Value)
Dynamic Static on Any Part
Dispatch
on Receiver (Like Overloading)
Class Conditions
Extension Subclassing
(No Subtypes)
Default
Reuse Inheritance
(No Overriding)

66. Type Classes Compared
OO Class Type Class
Type
Instance Object
(Not Value)
Dynamic Static on Any Part
Dispatch
on Receiver (Like Overloading)
Class Conditions
Extension Subclassing
(No Subtypes)
Default
Reuse Inheritance
(No Overriding)

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

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

72. numberFromString :: Num a => String -> a
numberFromString [] = 0
numberFromString (c:cs) =
fromIntegral (digitToInt c) *
10 ^ fromIntegral (length cs) +
integerFromString cs
fromIntegral ::
(Num b, Integral a) => a -> b

75. Monads

76. 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

77. Maybe (Failure)
instance Monad Maybe where
return = Just
Nothing >>= k = Nothing
Just x >>= k = k x

78. 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

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

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

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

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

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

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

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

86. 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'

87. 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'

88. List (Nondeterminism)
instance Monad [] where
return x = [x]
xs >>= k = concat (map k xs)

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

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

91. Generalized Map
(<$>) :: Monad m => (a -> b) -> m a -> m b
f <$> m = m >>= return . f
ord <$> "abc" --> [97, 98, 99]

92. Constant Map
(<$) :: Monad m => a -> m b -> m a
(<$) = (<$>) . const
'x' <$ "abc" --> "xxx"

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

94. [ (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)

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

96. List (Nondeterminism)
instance MonadPlus [] where
mzero = []
mplus = (++)

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

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

99. 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'

100. Primitive Action
getChar :: Getter Char
getChar = Getter $ s -> case s of
c:cs -> (c , cs)
"" -> ('0', "")

101. Derived Action
getLine :: Getter String
getLine = do
c <- getChar
if c == 'n' || c == '0'
then return ""
else do
s <- getLine
return $ c:s
get getLine "hellonworld" --> ("hello", "world")

102. IO
data IO a = IO (RealWorld -> (a, RealWorld))
putChar :: Char -> IO ()

103. Print Functions
putStr :: String -> IO ()
putStr "" = return ()
putStr (c:cs) = do
putChar c
putStr cs

104. Print Functions
putStrLn :: String -> IO ()
putStrLn s = do
putStr s
putChar 'n'

105. Main Point
“The business of the program is to construct one
gianormous action which is then performed.”
— Simon Peyton-Jones

106. hello.hs
main = putStrLn "hello, world"

107. Parsers

108. Parsers

109. Parsers
data Parser a = Parser (String -> [(a, String)])
parse :: Parser a -> String -> [(a, String)]
parse (Parser p) = p

110. 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]

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

112. Parsers
instance MonadPlus Parser where
mzero = Parser $ s -> []
mplus p q = Parser $ s ->
parse p s ++ parse q s
(<|>) :: Parser a -> Parser a -> Parser a
infixr 1 <|>
(<|>) = mplus

113. Primitive Actions
anyChar :: Parser Char
anyChar = Parser $ s -> case s of
c:cs -> [(c, cs)]
"" -> []
eof :: Parser ()
eof = Parser $ s -> case s of
c:cs -> []
"" -> [((), "")]

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

115. Derived Actions
char :: Char -> Parser Char
char c = satisfy (== c)

116. Derived Actions
string :: String -> Parser String
string "" = return ""
string s@(c:cs) = do
char c
string cs
return s

117. Backtracking
hiHeHello =
string "hi" <|> string "he" <|> string "hello"

118. Backtracking
hiHeHello =
string "hi" <|> string "he" <|> string "hello"
parse hiHeHello "hello" -->
[("he","llo"), ("hello","")]

119. Parsec
type Parser = Parsec String ()

120. Parsec
type Parser = Parsec String ()
hiHeHello =
string "hi" <|> string "he" <|> string "hello"
parseTest hiHeHello "hello" >>->
unexpected "e"
expecting "hi"

121. Optional Backtracking
try :: Parser a -> Parser a

122. Optional Backtracking
try :: Parser a -> Parser a
hiHeHello' =
try (string "hi") <|> string "he" <|> string "hello"

123. Optional Backtracking
try :: Parser a -> Parser a
hiHeHello' =
try (string "hi") <|> string "he" <|> string "hello"
parseTest hiHeHello' "hello" >>->
"he"

124. Error Messages
(<?>) :: Parser a -> String -> Parser a

125. Error Messages
(<?>) :: Parser a -> String -> Parser a
space :: Parser Char
space = satisfy isSpace <?> "space"
digit :: Parser Char
digit = satisfy isDigit <?> "digit"
hexDigit :: Parser Char
hexDigit = satisfy isHexDigit <?> "hexadecimal digit"

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

127. Parser Combinators
oneOf :: String -> Parser Char
-- Example
eE = oneOf "eE"

128. Parser Combinators
noneOf :: String -> Parser Char
-- Example
notDoubleQuote = noneOf """

129. Parser Combinators
between ::
Parser a -> Parser b -> Parser c -> Parser c
-- Definition
between open close p = do
open
x <- p
close
return x

130. Parser Combinators
option :: a -> Parser a -> Parser a
-- Definition
option x p = p <|> return x

131. Parser Combinators
count :: Int -> Parser a -> Parser [a]
-- Example
hexDigit4 = count 4 hexDigit

132. Parser Combinators
many, many1 :: Parser a -> Parser [a]
-- Example
digits = many1 digit

133. Parser Combinators
skipMany :: Parser a -> Parser ()
-- Example
skipMany p = many p >> return ()

134. Parser Combinators
spaces :: Parser ()
-- Definition
spaces = skipMany space

135. Parser Combinators
sepBy :: Parser a -> Parser b -> Parser [a]
-- Example
words =
(many1 . satisfy) (not . isSpace) `sepBy` spaces

136. Space Management
justOne :: Parser a -> Parser a
justOne = between spaces (spaces >> eof)

137. 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

138. 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 ','

139. Parse String

140. Parse String
jsstring :: Parser String
jsstring = between doubleQuote doubleQuote $
many character

141. Parse String
jsstring :: Parser String
jsstring = between doubleQuote doubleQuote $
many character
doubleQuote :: Parser Char
doubleQuote = char '"'

142. Parse String
jsstring :: Parser String
jsstring = between doubleQuote doubleQuote $
many character
doubleQuote :: Parser Char
doubleQuote = char '"'
character :: Parser Char
character = (char '' >> escapeChar)
<|> notDoubleQuote

143. escapeChar :: Parser Char
escapeChar = char '"'
<|> char ''
<|> char '/'
<|> 'b' <$ char 'b'
<|> 'f' <$ char 'f'
<|> 'n' <$ char 'n'
<|> 'r' <$ char 'r'
<|> 't' <$ char 't'
<|> unicode

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

145. Parse Number

146. Parse Number
number :: Parser Double
number = do
s <- sign
n <- int
f <- frac
e <- expon
return $ s * (n + f) * e

147. sign :: Parser Double
sign = option 1 $ (-1) <$ char '-'
int :: Parser Double
int = 0 <$ char '0'
<|> numberFromString <$> digits

148. frac :: Parser Double
frac = option 0 $ do
char '.'
n <- digits
return $ numberFromString n / 10 ^^ length n
expon :: Parser Double
expon = option 1 $ do
eE
s <- sign
n <- digits
return $ s * 10 ** numberFromString n

149. Parse JSON

150. Parse JSON

151. Parse JSON

152. Parse JSON
data Value = String String
| Number Double
| Object [(String, Value)]
| Array [Value]
| Bool Bool
| Null

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

154. Parse JSON
data Value = String String
| Number Double
| Object [(String, Value)]
| Array [Value]
| Bool Bool
| Null

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

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

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

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

159. 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 ","

160. Summary

161. Summary

162. Summary
Parsers
Monads
Type Classes
Parametric Types
Functions and Data Types

163. Summary
Parsers
Monads
Type Classes
Parametric Types
Functions and Data Types

164. Summary
Parsers
Monads
Type Classes
Parametric Types
Functions and Data Types

165. Summary
Parsers
Monads
Type Classes
Parametric Types
Functions and Data Types

166. Summary
Parsers
Monads
Type Classes
Parametric Types
Functions and Data Types

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

168. Thank You