git.iko.soy/elk
on master help sign in
Improve indentation and style in Parse.Expression
5e3f51aEvan Czaplicki
src/Parse/Expression.hs+68−57
compare with master
unifiedsplit
@@ -1,4 +1,4 @@
1−module Parse.Expression (def,term,typeAnnotation,expr) where
1+module Parse.Expression (def, term, typeAnnotation, expr) where
2
2
3import Control.Applicative ((<$>), (<*>))
3import Control.Applicative ((<$>), (<*>))
4import qualified Data.List as List
4import qualified Data.List as List
@@ -85,7 +85,7 @@ parensTerm =
85 loc = Annotation.at start end
85 loc = Annotation.at start end
86 return $ foldr (\x e -> loc $ E.Lambda x e)
86 return $ foldr (\x e -> loc $ E.Lambda x e)
87 (loc . E.tuple $ map (loc . E.rawVar) vars) (map P.Var vars)
87 (loc . E.tuple $ map (loc . E.rawVar) vars) (map P.Var vars)
88−
88+
89 parened = do
89 parened = do
90 (start, es, end) <- located (commaSep expr)
90 (start, es, end) <- located (commaSep expr)
91 return $ case es of
91 return $ case es of
@@ -102,7 +102,7 @@ recordTerm =
102 padded equals
102 padded equals
103 body <- expr
103 body <- expr
104 return (label, makeFunction patterns body)
104 return (label, makeFunction patterns body)
105−
105+
106 record =
106 record =
107 E.Record <$> commaSep field
107 E.Record <$> commaSep field
108
108
@@ -129,7 +129,7 @@ recordTerm =
129 case opt of
129 case opt of
130 Just e -> try (insert e) <|> return e
130 Just e -> try (insert e) <|> return e
131 Nothing -> try (insert record) <|> try (modify record)
131 Nothing -> try (insert record) <|> try (modify record)
132−
132+
133
133
134term :: IParser Source.Expr
134term :: IParser Source.Expr
135term = addLocation (choice [ E.Literal <$> Literal.literal, listTerm, accessor, negative ])
135term = addLocation (choice [ E.Literal <$> Literal.literal, listTerm, accessor, negative ])
@@ -152,6 +152,14 @@ appExpr =
152
152
153-------- Normal Expressions --------
153-------- Normal Expressions --------
154
154
155+expr :: IParser Source.Expr
156+expr =
157+ addLocation (choice [ ifExpr, letExpr, caseExpr ])
158+ <|> lambdaExpr
159+ <|> binaryExpr
160+ <?> "an expression"
161+
162+
155binaryExpr :: IParser Source.Expr
163binaryExpr :: IParser Source.Expr
156binaryExpr =
164binaryExpr =
157 Binop.binops appExpr lastExpr anyOp
165 Binop.binops appExpr lastExpr anyOp
@@ -198,23 +206,6 @@ lambdaExpr =
198 return (makeFunction args body)
206 return (makeFunction args body)
199
207
200
208
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−
218caseExpr :: IParser Source.Expr'
209caseExpr :: IParser Source.Expr'
219caseExpr =
210caseExpr =
220 do try (reserved "case")
211 do try (reserved "case")
@@ -235,45 +226,30 @@ caseExpr =
235 block (do c <- case_ ; whitespace ; return c)
226 block (do c <- case_ ; whitespace ; return c)
236
227
237
228
238−expr :: IParser Source.Expr
229+-- LET
239−expr = addLocation (choice [ ifExpr, letExpr, caseExpr ])
240− <|> lambdaExpr
241− <|> binaryExpr
242− <?> "an expression"
243
230
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
244
238
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]
258
239
259− infics p1 = do
240+defSet :: IParser [Source.Def]
260− o:p <- try (whitespace >> anyOp)
241+defSet =
242+ block $
243+ do d <- def
261− p2 <- (whitespace >> Pattern.term)
244+ whitespace
262− return $ if o == '`' then [ P.Var $ takeWhile (/='`') p, p1, p2 ]
245+ return d
263− else [ P.Var (o:p), p1, p2 ]
264
246
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
268
247
248+-- DEFINITIONS
269
249
270−definition :: IParser Source.Def
250+def :: IParser Source.Def
271−definition =
251+def =
272− withPos $
252+ typeAnnotation <|> definition
273− do (name:args) <- defStart
274− padded equals
275− body <- expr
276− return . Source.Definition name $ makeFunction args body
277
253
278
254
279typeAnnotation :: IParser Source.Def
255typeAnnotation :: IParser Source.Def
@@ -286,6 +262,41 @@ typeAnnotation =
286 return v
262 return v
287
263
288
264
289−def :: IParser Source.Def
265+definition :: IParser Source.Def
290−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+ ]
291− typeAnnotation <|> definition
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+