The document describes how to build a parser for Backus-Naur Form (BNF) grammars in Haskell using the attoparsec parsing library. It defines types and parsers to represent BNF syntax, rules, expressions, lists and terms. The parsers use functions like spaces, string, text from attoparsec to parse individual components and combine them using operators like <*>, <|> to build up the full BNF grammar parser.

1. 8 :
ruicc (ruicc.rail@gmail.com)

2. • ( )
•@ruicc
•http://d.hatena.ne.jp/ruicc
•LinkThink ! Altplus

3. Haskell 8
• Google Suggest

4. •Haskell

5. P.90 †2[ ]
•
Web
10

6. P.90 †2[ ]
•
Web
10

7. P.90 †2[ ]

8. P.90 †2[ ]

9. P.90 †2[ ]
• =>
• import Prelude hiding(return,(>>=),(>>))
• do (Mona* )
•

10. •
•
•Haskell

11. •
• *
•
•advanced :

12. •

13. •Parser [pärsəәr]
•

14. “-32.4” Parser -32.4

16. •
type Parser = String -> Tree
※Tree

17. •
type Parser = String -> (Tree, String)

18. •
type Parser = String -> [(Tree, String)]

19. • a
type Parser a = String -> [(a, String)]
※
advanced:

20. •
“1.4aaa” Parser [(1.4,“aaa”)]

21. •
“+.4aaa” Parser []

22. • return :: a -> Parser a
•
• failure :: Parser a
•
• item :: Parser Char
•

23. parse
• Parser String
• Parser
parse:: Parser a -> String -> [(a,String)]

24. parse
•parse
“1.4aaa” Parser [(1.4,“aaa”)]
parse !

25. “-3.24” sign [(‘-’,“3.24”)]
“3.24” digits [(“3”,“.24”)]
“.24” point [(‘.’,“24”)]

26. •
•
•
•

27. sign
digits
“-3.24” [(-3.24,“”)]
point
parse 1
digits
※

28. •
•

29. •p, then q
double
=
digits >>= point >>= digits
※

30. • (>>=)
p
(>>=):: Parser a -> (a -> Parser b) -> Parser b
p >>= f = inp -> case parse p inp of
[] -> []
[(v,out)] -> parse (f v) out
(f v)

31. •p, or q
char ‘+’
sign = +++
char ‘-’

32. •
p
(+++):: Parser a -> Parser a -> Parser a
p +++ q = inp -> case parse p inp of
[] -> parse q inp
[(v,out)] -> [(v,out)]
q
advanced: p

33. “-3.24” sign [(‘-’,“3.24”)]
“3.24” digits [(“3”,“.24”)]
“.24” point [(‘.’,“24”)]

34. “-3.24” sign [(‘-’,“3.24”)]
“3.24” digits [(“3”,“.24”)]
“.24” point [(‘.’,“24”)]

35. “-3.24” sign [(‘-’,“3.24”)]
“3.24” digits [(“3”,“.24”)]
“.24” point [(‘.’,“24”)]

36. • (>>=)
double =
sign >>= s ->
digits >>= num ->
point >>= p ->
digits >>= num2 ->
return (func s num p num2)
※sign,digits,point given

37. • return
double =
sign >>= s ->
digits >>= num ->
point >>= p ->
digits >>= num2 ->
return (func s num p num2)

38. do
• Parser
double :: Parser Double
double = do
s <- sign
num <- digits
p <- point
num2 <- digits
return (func s num p num2)

39. • type Parser a = String -> [(a, String)]
• Char
• Parser a
• Parser

40. do
•
double :: Parser Double
double = do
Char s <- sign :: Parser Char
num <- digits :: Parser String
String
p <- point :: Parser Char
Char num2 <- digits :: Parser String
String return (func s num p num2) :: Parser Double

41. do
•
•
• String
• (>>=)

42. sign
digits
“-3.24” [(-3.24,“”)]
point
digits

43. • return, failure, item
• (>>=)
• (+++)
• (do )

44. •
• (>>=)
• (+++)
• ( )

46. • item sat
item
sat :: (Char -> Bool) -> Parser Char
sat p = do x <- item
if p x then return x else failure
(p x) True False
※p predicate

47. • sat
digit = sat isDigit
lower = sat isLower
upper = sat isUpper
letter = sat isAlpha
alphanum = sat isAlphanum
char x = sat (==x)

48. • char string
string :: String -> Parser String
string [] = return []
string (x:xs) = do char x
string xs
return (x:xs)

49. • many, many1
many, many1 :: Parser a -> Parser [a]
many p = many1 p +++ return []
many1 p = do v <- p
vs <- many p
return (v:vs)

50. • many
ident = do x <- lower
xs <- many alphanum
return (x:xs)
nat = do xs <- many1 digit
return (read xs)
space = do many (sat isSpace)
return ()

