d9c0c51 · rowtype-yoga/purescript-native

git.iko.soy/rowtype-yoga/purescript-native

on golang help sign in

Merge pull request #1715 from purescript/eager-parsing

d9c0c51Phil Freeman11 years ago

src/Language/PureScript/Parser/Declarations.hs+63−58

compare with golang

unifiedsplit

@@ -76,7 +76,7 @@ parseTypeDeclaration =

77parseTypeSynonymDeclaration :: TokenParser Declaration

78parseTypeSynonymDeclaration =

79− TypeSynonymDeclaration <$> (P.try (reserved "type") *> indented *> properName)

79+ TypeSynonymDeclaration <$> (reserved "type" *> indented *> properName)

80 <*> many (indented *> kindedIdent)

81 <*> (indented *> equals *> noWildcards parsePolyType)

@@ -102,8 +102,8 @@ parseValueDeclaration = do

102 return $ maybe value (`Let` value) whereClause

103

104parseExternDeclaration :: TokenParser Declaration

105−parseExternDeclaration = P.try (reserved "foreign") *> indented *> reserved "import" *> indented *>

105+parseExternDeclaration = reserved "foreign" *> indented *> reserved "import" *> indented *>

106− (ExternDataDeclaration <$> (P.try (reserved "data") *> indented *> properName)

106+ (ExternDataDeclaration <$> (reserved "data" *> indented *> properName)

107 <*> (indented *> doubleColon *> parseKind)

108 <|> (do ident <- parseIdent

109 ty <- indented *> doubleColon *> noWildcards parsePolyType

@@ -111,9 +111,9 @@ parseExternDeclaration = P.try (reserved "foreign") *> indented *> reserved "imp

111

112parseAssociativity :: TokenParser Associativity

113parseAssociativity =

114− (P.try (reserved "infixl") >> return Infixl) <|>

114+ (reserved "infixl" *> return Infixl) <|>

115− (P.try (reserved "infixr") >> return Infixr) <|>

115+ (reserved "infixr" *> return Infixr) <|>

116− (P.try (reserved "infix") >> return Infix)

116+ (reserved "infix" *> return Infix)

117

118parseFixity :: TokenParser Fixity

119parseFixity = Fixity <$> parseAssociativity <*> (indented *> natural)

@@ -156,7 +156,6 @@ parseImportDeclaration' = do

156 <|> (const (Implicit True) <$> (indented *> parens (symbol' "..")))

157 return $ fromMaybe (Implicit False) declType

158

159−

160parseDeclarationRef :: TokenParser DeclarationRef

159parseDeclarationRef :: TokenParser DeclarationRef

161parseDeclarationRef =

160parseDeclarationRef =

162 withSourceSpan PositionedDeclarationRef

161 withSourceSpan PositionedDeclarationRef

@@ -173,9 +172,9 @@ parseDeclarationRef =

173parseTypeClassDeclaration :: TokenParser Declaration

172parseTypeClassDeclaration :: TokenParser Declaration

174parseTypeClassDeclaration = do

173parseTypeClassDeclaration = do

175 reserved "class"

174 reserved "class"

176− implies <- P.option [] $ P.try $ do

175+ implies <- P.option [] . P.try $ do

177 indented

176 indented

178− implies <- P.try (return <$> parseConstraint) <|> parens (commaSep1 parseConstraint)

177+ implies <- (return <$> parseConstraint) <|> parens (commaSep1 parseConstraint)

179 lfatArrow

178 lfatArrow

180 return implies

179 return implies

181 className <- indented *> properName

180 className <- indented *> properName

@@ -194,7 +193,7 @@ parseInstanceDeclaration = do

194 reserved "instance"

193 reserved "instance"

195 name <- parseIdent <* indented <* doubleColon

194 name <- parseIdent <* indented <* doubleColon

196 deps <- P.optionMaybe $ P.try $ do

195 deps <- P.optionMaybe $ P.try $ do

197− deps <- P.try (return <$> parseConstraint) <|> parens (commaSep1 parseConstraint)

196+ deps <- (return <$> parseConstraint) <|> parens (commaSep1 parseConstraint)

198 indented

197 indented

199 rfatArrow

198 rfatArrow

200 return deps

199 return deps

@@ -326,11 +325,12 @@ parseIdentifierAndValue =

326 <|> (,) <$> (C.indented *> stringLiteral) <*> rest

325 <|> (,) <$> (C.indented *> stringLiteral) <*> rest

327 where

326 where

328 rest = C.indented *> colon *> C.indented *> val

327 rest = C.indented *> colon *> C.indented *> val

329− val = (Just <$> parseValue) <|> (underscore *> pure Nothing)

328+ val = (underscore *> pure Nothing) <|> (Just <$> parseValue)

330

329

331parseAbs :: TokenParser Expr

330parseAbs :: TokenParser Expr

332parseAbs = do

331parseAbs = do

333 symbol' "\\"

332 symbol' "\\"

333+ -- TODO: remove this 'try' after operator aliases are finished (0.9)

334 args <- P.many1 (C.indented *> (Abs <$> (Left <$> P.try C.parseIdent <|> Right <$> parseBinderNoParens)))

335 C.indented *> rarrow

336 value <- parseValue

@@ -346,7 +346,7 @@ parseConstructor :: TokenParser Expr

346parseConstructor = Constructor <$> C.parseQualified C.properName

347

348parseCase :: TokenParser Expr

349−parseCase = Case <$> P.between (P.try (reserved "case")) (C.indented *> reserved "of") (commaSep1 parseValue)

349+parseCase = Case <$> P.between (reserved "case") (C.indented *> reserved "of") (commaSep1 parseValue)

350 <*> (C.indented *> C.mark (P.many1 (C.same *> C.mark parseCaseAlternative)))

351

352parseCaseAlternative :: TokenParser CaseAlternative

@@ -375,23 +375,25 @@ parseLet = do

375

376parseValueAtom :: TokenParser Expr

377parseValueAtom = P.choice

378− [ P.try parseNumericLiteral

378+ [ parseNumericLiteral

379− , P.try parseCharLiteral

379+ , parseCharLiteral

380− , P.try parseStringLiteral

380+ , parseStringLiteral

381− , P.try parseBooleanLiteral

381+ , parseBooleanLiteral

382− , parseArrayLiteral

382+ , parseArrayLiteral

383− , P.try parseObjectLiteral

383+ , P.try parseObjectLiteral

384− , P.try parseObjectGetter

384+ , P.try parseObjectGetter

385− , parseAbs

385+ , parseAbs

386− , P.try parseConstructor

386+ , P.try parseConstructor

387− , P.try parseVar

387+ , P.try parseVar

388− , parseCase

388+ , parseCase

389− , parseIfThenElse

389+ , parseIfThenElse

390− , parseDo

390+ , parseDo

391− , parseLet

391+ , parseLet

392− , P.try $ Parens <$> parens parseValue

392+ , P.try $ Parens <$> parens parseValue

393− , parseOperatorSection

393+ , parseOperatorSection

394+ -- TODO: combine this with parseObjectGetter

394− , P.try parseObjectUpdaterWildcard ]

395+ , parseObjectUpdaterWildcard

396+ ]

395

397

396-- |

398-- |

397-- Parse an expression in backticks or an operator

399-- Parse an expression in backticks or an operator

@@ -427,13 +429,14 @@ parseDoNotationLet :: TokenParser DoNotationElement

427parseDoNotationLet = DoNotationLet <$> (reserved "let" *> C.indented *> C.mark (P.many1 (C.same *> parseLocalDeclaration)))

429parseDoNotationLet = DoNotationLet <$> (reserved "let" *> C.indented *> C.mark (P.many1 (C.same *> parseLocalDeclaration)))

428

430

429parseDoNotationBind :: TokenParser DoNotationElement

431parseDoNotationBind :: TokenParser DoNotationElement

430−parseDoNotationBind = DoNotationBind <$> parseBinder <*> (C.indented *> larrow *> parseValue)

432+parseDoNotationBind = DoNotationBind <$> P.try (parseBinder <* C.indented <* larrow) <*> parseValue

431

433

432parseDoNotationElement :: TokenParser DoNotationElement

434parseDoNotationElement :: TokenParser DoNotationElement

433parseDoNotationElement = P.choice

435parseDoNotationElement = P.choice

434− [ P.try parseDoNotationBind

436+ [ parseDoNotationBind

435 , parseDoNotationLet

437 , parseDoNotationLet

436− , P.try (DoNotationValue <$> parseValue) ]

438+ , DoNotationValue <$> parseValue

439+ ]

437

440

438parseObjectGetter :: TokenParser Expr

441parseObjectGetter :: TokenParser Expr

439parseObjectGetter = ObjectGetter <$> (underscore *> C.indented *> dot *> C.indented *> (lname <|> stringLiteral))

442parseObjectGetter = ObjectGetter <$> (underscore *> C.indented *> dot *> C.indented *> (lname <|> stringLiteral))

@@ -443,7 +446,8 @@ indexersAndAccessors :: TokenParser Expr

443indexersAndAccessors = C.buildPostfixParser postfixTable parseValueAtom

446indexersAndAccessors = C.buildPostfixParser postfixTable parseValueAtom

444 where

447 where

445 postfixTable = [ parseAccessor

448 postfixTable = [ parseAccessor

446− , P.try . parseUpdaterBody . Just ]

449+ , P.try . parseUpdaterBody . Just

450+ ]

447

451

448-- |

452-- |

449-- Parse a value

453-- Parse a value

@@ -455,9 +459,9 @@ parseValue = withSourceSpan PositionedValue

455 $ indexersAndAccessors) P.<?> "expression"

459 $ indexersAndAccessors) P.<?> "expression"

456 where

460 where

457 postfixTable = [ \v -> P.try (flip App <$> (C.indented *> indexersAndAccessors)) <*> pure v

461 postfixTable = [ \v -> P.try (flip App <$> (C.indented *> indexersAndAccessors)) <*> pure v

458− , \v -> flip (TypedValue True) <$> (P.try (C.indented *> doubleColon) *> parsePolyType) <*> pure v

462+ , \v -> flip (TypedValue True) <$> (C.indented *> doubleColon *> parsePolyType) <*> pure v

459 ]

463 ]

460− operators = [ [ P.Prefix (P.try (C.indented *> symbol' "-") >> return UnaryMinus)

464+ operators = [ [ P.Prefix (C.indented *> symbol' "-" *> return UnaryMinus)

461 ]

465 ]

462 , [ P.Infix (P.try (C.indented *> parseInfixExpr P.<?> "infix expression") >>= \ident ->

466 , [ P.Infix (P.try (C.indented *> parseInfixExpr P.<?> "infix expression") >>= \ident ->

463 return (BinaryNoParens ident)) P.AssocRight

467 return (BinaryNoParens ident)) P.AssocRight

@@ -487,9 +491,6 @@ parseNumberBinder = NumberBinder <$> (sign <*> number)

487 <|> (symbol' "+" >> return id)

491 <|> (symbol' "+" >> return id)

488 <|> return id

492 <|> return id

489

493

490−parseVarBinder :: TokenParser Binder

491−parseVarBinder = VarBinder <$> C.parseIdent

492−

493parseNullaryConstructorBinder :: TokenParser Binder

494parseNullaryConstructorBinder :: TokenParser Binder

494parseNullaryConstructorBinder = ConstructorBinder <$> C.parseQualified C.properName <*> pure []

495parseNullaryConstructorBinder = ConstructorBinder <$> C.parseQualified C.properName <*> pure []

495

496

@@ -502,9 +503,13 @@ parseObjectBinder = ObjectBinder <$> braces (commaSep (C.indented *> parseIdenti

502parseArrayBinder :: TokenParser Binder

503parseArrayBinder :: TokenParser Binder

503parseArrayBinder = squares $ ArrayBinder <$> commaSep (C.indented *> parseBinder)

504parseArrayBinder = squares $ ArrayBinder <$> commaSep (C.indented *> parseBinder)

504

505

505−parseNamedBinder :: TokenParser Binder

506+parseVarOrNamedBinder :: TokenParser Binder

507+parseVarOrNamedBinder = do

508+ -- TODO: once operator aliases are finalized in 0.9, this 'try' won't be needed

509+ -- any more since identifiers in binders won't be 'Op's.

510+ name <- P.try C.parseIdent

506−parseNamedBinder = NamedBinder <$> (C.parseIdent <* C.indented <* at)

511+ let parseNamedBinder = NamedBinder name <$> (at *> C.indented *> parseBinder)

507− <*> (C.indented *> parseBinder)

512+ parseNamedBinder <|> return (VarBinder name)

508

513

509parseNullBinder :: TokenParser Binder

514parseNullBinder :: TokenParser Binder

510parseNullBinder = underscore *> return NullBinder

515parseNullBinder = underscore *> return NullBinder

@@ -525,38 +530,38 @@ parseBinder :: TokenParser Binder

525parseBinder = withSourceSpan PositionedBinder (buildPostfixParser postfixTable parseBinderAtom)

530parseBinder = withSourceSpan PositionedBinder (buildPostfixParser postfixTable parseBinderAtom)

526 where

531 where

527 -- TODO: parsePolyType when adding support for polymorphic types

532 -- TODO: parsePolyType when adding support for polymorphic types

528− postfixTable = [ \b -> flip TypedBinder b <$> (P.try (indented *> doubleColon) *> parseType)

533+ postfixTable = [ \b -> flip TypedBinder b <$> (indented *> doubleColon *> parseType)

529 ]

534 ]

530 parseBinderAtom :: TokenParser Binder

535 parseBinderAtom :: TokenParser Binder

531− parseBinderAtom = P.choice (map P.try

536+ parseBinderAtom = P.choice

532 [ parseNullBinder

537 [ parseNullBinder

533 , parseCharBinder

538 , parseCharBinder

534 , parseStringBinder

539 , parseStringBinder

535 , parseBooleanBinder

540 , parseBooleanBinder

536 , parseNumberBinder

541 , parseNumberBinder

537− , parseNamedBinder

542+ , parseVarOrNamedBinder

538− , parseVarBinder

539 , parseConstructorBinder

543 , parseConstructorBinder

540 , parseObjectBinder

544 , parseObjectBinder

541 , parseArrayBinder

545 , parseArrayBinder

542− , parens parseBinder ]) P.<?> "binder"

546+ , parens parseBinder

547+ ] P.<?> "binder"

543

548

544-- |

549-- |

545-- Parse a binder as it would appear in a top level declaration

550-- Parse a binder as it would appear in a top level declaration

546--

551--

547parseBinderNoParens :: TokenParser Binder

552parseBinderNoParens :: TokenParser Binder

548−parseBinderNoParens = P.choice (map P.try

553+parseBinderNoParens = P.choice

549− [ parseNullBinder

554+ [ parseNullBinder

550− , parseCharBinder

555+ , parseCharBinder

551− , parseStringBinder

556+ , parseStringBinder

552− , parseBooleanBinder

557+ , parseBooleanBinder

553− , parseNumberBinder

558+ , parseNumberBinder

554− , parseNamedBinder

559+ , parseVarOrNamedBinder

555− , parseVarBinder

556− , parseNullaryConstructorBinder

560+ , parseNullaryConstructorBinder

557− , parseObjectBinder

561+ , parseObjectBinder

558− , parseArrayBinder

562+ , parseArrayBinder

559− , parens parseBinder ]) P.<?> "binder"

563+ , parens parseBinder

564+ ] P.<?> "binder"

560

565

561-- |

566-- |

562-- Parse a guard

567-- Parse a guard

src/Language/PureScript/Parser/Kinds.hs+4−3

@@ -33,10 +33,11 @@ parseBang :: TokenParser Kind

33parseBang = const Bang <$> symbol' "!"

35parseTypeAtom :: TokenParser Kind

36−parseTypeAtom = indented *> P.choice (map P.try

36+parseTypeAtom = indented *> P.choice

37 [ parseStar

38 , parseBang

39− , parens parseKind ])

39+ , parens parseKind

40+ ]

40-- |

41-- |

41-- Parse a kind

42-- Parse a kind

42--

43--

@@ -44,4 +45,4 @@ parseKind :: TokenParser Kind

44parseKind = P.buildExpressionParser operators parseTypeAtom P.<?> "kind"

45parseKind = P.buildExpressionParser operators parseTypeAtom P.<?> "kind"

45 where

46 where

46 operators = [ [ P.Prefix (symbol' "#" >> return Row) ]

47 operators = [ [ P.Prefix (symbol' "#" >> return Row) ]

47− , [ P.Infix (P.try rarrow >> return FunKind) P.AssocRight ] ]

48+ , [ P.Infix (rarrow >> return FunKind) P.AssocRight ] ]

src/Language/PureScript/Parser/Types.hs+12−10

@@ -18,7 +18,7 @@ import qualified Text.Parsec as P

18import qualified Text.Parsec.Expr as P

20parseFunction :: TokenParser Type

21−parseFunction = parens $ rarrow >> return tyFunction

21+parseFunction = parens rarrow >> return tyFunction

23parseObject :: TokenParser Type

24parseObject = braces $ TypeApp tyObject <$> parseRow

@@ -36,24 +36,25 @@ parseTypeConstructor :: TokenParser Type

36parseTypeConstructor = TypeConstructor <$> parseQualified properName

38parseForAll :: TokenParser Type

39−parseForAll = mkForAll <$> (P.try (reserved "forall") *> P.many1 (indented *> identifier) <* indented <* dot)

39+parseForAll = mkForAll <$> (reserved "forall" *> P.many1 (indented *> identifier) <* indented <* dot)

40 <*> parseType

42-- |

43-- Parse a type as it appears in e.g. a data constructor

44--

45parseTypeAtom :: TokenParser Type

46−parseTypeAtom = indented *> P.choice (map P.try

46+parseTypeAtom = indented *> P.choice

47− [ parseConstrainedType

47+ [ P.try parseConstrainedType

48− , parseFunction

48+ , P.try parseFunction

49 , parseObject

50 , parseTypeWildcard

51+ , parseForAll

51 , parseTypeVariable

52 , parseTypeVariable

52 , parseTypeConstructor

53 , parseTypeConstructor

53− , parseForAll

54+ -- This try is needed due to some unfortunate ambiguities between rows and kinded types

54− , parens parseRow

55+ , P.try (parens parseRow)

55 , parens parsePolyType

56 , parens parsePolyType

56− ])

57+ ]

58parseConstrainedType :: TokenParser Type

59parseConstrainedType :: TokenParser Type

59parseConstrainedType = do

60parseConstrainedType = do

@@ -74,8 +75,9 @@ parseAnyType :: TokenParser Type

74parseAnyType = P.buildExpressionParser operators (buildPostfixParser postfixTable parseTypeAtom) P.<?> "type"

75parseAnyType = P.buildExpressionParser operators (buildPostfixParser postfixTable parseTypeAtom) P.<?> "type"

75 where

76 where

76 operators = [ [ P.Infix (return TypeApp) P.AssocLeft ]

77 operators = [ [ P.Infix (return TypeApp) P.AssocLeft ]

77− , [ P.Infix (rarrow >> return function) P.AssocRight ] ]

78+ , [ P.Infix (rarrow >> return function) P.AssocRight ]

79+ ]

78− postfixTable = [ \t -> KindedType t <$> (P.try (indented *> doubleColon) *> parseKind)

80+ postfixTable = [ \t -> KindedType t <$> (indented *> doubleColon *> parseKind)

79 ]

81 ]

81-- |

83-- |