1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
|
module Minilang.Lambda.Parser where
import Control.Applicative (Alternative (many), (<|>))
import Data.Bifunctor (first)
import Data.Text (Text, pack)
import Data.Void (Void)
import Text.Megaparsec (Parsec, between, empty, errorBundlePretty, manyTill, notFollowedBy, optional, parse, try)
import Text.Megaparsec.Char (alphaNumChar, char, letterChar, space1, string, symbolChar)
import qualified Text.Megaparsec.Char.Lexer as L
type Parser = Parsec Void Text
data ParseError = ParseError Text
deriving (Eq, Show)
data AST = Sym Text | Abs [Text] AST
deriving (Eq, Show)
parse :: Text -> Either ParseError AST
parse =
first (ParseError . pack . errorBundlePretty) . Text.Megaparsec.parse ast ""
ast :: Parser AST
ast = try lambda <|> try sym
lambda :: Parser AST
lambda =
between
lpar
rpar
( lexeme "lam"
*> ( (Abs . fmap pack <$> between lpar rpar (many identifier))
<*> ast
)
)
lpar :: Parser Text
lpar = symbol "("
rpar :: Parser Text
rpar = symbol ")"
symbol :: Text -> Parser Text
symbol = L.symbol spaceConsumer
sym :: Parser AST
sym = Sym . pack <$> identifier
identifier :: Parser String
identifier =
lexeme $
(:)
<$> (letterChar <|> extraChars)
<*> many (alphaNumChar <|> extraChars)
lexeme :: Parser a -> Parser a
lexeme = L.lexeme spaceConsumer
extraChars :: Parser Char
extraChars =
foldl (\b a -> char a <|> b) symbolChar extraIdentifierChars
initialChars :: [Char]
initialChars =
['a' .. 'z'] <> ['A' .. 'Z'] <> extraIdentifierChars
restChars :: [Char]
restChars =
initialChars <> ['0' .. '9']
extraIdentifierChars :: String
extraIdentifierChars = ['-', '_', '*', '#', '%', '&', ':', '@', '/']
spaceConsumer :: Parser ()
spaceConsumer =
L.space space1 (L.skipLineComment ";") empty
|