51. •
token :: Parser a -> Parser a
token p = do space
v <- p
space
return v

52. • token
identifier :: Parser String
identifier = token ident
natural :: Parser Int
natural = token nat
symbol :: Parser String
symbol xs = token (string xs)

53. •

54. :
•BNF(Backus-Naur Form)
•
• (|) ( )

55. • BNF..?
expr ::= expr ‘+’ expr
| expr ‘*’ expr
| ‘(‘ expr ‘)’
| nat
nat ::= ‘0’ | ‘1’ | ‘2’ | ...

56. •(*) (+)
•
• (expr), (term), (factor)

57. • BNF
expr ::= expr ‘+’ expr | term
term ::= term ‘*’ term | factor
factor ::= ‘(‘ expr ‘)’ | nat
nat ::= ‘0’ | ‘1’ | ‘2’ | ...

58. •
•1 + 2 + 3 == 1 + (2 + 3)
•
•1 - 2 - 3 == (1 - 2) - 3
•

59. • BNF( )
expr ::= term ‘+’ expr | term
term ::= factor ‘*’ term | factor
factor ::= ‘(‘ expr ‘)’ | nat
nat ::= ‘0’ | ‘1’ | ‘2’ | ...

60. • BNF( )
expr ::= term ‘+’ expr | term
term ::= factor ‘*’ term | factor
→

61. •BNF 1
-- expr ::= term ‘+’ expr | term
expr :: Parser Int
expr = do t <- (term :: Parser Int)
symbol “+”
e <- (expr :: Parser Int)
return (t + e)
+++ term

62. •BNF 2
-- term ::= factor ‘*’ term | factor
term :: Parser Int
term = do f <- (factor :: Parser Int)
symbol “*”
t <- (term :: Parser Int)
return (f * t)
+++ factor

63. •BNF 3
-- factor ::= ‘(‘ expr ‘)’ | nat
factor :: Parser Int
factor = do symbol “(“
e <- (expr :: Parser Int)
symbol “)”
return e
+++ natural

64. • expr
ghci> parse expr "5 * (2) + ( 4 +(2 * 2 + 4) * 2) * 5 "
[(110,””)]

65. Haskell
Parser

66. Package
•Parsec3
•
•attoparsec
•

67. •
• letter, digit, char, string, many, ...
• (+++) (<|>), try
•
• import Control.Applicative (<|>)
• try

68. BNF
BNF BNF (wikipedia )
<syntax> ::= <rule> | <rule> <syntax>
<rule> ::= <opt-whitespace> "<" <rule-name> ">" <opt-whitespace> "::="
<opt-whitespace> <expression> <line-end>
<opt-whitespace> ::= " " <opt-whitespace> | ""
<expression> ::= <list> | <list> "|" <expression>
<line-end> ::= <opt-whitespace> <eol> | <line-end> <line-end>
<list> ::= <term> | <term> <opt-whitespace> <list>
<term> ::= <literal> | "<" <rule-name> ">"
<literal> ::= '"' <text> '"' | "'" <text> "'"

69. cabal install attoparsec
cabal install attoparsec-text

70. {-# LANGUAGE OverloadedStrings #-}
module BNFParser where
import Data.Attoparsec.Text
import Data.Text.Internal (Text)
import Data.Text as T
import Control.Applicative hiding(many)

71. BNF
type BNF = Syntax
type Syntax = [Rule]
data Rule = Rule Text Expr
type Expr = [List]
type List = [Term]
data Term = Lit Text | RuleName Text

72. BNF (10 !)
syntax = many1 rule
rule = Rule <$> (spaces *> "<" .*> text '>' <*. ">") <* spaces
<* string "::=" <* spaces <*> expression <* line_end
spaces = T.pack <$> many (char ' ')
expression = sepBy1 list (spaces *> string "|" <* spaces)
line_end = many1 $ spaces *> endOfLine
list = sepBy1 term spaces
term = Lit <$> literal <|> RuleName <$> "<" .*> text '>' <*. ">"
literal = "'" .*> text ''' <*. "'" <|> """ .*> text '"' <*. """
text c = takeTill (==c)

73. 3
Haskell
Parser

74. BNF
syntax = many1 rule
rule = Rule <$> (spaces *> "<" .*> text '>' <*. ">") <* spaces
<* string "::=" <* spaces <*> expression <* line_end
spaces = T.pack <$> many (char ' ')
expression = sepBy1 list (spaces *> string "|" <* spaces)
line_end = many1 $ spaces *> endOfLine
list = sepBy1 term spaces
term = Lit <$> literal <|> RuleName <$> "<" .*> text '>' <*. ">"
literal = "'" .*> text ''' <*. "'" <|> """ .*> text '"' <*. """
text c = takeTill (==c)

75. 3

76. Haskell
Mona*,Applicative,
Functor,Arrow,...

77. Happy Hacking Parser
in Haskell!