mirror of
https://github.com/github/semantic.git
synced 2024-12-27 17:05:33 +03:00
Move the HasCallStack constraint into the Assignment type synonym.
This commit is contained in:
Rob Rix
parent
d01f188d4d
commit
89c9e546eb
@ -1,4 +1,4 @@
|
||||
{-# LANGUAGE DataKinds, DeriveAnyClass #-}
|
||||
{-# LANGUAGE DataKinds, DeriveAnyClass, RankNTypes #-}
|
||||
module Language.Markdown.Syntax
|
||||
( assignment
|
||||
, Syntax
|
||||
@ -50,7 +50,7 @@ instance Show1 Paragraph where liftShowsPrec = genericLiftShowsPrec
|
||||
|
||||
type Error = Assignment.Error Grammar
|
||||
type Term = Term.Term (Union Syntax) (Record Location)
|
||||
type Assignment = Assignment.Assignment CMark.NodeType Grammar Term
|
||||
type Assignment = HasCallStack => Assignment.Assignment CMark.NodeType Grammar Term
|
||||
|
||||
assignment :: HasCallStack => Assignment
|
||||
assignment :: Assignment
|
||||
assignment = empty
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
{-# LANGUAGE DataKinds, DeriveAnyClass, GeneralizedNewtypeDeriving, TypeOperators #-}
|
||||
{-# LANGUAGE DataKinds, DeriveAnyClass, RankNTypes, TypeOperators #-}
|
||||
module Language.Python.Syntax
|
||||
( assignment
|
||||
, Syntax
|
||||
@ -65,7 +65,7 @@ type Syntax =
|
||||
|
||||
type Error = Assignment.Error Grammar
|
||||
type Term = Term.Term (Union Syntax) (Record Location)
|
||||
type Assignment = Assignment.Assignment (AST Grammar) Grammar Term
|
||||
type Assignment = HasCallStack => Assignment.Assignment (AST Grammar) Grammar Term
|
||||
|
||||
-- | Ellipsis (used in splice expressions and alternatively can be used as a fill in expression, like `undefined` in Haskell)
|
||||
data Ellipsis a = Ellipsis
|
||||
@ -82,13 +82,13 @@ instance Eq1 Redirect where liftEq = genericLiftEq
|
||||
instance Show1 Redirect where liftShowsPrec = genericLiftShowsPrec
|
||||
|
||||
-- | Assignment from AST in Python's grammar onto a program in Python's syntax.
|
||||
assignment :: HasCallStack => Assignment
|
||||
assignment :: Assignment
|
||||
assignment = makeTerm <$> symbol Module <*> children (many declaration)
|
||||
|
||||
declaration :: HasCallStack => Assignment
|
||||
declaration :: Assignment
|
||||
declaration = handleError $ comment <|> statement <|> expression
|
||||
|
||||
statement :: HasCallStack => Assignment
|
||||
statement :: Assignment
|
||||
statement = assertStatement
|
||||
<|> assignment'
|
||||
<|> augmentedAssignment
|
||||
@ -101,10 +101,10 @@ statement = assertStatement
|
||||
<|> printStatement
|
||||
<|> returnStatement
|
||||
|
||||
expressionStatement :: HasCallStack => Assignment
|
||||
expressionStatement :: Assignment
|
||||
expressionStatement = symbol ExpressionStatement *> children expression
|
||||
|
||||
expression :: HasCallStack => Assignment
|
||||
expression :: Assignment
|
||||
expression = await
|
||||
<|> binaryOperator
|
||||
<|> booleanOperator
|
||||
@ -124,13 +124,13 @@ expression = await
|
||||
<|> tuple
|
||||
<|> unaryOperator
|
||||
|
||||
dottedName :: HasCallStack => Assignment
|
||||
dottedName :: Assignment
|
||||
dottedName = makeTerm <$> symbol DottedName <*> children (Expression.ScopeResolution <$> many expression)
|
||||
|
||||
ellipsis :: HasCallStack => Assignment
|
||||
ellipsis :: Assignment
|
||||
ellipsis = makeTerm <$> symbol Grammar.Ellipsis <*> (Language.Python.Syntax.Ellipsis <$ source)
|
||||
|
||||
comparisonOperator :: HasCallStack => Assignment
|
||||
comparisonOperator :: Assignment
|
||||
comparisonOperator = symbol ComparisonOperator >>= \ loc -> children (expression >>= \ lexpression -> makeComparison loc lexpression)
|
||||
where
|
||||
makeComparison loc lexpression = makeTerm loc <$ symbol AnonLAngle <*> (Expression.LessThan lexpression <$> expression)
|
||||
@ -145,26 +145,26 @@ comparisonOperator = symbol ComparisonOperator >>= \ loc -> children (expression
|
||||
<|> symbol AnonIs *> source *> (symbol AnonNot *> (makeTerm loc <$> Expression.Not <$> (makeTerm <$> location <*> (Expression.Equal lexpression <$> expression)))
|
||||
<|> (makeTerm loc <$> Expression.Equal lexpression <$> expression))
|
||||
|
||||
notOperator :: HasCallStack => Assignment
|
||||
notOperator :: Assignment
|
||||
notOperator = makeTerm <$> symbol NotOperator <*> children (Expression.Not <$> expression)
|
||||
|
||||
keywordIdentifier :: HasCallStack => Assignment
|
||||
keywordIdentifier :: Assignment
|
||||
keywordIdentifier = makeTerm <$> symbol KeywordIdentifier <*> children (Syntax.Identifier <$> source)
|
||||
|
||||
tuple :: HasCallStack => Assignment
|
||||
tuple :: Assignment
|
||||
tuple = makeTerm <$> symbol Tuple <*> children (Literal.Tuple <$> (many expression))
|
||||
|
||||
-- TODO: Consider flattening single element lists
|
||||
expressionList :: HasCallStack => Assignment
|
||||
expressionList :: Assignment
|
||||
expressionList = makeTerm <$> symbol ExpressionList <*> children (many expression)
|
||||
|
||||
unaryOperator :: HasCallStack => Assignment
|
||||
unaryOperator :: Assignment
|
||||
unaryOperator = symbol UnaryOperator >>= \ location -> arithmetic location <|> bitwise location <|> children ( symbol AnonPlus *> expression )
|
||||
where
|
||||
arithmetic location = makeTerm location . Expression.Negate <$> children ( symbol AnonMinus *> expression )
|
||||
bitwise location = makeTerm location . Expression.Complement <$> children ( symbol AnonTilde *> expression )
|
||||
|
||||
binaryOperator :: HasCallStack => Assignment
|
||||
binaryOperator :: Assignment
|
||||
binaryOperator = symbol BinaryOperator >>= \ location -> children (expression >>= \ lexpression ->
|
||||
makeTerm location <$> arithmetic lexpression
|
||||
<|> makeTerm location <$> bitwise lexpression)
|
||||
@ -182,17 +182,17 @@ binaryOperator = symbol BinaryOperator >>= \ location -> children (expression >>
|
||||
<|> symbol AnonLAngleLAngle *> (Expression.LShift lexpression <$> expression)
|
||||
<|> symbol AnonRAngleRAngle *> (Expression.RShift lexpression <$> expression)
|
||||
|
||||
booleanOperator :: HasCallStack => Assignment
|
||||
booleanOperator :: Assignment
|
||||
booleanOperator = makeTerm <$> symbol BooleanOperator <*> children ( expression >>= booleanOperator' )
|
||||
where
|
||||
booleanOperator' lexpression = symbol AnonAnd *> (Expression.And lexpression <$> expression)
|
||||
<|> symbol AnonOr *> (Expression.Or lexpression <$> expression)
|
||||
|
||||
assignment' :: HasCallStack => Assignment
|
||||
assignment' :: Assignment
|
||||
assignment' =
|
||||
makeTerm <$> symbol Assignment <*> children (Statement.Assignment <$> expressionList <*> rvalue)
|
||||
|
||||
augmentedAssignment :: HasCallStack => Assignment
|
||||
augmentedAssignment :: Assignment
|
||||
augmentedAssignment = makeTerm <$> symbol AugmentedAssignment <*> children (expressionList >>= \ lvalue -> Statement.Assignment lvalue <$>
|
||||
(makeTerm <$> symbol AnonPlusEqual <*> (Expression.Plus lvalue <$> rvalue)
|
||||
<|> makeTerm <$> symbol AnonMinusEqual <*> (Expression.Minus lvalue <$> rvalue)
|
||||
@ -207,56 +207,56 @@ augmentedAssignment = makeTerm <$> symbol AugmentedAssignment <*> children (expr
|
||||
<|> makeTerm <$> symbol AnonLAngleLAngleEqual <*> (Expression.LShift lvalue <$> rvalue)
|
||||
<|> makeTerm <$> symbol AnonCaretEqual <*> (Expression.BXOr lvalue <$> rvalue)))
|
||||
|
||||
yield :: HasCallStack => Assignment
|
||||
yield :: Assignment
|
||||
yield = makeTerm <$> symbol Yield <*> (Statement.Yield <$> children ( expression <|> expressionList <|> emptyTerm ))
|
||||
|
||||
rvalue :: HasCallStack => Assignment
|
||||
rvalue :: Assignment
|
||||
rvalue = expressionList <|> assignment' <|> augmentedAssignment <|> yield
|
||||
|
||||
identifier :: HasCallStack => Assignment
|
||||
identifier :: Assignment
|
||||
identifier = makeTerm <$> symbol Identifier <*> (Syntax.Identifier <$> source)
|
||||
|
||||
literal :: HasCallStack => Assignment
|
||||
literal :: Assignment
|
||||
literal = string <|> integer <|> float <|> boolean <|> none <|> concatenatedString <|> list' <|> dictionary <|> set
|
||||
|
||||
set :: HasCallStack => Assignment
|
||||
set :: Assignment
|
||||
set = makeTerm <$> symbol Set <*> children (Literal.Set <$> many expression)
|
||||
|
||||
dictionary :: HasCallStack => Assignment
|
||||
dictionary :: Assignment
|
||||
dictionary = makeTerm <$> symbol Dictionary <*> children (Literal.Hash <$> many pairs)
|
||||
where pairs = makeTerm <$> symbol Pair <*> children (Literal.KeyValue <$> expression <*> expression)
|
||||
|
||||
list' :: HasCallStack => Assignment
|
||||
list' :: Assignment
|
||||
list' = makeTerm <$> symbol List <*> children (Literal.Array <$> many expression)
|
||||
|
||||
-- TODO: Wrap `Literal.TextElement` with a `Literal.String`
|
||||
string :: HasCallStack => Assignment
|
||||
string :: Assignment
|
||||
string = makeTerm <$> symbol String <*> (Literal.TextElement <$> source)
|
||||
|
||||
concatenatedString :: HasCallStack => Assignment
|
||||
concatenatedString :: Assignment
|
||||
concatenatedString = makeTerm <$> symbol ConcatenatedString <*> children (Literal.TextElement . mconcat <$> many (symbol String *> source))
|
||||
|
||||
float :: HasCallStack => Assignment
|
||||
float :: Assignment
|
||||
float = makeTerm <$> symbol Float <*> (Literal.Float <$> source)
|
||||
|
||||
integer :: HasCallStack => Assignment
|
||||
integer :: Assignment
|
||||
integer = makeTerm <$> symbol Integer <*> (Literal.Integer <$> source)
|
||||
|
||||
comment :: HasCallStack => Assignment
|
||||
comment :: Assignment
|
||||
comment = makeTerm <$> symbol Comment <*> (Comment.Comment <$> source)
|
||||
|
||||
-- TODO Possibly match against children for dotted name and identifiers
|
||||
import' :: HasCallStack => Assignment
|
||||
import' :: Assignment
|
||||
import' = makeTerm <$> symbol ImportStatement <*> children (Declaration.Import <$> many expression)
|
||||
|
||||
-- TODO Possibly match against children nodes
|
||||
importFrom :: HasCallStack => Assignment
|
||||
importFrom :: Assignment
|
||||
importFrom = makeTerm <$> symbol ImportFromStatement <*> children (Declaration.Import <$> many expression)
|
||||
|
||||
assertStatement :: HasCallStack => Assignment
|
||||
assertStatement :: Assignment
|
||||
assertStatement = makeTerm <$ symbol AssertStatement <*> location <*> children (Expression.Call <$> (makeTerm <$> symbol AnonAssert <*> (Syntax.Identifier <$> source)) <*> many expression)
|
||||
|
||||
printStatement :: HasCallStack => Assignment
|
||||
printStatement :: Assignment
|
||||
printStatement = do
|
||||
location <- symbol PrintStatement
|
||||
children $ do
|
||||
@ -267,47 +267,47 @@ printStatement = do
|
||||
redirectCallTerm location keyword = makeTerm location <$ symbol Chevron <*> (flip Redirect <$> children expression <*> printCallTerm location keyword)
|
||||
printCallTerm location keyword = makeTerm location . Expression.Call keyword <$> many expression
|
||||
|
||||
globalStatement :: HasCallStack => Assignment
|
||||
globalStatement :: Assignment
|
||||
globalStatement = makeTerm <$> symbol GlobalStatement <*> children (Expression.Call <$> (makeTerm <$> symbol AnonGlobal <*> (Syntax.Identifier <$> source)) <*> many identifier)
|
||||
|
||||
await :: HasCallStack => Assignment
|
||||
await :: Assignment
|
||||
await = makeTerm <$> symbol Await <*> children (Expression.Call <$> (makeTerm <$> symbol AnonAwait <*> (Syntax.Identifier <$> source)) <*> many expression)
|
||||
|
||||
returnStatement :: HasCallStack => Assignment
|
||||
returnStatement :: Assignment
|
||||
returnStatement = makeTerm <$> symbol ReturnStatement <*> (Statement.Return <$> children expressionList)
|
||||
|
||||
|
||||
ifStatement :: HasCallStack => Assignment
|
||||
ifStatement :: Assignment
|
||||
ifStatement = makeTerm <$> symbol IfStatement <*> children (Statement.If <$> expression <*> statement <*> (flip (foldr makeElif) <$> many elifClause <*> optionalElse))
|
||||
where elseClause = symbol ElseClause *> children statement
|
||||
elifClause = (,) <$ symbol ElifClause <*> location <*> children (Statement.If <$> expression <*> statement)
|
||||
optionalElse = fromMaybe <$> emptyTerm <*> optional elseClause
|
||||
makeElif (loc, makeIf) rest = makeTerm loc (makeIf rest)
|
||||
|
||||
memberAccess :: HasCallStack => Assignment
|
||||
memberAccess :: Assignment
|
||||
memberAccess = makeTerm <$> symbol Attribute <*> children (Expression.MemberAccess <$> expression <*> expression)
|
||||
|
||||
subscript :: HasCallStack => Assignment
|
||||
subscript :: Assignment
|
||||
subscript = makeTerm <$> symbol Subscript <*> children (Expression.Subscript <$> expression <*> many expression)
|
||||
|
||||
call :: HasCallStack => Assignment
|
||||
call :: Assignment
|
||||
call = makeTerm <$> symbol Call <*> children (Expression.Call <$> identifier <*> (symbol ArgumentList *> children (many expression)
|
||||
<|> some comprehension))
|
||||
|
||||
boolean :: HasCallStack => Assignment
|
||||
boolean :: Assignment
|
||||
boolean = makeTerm <$> symbol Grammar.True <*> (Literal.true <$ source)
|
||||
<|> makeTerm <$> symbol Grammar.False <*> (Literal.false <$ source)
|
||||
|
||||
none :: HasCallStack => Assignment
|
||||
none :: Assignment
|
||||
none = makeTerm <$> symbol None <*> (Literal.Null <$ source)
|
||||
|
||||
lambda :: HasCallStack => Assignment
|
||||
lambda :: Assignment
|
||||
lambda = makeTerm <$> symbol Lambda <*> children (Declaration.Function <$> lambdaIdentifier <*> lambdaParameters <*> lambdaBody)
|
||||
where lambdaIdentifier = makeTerm <$> symbol AnonLambda <*> (Syntax.Identifier <$> source)
|
||||
lambdaParameters = many identifier
|
||||
lambdaBody = expression
|
||||
|
||||
comprehension :: HasCallStack => Assignment
|
||||
comprehension :: Assignment
|
||||
comprehension = makeTerm <$> symbol GeneratorExpression <*> children (comprehensionDeclaration expression)
|
||||
<|> makeTerm <$> symbol ListComprehension <*> children (comprehensionDeclaration expression)
|
||||
<|> makeTerm <$> symbol SetComprehension <*> children (comprehensionDeclaration expression)
|
||||
@ -318,16 +318,16 @@ comprehension = makeTerm <$> symbol GeneratorExpression <*> children (comprehen
|
||||
makeComprehension (loc, makeRest) rest = makeTerm loc (makeRest rest)
|
||||
nestedComprehension = (,) <$> location <*> (Declaration.Comprehension <$> expression <* symbol Variables <*> children (many expression))
|
||||
|
||||
conditionalExpression :: HasCallStack => Assignment
|
||||
conditionalExpression :: Assignment
|
||||
conditionalExpression = makeTerm <$> symbol ConditionalExpression <*> children (expression >>= \ thenBranch -> expression >>= \ conditional -> Statement.If conditional thenBranch <$> (expression <|> emptyTerm))
|
||||
|
||||
makeTerm :: (HasCallStack, InUnion fs f) => a -> f (Term.Term (Union fs) a) -> Term.Term (Union fs) a
|
||||
makeTerm a f = cofree (a :< inj f)
|
||||
|
||||
emptyTerm :: HasCallStack => Assignment
|
||||
emptyTerm :: Assignment
|
||||
emptyTerm = makeTerm <$> location <*> pure Syntax.Empty
|
||||
|
||||
handleError :: HasCallStack => Assignment -> Assignment
|
||||
handleError :: Assignment -> Assignment
|
||||
handleError = flip catchError $ \ error -> case errorCause error of
|
||||
UnexpectedEndOfInput _ -> throwError error
|
||||
_ -> makeTerm <$> location <*> (Syntax.Error error <$ source)
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
{-# LANGUAGE DataKinds #-}
|
||||
{-# LANGUAGE DataKinds, RankNTypes #-}
|
||||
module Language.Ruby.Syntax
|
||||
( assignment
|
||||
, Syntax
|
||||
@ -55,34 +55,34 @@ type Syntax =
|
||||
|
||||
type Error = Assignment.Error Grammar
|
||||
type Term = Term.Term (Union Syntax) (Record Location)
|
||||
type Assignment = Assignment.Assignment (AST Grammar) Grammar Term
|
||||
type Assignment = HasCallStack => Assignment.Assignment (AST Grammar) Grammar Term
|
||||
|
||||
|
||||
-- | Assignment from AST in Ruby’s grammar onto a program in Ruby’s syntax.
|
||||
assignment :: HasCallStack => Assignment
|
||||
assignment :: Assignment
|
||||
assignment = makeTerm <$> symbol Program <*> children (many declaration)
|
||||
|
||||
declaration :: HasCallStack => Assignment
|
||||
declaration :: Assignment
|
||||
declaration = handleError $ comment <|> class' <|> method
|
||||
|
||||
class' :: HasCallStack => Assignment
|
||||
class' :: Assignment
|
||||
class' = makeTerm <$> symbol Class <*> children (Declaration.Class <$> (constant <|> scopeResolution) <*> (superclass <|> pure []) <*> many declaration)
|
||||
where superclass = pure <$ symbol Superclass <*> children constant
|
||||
scopeResolution = symbol ScopeResolution *> children (constant <|> identifier)
|
||||
|
||||
constant :: HasCallStack => Assignment
|
||||
constant :: Assignment
|
||||
constant = makeTerm <$> symbol Constant <*> (Syntax.Identifier <$> source)
|
||||
|
||||
identifier :: HasCallStack => Assignment
|
||||
identifier :: Assignment
|
||||
identifier = makeTerm <$> symbol Identifier <*> (Syntax.Identifier <$> source)
|
||||
|
||||
method :: HasCallStack => Assignment
|
||||
method :: Assignment
|
||||
method = makeTerm <$> symbol Method <*> children (Declaration.Method <$> identifier <*> pure [] <*> statements)
|
||||
|
||||
statements :: HasCallStack => Assignment
|
||||
statements :: Assignment
|
||||
statements = makeTerm <$> location <*> many statement
|
||||
|
||||
statement :: HasCallStack => Assignment
|
||||
statement :: Assignment
|
||||
statement = handleError
|
||||
$ exit Statement.Return Return
|
||||
<|> exit Statement.Yield Yield
|
||||
@ -97,36 +97,36 @@ statement = handleError
|
||||
<|> assignment'
|
||||
where exit construct sym = makeTerm <$> symbol sym <*> children ((construct .) . fromMaybe <$> emptyTerm <*> optional (symbol ArgumentList *> children statement))
|
||||
|
||||
lvalue :: HasCallStack => Assignment
|
||||
lvalue :: Assignment
|
||||
lvalue = identifier
|
||||
|
||||
expression :: HasCallStack => Assignment
|
||||
expression :: Assignment
|
||||
expression = identifier <|> statement
|
||||
|
||||
comment :: HasCallStack => Assignment
|
||||
comment :: Assignment
|
||||
comment = makeTerm <$> symbol Comment <*> (Comment.Comment <$> source)
|
||||
|
||||
if' :: HasCallStack => Assignment
|
||||
if' :: Assignment
|
||||
if' = ifElsif If
|
||||
<|> makeTerm <$> symbol IfModifier <*> children (flip Statement.If <$> statement <*> statement <*> (makeTerm <$> location <*> pure Syntax.Empty))
|
||||
where ifElsif s = makeTerm <$> symbol s <*> children (Statement.If <$> statement <*> statements <*> (fromMaybe <$> emptyTerm <*> optional (ifElsif Elsif <|> makeTerm <$> symbol Else <*> children (many statement))))
|
||||
|
||||
unless :: HasCallStack => Assignment
|
||||
unless :: Assignment
|
||||
unless = makeTerm <$> symbol Unless <*> children (Statement.If <$> invert statement <*> statements <*> (fromMaybe <$> emptyTerm <*> optional (makeTerm <$> symbol Else <*> children (many statement))))
|
||||
<|> makeTerm <$> symbol UnlessModifier <*> children (flip Statement.If <$> statement <*> invert statement <*> (makeTerm <$> location <*> pure Syntax.Empty))
|
||||
|
||||
while :: HasCallStack => Assignment
|
||||
while :: Assignment
|
||||
while = makeTerm <$> symbol While <*> children (Statement.While <$> statement <*> statements)
|
||||
<|> makeTerm <$> symbol WhileModifier <*> children (flip Statement.While <$> statement <*> statement)
|
||||
|
||||
until :: HasCallStack => Assignment
|
||||
until :: Assignment
|
||||
until = makeTerm <$> symbol Until <*> children (Statement.While <$> invert statement <*> statements)
|
||||
<|> makeTerm <$> symbol UntilModifier <*> children (flip Statement.While <$> statement <*> invert statement)
|
||||
|
||||
for :: HasCallStack => Assignment
|
||||
for :: Assignment
|
||||
for = makeTerm <$> symbol For <*> children (Statement.ForEach <$> identifier <*> statement <*> statements)
|
||||
|
||||
assignment' :: HasCallStack => Assignment
|
||||
assignment' :: Assignment
|
||||
assignment'
|
||||
= makeTerm <$> symbol Assignment <*> children (Statement.Assignment <$> lvalue <*> expression)
|
||||
<|> makeTerm <$> symbol OperatorAssignment <*> children (lvalue >>= \ var -> Statement.Assignment var <$>
|
||||
@ -144,7 +144,7 @@ assignment'
|
||||
<|> makeTerm <$> symbol AnonLAngleLAngleEqual <*> (Expression.LShift var <$> expression)
|
||||
<|> makeTerm <$> symbol AnonCaretEqual <*> (Expression.BXOr var <$> expression)))
|
||||
|
||||
literal :: HasCallStack => Assignment
|
||||
literal :: Assignment
|
||||
literal = makeTerm <$> symbol Grammar.True <*> (Literal.true <$ source)
|
||||
<|> makeTerm <$> symbol Grammar.False <*> (Literal.false <$ source)
|
||||
<|> makeTerm <$> symbol Grammar.Integer <*> (Literal.Integer <$> source)
|
||||
@ -157,10 +157,10 @@ invert term = makeTerm <$> location <*> fmap Expression.Not term
|
||||
makeTerm :: (InUnion fs f, HasCallStack) => a -> f (Term.Term (Union fs) a) -> Term.Term (Union fs) a
|
||||
makeTerm a f = cofree $ a :< inj f
|
||||
|
||||
emptyTerm :: HasCallStack => Assignment
|
||||
emptyTerm :: Assignment
|
||||
emptyTerm = makeTerm <$> location <*> pure Syntax.Empty
|
||||
|
||||
handleError :: HasCallStack => Assignment -> Assignment
|
||||
handleError :: Assignment -> Assignment
|
||||
handleError = flip catchError $ \ error -> case errorCause error of
|
||||
UnexpectedEndOfInput _ -> throwError error
|
||||
_ -> makeTerm <$> location <*> (Syntax.Error error <$ source)
|
||||
|
||||
Loading…
Reference in New Issue
Block a user