summaryrefslogtreecommitdiff
path: root/Unlambda/Parser.hs
blob: 384ec8ff7000167bf0ed6f256845cb4cff688701 (plain)
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
module Unlambda.Parser (
    UnlambdaTerm(..),

	parseUnlambda
    ) where


import Control.Applicative( some )
import Text.ParserCombinators.Parsec



data UnlambdaTerm = S | K | I | V | R | D | C | E | Bar | Reed
                  | Dot { cha :: Char }
                  | Compare { cha :: Char }
	              | App { func :: UnlambdaTerm
                        , arg :: UnlambdaTerm }
                  | Kpartial { constant :: UnlambdaTerm }
                  | Spartial { func1 :: UnlambdaTerm }
                  | Sapp { func1 :: UnlambdaTerm
                         , func2 :: UnlambdaTerm }
                  | Continuation { arg :: UnlambdaTerm }
                  | Promise { arg :: UnlambdaTerm }
    deriving (Eq, Show)




parseUnlambda :: String -> Either ParseError UnlambdaTerm
parseUnlambda = parse unlambda "error"



parseUnlambda1 :: String -> Either ParseError UnlambdaTerm
parseUnlambda1 = parse unlambda1 "error"



unlambda = do
	whiteSpace
	t <- term
	eof
	return t


unlambda1 = do
	whiteSpace
	t <- term1
	eof
	return t


term  =  (try term1)
     <|> (try e)
     <|> (try reed)
     <|> (try comp)
     <|> (try bar)
     <?> "unlambda term"


term1  =  (try app)
      <|> (try s)
      <|> (try k)
      <|> (try i)
      <|> (try v)
      <|> (try r)
      <|> (try d)
      <|> (try c)
      <|> (try dot)
      <?> "unlambda term"


app = do
	char '`'
	whiteSpace
	f <- term
	x <- term
	return (App f x)


s = char 's' >> whiteSpace >> return S
k = char 'k' >> whiteSpace >> return K
i = char 'i' >> whiteSpace >> return I
v = char 'v' >> whiteSpace >> return V
r = char 'r' >> whiteSpace >> return R
d = char 'd' >> whiteSpace >> return D
c = char 'c' >> whiteSpace >> return C
e = char 'e' >> whiteSpace >> return E
reed = char '@' >> whiteSpace >> return Reed
bar = char '|' >> whiteSpace >> return Bar


comp = do
	char '?'
	c <- noneOf("")
	whiteSpace
	return (Compare c)


dot = do
	char '.'
	c <- noneOf("")
	whiteSpace
	return (Dot c)


whiteSpace = many (oneOf "\t\n\r ")