ReadableABC: False
ReuseUniqueNodes: True
Fusion: False
+ Module
+ Name: StdMaybe
+ Dir: {Application}/lib/iTasks-SDK/Dependencies/clean-platform/src/libraries/OS-Independent/Deprecated/StdLib
+ Compiler
+ NeverMemoryProfile: False
+ NeverTimeProfile: False
+ StrictnessAnalysis: True
+ ListTypes: StrictExportTypes
+ ListAttributes: True
+ Warnings: True
+ Verbose: True
+ ReadableABC: False
+ ReuseUniqueNodes: True
+ Fusion: False
Module
Name: System.OS
Dir: {Application}/lib/iTasks-SDK/Dependencies/Platform/OS-Linux-64
ReadableABC: False
ReuseUniqueNodes: True
Fusion: False
+ Module
+ Name: GenPrint
+ Dir: {Application}/lib/iTasks-SDK/Patches/Generics
+ Compiler
+ NeverMemoryProfile: False
+ NeverTimeProfile: False
+ StrictnessAnalysis: True
+ ListTypes: StrictExportTypes
+ ListAttributes: True
+ Warnings: True
+ Verbose: True
+ ReadableABC: False
+ ReuseUniqueNodes: True
+ Fusion: False
Module
Name: StdGeneric
Dir: {Application}/lib/iTasks-SDK/Patches/StdEnv
import Data.Func
from Data.List import intercalate, replicate, instance Functor []
from Text import class Text(concat), instance Text String
+import GenPrint
import yard
import lex
trans1 :: TokenValue a -> Parser Token a
trans1 t r = trans2 t $ const r
+derive gPrint TokenValue
derive gEq TokenValue
satTok :: TokenValue -> Parser Token Token
-satTok t = satisfy $ eq t
+satTok t = top >>= \tok=:(pos, tv) -> if (eq t tok) (return tok) (fail <?> (printToString t, pos))
where
eq (IdentToken _) (_, IdentToken _) = True
eq (NumberToken _) (_, NumberToken _) = True
from Control.Monad import class Monad
from Control.Applicative import class Applicative, class Alternative
-:: Error = ParseError | LexError String | Expected [String]
+:: Error = ParseError | LexError String | Expected [String] Int
:: Parser a b = Parser ([a] -> (Either Error b, [a]))
instance Functor (Parser a)
instance toString Error
runParser :: (Parser a b) [a] -> (Either Error b, [a])
+(<?>) :: (Parser a b) (String, Int) -> Parser a b
fail :: Parser a b
top :: Parser a a
satisfy :: (a -> Bool) -> Parser a a
import StdClass
import StdString
import StdList
+import StdInt
+from Data.List import intersperse
+from Text import instance Text String, class Text(concat)
import Data.Functor
import Data.Either
import Control.Monad
instance toString Error where
toString ParseError = "General parse error"
toString (LexError e) = "Lexer error: " +++ e
+ toString (Expected ts pos) = "Expected " +++ (concat $ intersperse ", " ts)
+ +++ " at position " +++ (toString pos)
instance + Error where
- (+) (Expected as) (Expected bs) = Expected (as++bs)
- (+) _ r = r
+ (+) (Expected as _) (Expected bs p) = Expected (as++bs) p
+ (+) _ r = r
runParser :: (Parser a b) [a] -> (Either Error b, [a])
runParser (Parser f) i = f i
(Right r, rest) = (Right r, rest)
(Left e2, rest) = (Left (e1+e2), rest)
-<?> :: (Parser a b) String -> Parser a b
-<?> p e = Parser \i -> case runParser p i of
- (Left e1, rest) = (Left (e1+(Expected [e])), rest)
+//Try the parser, if it fails decorate the error with Expected of the given String and position
+(<?>) :: (Parser a b) (String, Int) -> Parser a b
+(<?>) p (e,pos) = Parser \i -> case runParser p i of
+ (Left e1, rest) = let error = (e1+(Expected [e] pos)) in (Left error, rest)
(Right r, rest) = (Right r, rest)
fail :: Parser a b