@@ -1,4 +1,4 @@
1−module Parse.Expression (def,term,typeAnnotation,expr) where
1+module Parse.Expression (def, term, typeAnnotation, expr) where
22
33import Control.Applicative ((<$>), (<*>))
44import qualified Data.List as List
@@ -85,7 +85,7 @@ parensTerm =
8585 loc = Annotation.at start end
8686 return $ foldr (\x e -> loc $ E.Lambda x e)
8787 (loc . E.tuple $ map (loc . E.rawVar) vars) (map P.Var vars)
88−
88+
8989 parened = do
9090 (start, es, end) <- located (commaSep expr)
9191 return $ case es of
@@ -102,7 +102,7 @@ recordTerm =
102102 padded equals
103103 body <- expr
104104 return (label, makeFunction patterns body)
105−
105+
106106 record =
107107 E.Record <$> commaSep field
108108
@@ -129,7 +129,7 @@ recordTerm =
129129 case opt of
130130 Just e -> try (insert e) <|> return e
131131 Nothing -> try (insert record) <|> try (modify record)
132−
132+
133133
134134term :: IParser Source.Expr
135135term = addLocation (choice [ E.Literal <$> Literal.literal, listTerm, accessor, negative ])
@@ -152,6 +152,14 @@ appExpr =
152152
153153-------- Normal Expressions --------
154154
155+expr :: IParser Source.Expr
156+expr =
157+ addLocation (choice [ ifExpr, letExpr, caseExpr ])
158+ <|> lambdaExpr
159+ <|> binaryExpr
160+ <?> "an expression"
161+
162+
155163binaryExpr :: IParser Source.Expr
156164binaryExpr =
157165 Binop.binops appExpr lastExpr anyOp
@@ -198,23 +206,6 @@ lambdaExpr =
198206 return (makeFunction args body)
199207
200208
201−defSet :: IParser [Source.Def]
202−defSet =
203− block $
204− do d <- def
205− whitespace
206− return d
207−
208−
209−letExpr :: IParser Source.Expr'
210−letExpr =
211− do try (reserved "let")
212− whitespace
213− defs <- defSet
214− padded (reserved "in")
215− E.Let defs <$> expr
216−
217−
218209caseExpr :: IParser Source.Expr'
219210caseExpr =
220211 do try (reserved "case")
@@ -235,45 +226,30 @@ caseExpr =
235226 block (do c <- case_ ; whitespace ; return c)
236227
237228
238−expr :: IParser Source.Expr
239−expr = addLocation (choice [ ifExpr, letExpr, caseExpr ])
240− <|> lambdaExpr
241− <|> binaryExpr
242− <?> "an expression"
229+-- LET
243230
231+letExpr :: IParser Source.Expr'
232+letExpr =
233+ do try (reserved "let")
234+ whitespace
235+ defs <- defSet
236+ padded (reserved "in")
237+ E.Let defs <$> expr
244238
245−defStart :: IParser [P.RawPattern]
246−defStart =
247− choice [ do p1 <- try Pattern.term
248− infics p1 <|> func p1
249− , func =<< (P.Var <$> parens symOp)
250− , (:[]) <$> Pattern.expr
251− ] <?> "the definition of a variable (x = ...)"
252− where
253− func pattern =
254− case pattern of
255− P.Var _ -> (pattern:) <$> spacePrefix Pattern.term
256− _ -> do try (lookAhead (whitespace >> string "="))
257− return [pattern]
258239
259− infics p1 = do
260− o:p <- try (whitespace >> anyOp)
261− p2 <- (whitespace >> Pattern.term)
262− return $ if o == '`' then [ P.Var $ takeWhile (/='`') p, p1, p2 ]
263− else [ P.Var (o:p), p1, p2 ]
240+defSet :: IParser [Source.Def]
241+defSet =
242+ block $
243+ do d <- def
244+ whitespace
245+ return d
264246
265−makeFunction :: [P.RawPattern] -> Source.Expr -> Source.Expr
266−makeFunction args body@(Annotation.A ann _) =
267− foldr (\arg body' -> Annotation.A ann $ E.Lambda arg body') body args
268247
248+-- DEFINITIONS
269249
270−definition :: IParser Source.Def
271−definition =
272− withPos $
273− do (name:args) <- defStart
274− padded equals
275− body <- expr
276− return . Source.Definition name $ makeFunction args body
250+def :: IParser Source.Def
251+def =
252+ typeAnnotation <|> definition
277253
278254
279255typeAnnotation :: IParser Source.Def
@@ -286,6 +262,41 @@ typeAnnotation =
286262 return v
287263
288264
289−def :: IParser Source.Def
290−def =
291− typeAnnotation <|> definition
265+definition :: IParser Source.Def
266+definition =
267+ withPos $
268+ do (name:args) <- defStart
269+ padded equals
270+ body <- expr
271+ return . Source.Definition name $ makeFunction args body
272+
273+
274+makeFunction :: [P.RawPattern] -> Source.Expr -> Source.Expr
275+makeFunction args body@(Annotation.A ann _) =
276+ foldr (\arg body' -> Annotation.A ann $ E.Lambda arg body') body args
277+
278+
279+defStart :: IParser [P.RawPattern]
280+defStart =
281+ choice
282+ [ do p1 <- try Pattern.term
283+ infics p1 <|> func p1
284+ , func =<< (P.Var <$> parens symOp)
285+ , (:[]) <$> Pattern.expr
286+ ]
287+ <?> "the definition of a variable (x = ...)"
288+ where
289+ func pattern =
290+ case pattern of
291+ P.Var _ -> (pattern:) <$> spacePrefix Pattern.term
292+ _ -> do try (lookAhead (whitespace >> string "="))
293+ return [pattern]
294+
295+ infics p1 =
296+ do o:p <- try (whitespace >> anyOp)
297+ p2 <- (whitespace >> Pattern.term)
298+ return $
299+ if o == '`'
300+ then [ P.Var $ takeWhile (/='`') p, p1, p2 ]
301+ else [ P.Var (o:p), p1, p2 ]
302+