{-# LANGUAGE RankNTypes, BangPatterns, MultiParamTypeClasses, FunctionalDependencies, FlexibleInstances, UndecidableInstances, TypeFamilies, CPP #-}
{-# OPTIONS_GHC -funfolding-creation-threshold=10000 -funfolding-use-threshold=10000 #-}
module Jukebox.TPTP.Parsec where

import Control.Applicative
import Control.Monad
import Data.List
import Control.Monad.Fail

-- Parser type and monad instances

newtype Parsec a b = Parsec
  { Parsec a b
-> forall c.
   (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c
runParsec :: forall c.
                 (b -> Reply a c -> a -> Reply a c) -- ok: success
              -> Reply a c -- err: backtracking failure
              -> a -> Reply a c }

type Reply a b = [String] -> Result (Position a) b

data Result a b = Ok a b | Error a String | Expected a [String]

{-# INLINE parseError #-}
parseError :: [String] -> Parsec a b
parseError :: [String] -> Parsec a b
parseError [String]
e = (forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\b -> Reply a c -> a -> Reply a c
_ok Reply a c
err a
_inp [String]
exp -> Reply a c
err ([String]
e [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
exp))

{-# INLINE fatalError #-}
fatalError :: Stream a c => String -> Parsec a b
fatalError :: String -> Parsec a b
fatalError String
e = (forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\b -> Reply a c -> a -> Reply a c
_ok Reply a c
_err a
inp [String]
_ -> Position a -> String -> Result (Position a) c
forall a b. a -> String -> Result a b
Error (a -> Position a
forall a b. Stream a b => a -> Position a
position a
inp) String
e)

instance Functor (Parsec a) where
  {-# INLINE fmap #-}
  fmap :: (a -> b) -> Parsec a a -> Parsec a b
fmap a -> b
f Parsec a a
x = Parsec a a
x Parsec a a -> (a -> Parsec a b) -> Parsec a b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= b -> Parsec a b
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> Parsec a b) -> (a -> b) -> a -> Parsec a b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f

instance Monad (Parsec a) where
  {-# INLINE return #-}
  return :: a -> Parsec a a
return a
x = (forall c.
 (a -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a a
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\a -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp [String]
exp -> a -> Reply a c -> a -> Reply a c
ok a
x Reply a c
err a
inp [String]
exp)
  {-# INLINE (>>=) #-}
  Parsec a a
x >>= :: Parsec a a -> (a -> Parsec a b) -> Parsec a b
>>= a -> Parsec a b
f = (forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\b -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp [String]
exp  -> Parsec a a
-> (a -> Reply a c -> a -> Reply a c)
-> Reply a c
-> a
-> Reply a c
forall a b.
Parsec a b
-> forall c.
   (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c
runParsec Parsec a a
x (\a
y Reply a c
err a
inp [String]
exp -> Parsec a b
-> (b -> Reply a c -> a -> Reply a c)
-> Reply a c
-> a
-> Reply a c
forall a b.
Parsec a b
-> forall c.
   (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c
runParsec (a -> Parsec a b
f a
y) b -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp [String]
exp) Reply a c
err a
inp [String]
exp)

#if __GLASGOW_HASKELL__ < 808
  {-# INLINE fail #-}
  fail _ = parseError []
#endif

instance MonadFail (Parsec a) where
  {-# INLINE fail #-}
  fail :: String -> Parsec a a
fail String
_ = [String] -> Parsec a a
forall a b. [String] -> Parsec a b
parseError []

instance MonadPlus (Parsec a) where
  {-# INLINE mzero #-}
  mzero :: Parsec a a
mzero = (forall c.
 (a -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a a
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\a -> Reply a c -> a -> Reply a c
_ok Reply a c
err a
_inp [String]
exp -> Reply a c
err [String]
exp)
  {-# INLINE mplus #-}
  Parsec a a
m1 mplus :: Parsec a a -> Parsec a a -> Parsec a a
`mplus` Parsec a a
m2 = (forall c.
 (a -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a a
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\a -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp [String]
exp ->
    Parsec a a
-> (a -> Reply a c -> a -> Reply a c)
-> Reply a c
-> a
-> Reply a c
forall a b.
Parsec a b
-> forall c.
   (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c
runParsec Parsec a a
m1 a -> Reply a c -> a -> Reply a c
ok (\[String]
exp -> Parsec a a
-> (a -> Reply a c -> a -> Reply a c)
-> Reply a c
-> a
-> Reply a c
forall a b.
Parsec a b
-> forall c.
   (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c
runParsec Parsec a a
m2 a -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp [String]
exp) a
inp [String]
exp)

instance Applicative (Parsec a) where
  {-# INLINE pure #-}
  pure :: a -> Parsec a a
pure = a -> Parsec a a
forall (m :: * -> *) a. Monad m => a -> m a
return
  {-# INLINE (<*>) #-}
  Parsec a (a -> b)
f <*> :: Parsec a (a -> b) -> Parsec a a -> Parsec a b
<*> Parsec a a
x = do { a -> b
f' <- Parsec a (a -> b)
f; a
x' <- Parsec a a
x; b -> Parsec a b
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> b
f' a
x') }
  {-# INLINE (*>) #-}
  *> :: Parsec a a -> Parsec a b -> Parsec a b
(*>) = Parsec a a -> Parsec a b -> Parsec a b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
(>>)
  {-# INLINE (<*) #-}
  Parsec a a
x <* :: Parsec a a -> Parsec a b -> Parsec a a
<* Parsec a b
y = do
    a
x' <- Parsec a a
x
    Parsec a b
y
    a -> Parsec a a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x'

instance Alternative (Parsec a) where
  {-# INLINE empty #-}
  empty :: Parsec a a
empty = Parsec a a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
  {-# INLINE (<|>) #-}
  <|> :: Parsec a a -> Parsec a a -> Parsec a a
(<|>) = Parsec a a -> Parsec a a -> Parsec a a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus
  {-# INLINE some #-}
  some :: Parsec a a -> Parsec a [a]
some Parsec a a
p = do { a
x <- Parsec a a -> Parsec a a
forall a b. Parsec a b -> Parsec a b
nonempty Parsec a a
p; [a]
xs <- Parsec a a -> Parsec a [a]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many Parsec a a
p; [a] -> Parsec a [a]
forall (m :: * -> *) a. Monad m => a -> m a
return (a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
xs) }
  {-# INLINE many #-}
  many :: Parsec a a -> Parsec a [a]
many Parsec a a
p = Parsec a [a]
p' where p' :: Parsec a [a]
p' = (a -> [a] -> [a]) -> Parsec a a -> Parsec a [a] -> Parsec a [a]
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (:) (Parsec a a -> Parsec a a
forall a b. Parsec a b -> Parsec a b
nonempty Parsec a a
p) Parsec a [a]
p' Parsec a [a] -> Parsec a [a] -> Parsec a [a]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [a] -> Parsec a [a]
forall (m :: * -> *) a. Monad m => a -> m a
return []
  -- Stack overflow-avoiding version:
  -- many p = liftM reverse (p' [])
  --   where p' !xs = do { x <- nonempty p; p' (x:xs) } `mplus` return xs

-- Basic combinators

{-# INLINE nonempty #-}
nonempty :: Parsec a b -> Parsec a b
nonempty :: Parsec a b -> Parsec a b
nonempty Parsec a b
p = Parsec a b
p

{-# INLINE skipSome #-}
skipSome :: Parsec a b -> Parsec a ()
skipSome :: Parsec a b -> Parsec a ()
skipSome Parsec a b
p = Parsec a ()
p' where p' :: Parsec a ()
p' = Parsec a b -> Parsec a b
forall a b. Parsec a b -> Parsec a b
nonempty Parsec a b
p Parsec a b -> Parsec a () -> Parsec a ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Parsec a ()
p' Parsec a () -> Parsec a () -> Parsec a ()
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` () -> Parsec a ()
forall (m :: * -> *) a. Monad m => a -> m a
return ())

{-# INLINE skipMany #-}
skipMany :: Parsec a b -> Parsec a ()
skipMany :: Parsec a b -> Parsec a ()
skipMany Parsec a b
p = Parsec a ()
p' where p' :: Parsec a ()
p' = (Parsec a b -> Parsec a b
forall a b. Parsec a b -> Parsec a b
nonempty Parsec a b
p Parsec a b -> Parsec a () -> Parsec a ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parsec a ()
p') Parsec a () -> Parsec a () -> Parsec a ()
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus` () -> Parsec a ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

{-# INLINE (<?>) #-}
infix 0 <?>
(<?>) :: Parsec a b -> String -> Parsec a b
Parsec a b
p <?> :: Parsec a b -> String -> Parsec a b
<?> String
text = (forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\b -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp [String]
exp ->
  Parsec a b
-> (b -> Reply a c -> a -> Reply a c)
-> Reply a c
-> a
-> Reply a c
forall a b.
Parsec a b
-> forall c.
   (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c
runParsec Parsec a b
p b -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp (String
textString -> [String] -> [String]
forall a. a -> [a] -> [a]
:[String]
exp))

{-# INLINE between #-}
between :: Parsec a b -> Parsec a c -> Parsec a d -> Parsec a d
between :: Parsec a b -> Parsec a c -> Parsec a d -> Parsec a d
between Parsec a b
p Parsec a c
q Parsec a d
r = Parsec a b
p Parsec a b -> Parsec a d -> Parsec a d
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Parsec a d
r Parsec a d -> Parsec a c -> Parsec a d
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Parsec a c
q

{-# INLINE sepBy1 #-}
sepBy1 :: Parsec a b -> Parsec a c -> Parsec a [b]
sepBy1 :: Parsec a b -> Parsec a c -> Parsec a [b]
sepBy1 Parsec a b
it Parsec a c
sep = (b -> [b] -> [b]) -> Parsec a b -> Parsec a [b] -> Parsec a [b]
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (:) Parsec a b
it (Parsec a b -> Parsec a [b]
forall (f :: * -> *) a. Alternative f => f a -> f [a]
many (Parsec a c
sep Parsec a c -> Parsec a b -> Parsec a b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Parsec a b
it))

-- Running the parser

run_ :: Stream a c => Parsec a b -> a -> Result (Position a) b
run_ :: Parsec a b -> a -> Result (Position a) b
run_ Parsec a b
p a
x = Parsec a b
-> (b -> Reply a b -> a -> Reply a b)
-> Reply a b
-> a
-> Reply a b
forall a b.
Parsec a b
-> forall c.
   (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c
runParsec Parsec a b
p b -> Reply a b -> a -> Reply a b
forall a b b p p.
Stream a b =>
b -> p -> a -> p -> Result (Position a) b
ok Reply a b
err a
x []
  where ok :: b -> p -> a -> p -> Result (Position a) b
ok b
x p
_ a
inp p
_ = Position a -> b -> Result (Position a) b
forall a b. a -> b -> Result a b
Ok (a -> Position a
forall a b. Stream a b => a -> Position a
position a
inp) b
x
        err :: Reply a b
err [String]
exp = Position a -> Reply a b
forall a b. a -> [String] -> Result a b
Expected (a -> Position a
forall a b. Stream a b => a -> Position a
position a
x) ([String] -> [String]
forall a. [a] -> [a]
reverse [String]
exp)

run :: Stream a c => (Position a -> [String]) -> Parsec a b -> a -> (Position a, Either [String] b)
run :: (Position a -> [String])
-> Parsec a b -> a -> (Position a, Either [String] b)
run Position a -> [String]
report Parsec a b
p a
ts =
  case Parsec a b -> a -> Result (Position a) b
forall a c b.
Stream a c =>
Parsec a b -> a -> Result (Position a) b
run_ Parsec a b
p a
ts of
    Ok Position a
ts' b
x -> (Position a
ts', b -> Either [String] b
forall a b. b -> Either a b
Right b
x)
    Error Position a
ts' String
e -> (Position a
ts', [String] -> Either [String] b
forall a b. a -> Either a b
Left [String
e])
    Expected Position a
ts' [String]
e -> (Position a
ts', [String] -> Either [String] b
forall a b. a -> Either a b
Left ([String] -> [String] -> [String]
expected (Position a -> [String]
report Position a
ts') [String]
e))

-- Reporting errors

expected :: [String] -> [String] -> [String]
expected :: [String] -> [String] -> [String]
expected [String]
unexpected [] = [String]
unexpected [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String
"Unknown error"]
expected [String]
unexpected [String]
expected =
  [String]
unexpected [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [ String
"Expected " String -> String -> String
forall a. [a] -> [a] -> [a]
++ [String] -> String
list [String]
expected ]
  where list :: [String] -> String
list [String
exp] = String
exp
        list [String]
exp = String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
", " ([String] -> [String]
forall a. [a] -> [a]
init [String]
exp) String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" or " String -> String -> String
forall a. [a] -> [a] -> [a]
++ [String] -> String
forall a. [a] -> a
last [String]
exp

-- Token streams

class Stream a b | a -> b where
  primToken :: a -> (a -> b -> c) -> c -> (String -> c) -> c
  type Position a
  position :: a -> Position a

{-# INLINE next #-}
next :: Stream a b => Parsec a b
next :: Parsec a b
next = (forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\b -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp [String]
exp ->
  a
-> (a -> b -> Result (Position a) c)
-> Result (Position a) c
-> (String -> Result (Position a) c)
-> Result (Position a) c
forall a b c.
Stream a b =>
a -> (a -> b -> c) -> c -> (String -> c) -> c
primToken a
inp (\a
inp' b
x -> b -> Reply a c -> a -> Reply a c
ok b
x Reply a c
err a
inp' [String]
exp) (Reply a c
err [String]
exp) (Position a -> String -> Result (Position a) c
forall a b. a -> String -> Result a b
Error (a -> Position a
forall a b. Stream a b => a -> Position a
position a
inp)))

{-# INLINE cut #-}
cut :: Stream a b => Parsec a ()
cut :: Parsec a ()
cut = (forall c.
 (() -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a ()
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\() -> Reply a c -> a -> Reply a c
ok Reply a c
_err a
inp [String]
_exp -> () -> Reply a c -> a -> Reply a c
ok () (Position a -> Reply a c
forall a b. a -> [String] -> Result a b
Expected (a -> Position a
forall a b. Stream a b => a -> Position a
position a
inp)) a
inp [])

{-# INLINE cut' #-}
cut' :: Stream a b => Parsec a c -> Parsec a c
cut' :: Parsec a c -> Parsec a c
cut' Parsec a c
p = (forall c.
 (c -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a c
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\c -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp [String]
exp -> Parsec a c
-> (c -> Reply a c -> a -> Reply a c)
-> Reply a c
-> a
-> Reply a c
forall a b.
Parsec a b
-> forall c.
   (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c
runParsec Parsec a c
p (\c
x Reply a c
_ a
inp' [String]
_ -> c -> Reply a c -> a -> Reply a c
ok c
x Reply a c
err a
inp' []) Reply a c
err a
inp [String]
exp)

{-# INLINE satisfy #-}
satisfy :: Stream a b => (b -> Bool) -> Parsec a b
satisfy :: (b -> Bool) -> Parsec a b
satisfy b -> Bool
p = do
  b
t <- Parsec a b
forall a b. Stream a b => Parsec a b
next
  Bool -> Parsec a ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (b -> Bool
p b
t)
  Parsec a ()
forall a b. Stream a b => Parsec a ()
cut
  b -> Parsec a b
forall (m :: * -> *) a. Monad m => a -> m a
return b
t

{-# INLINE eof #-}
eof :: Stream a b => Parsec a ()
eof :: Parsec a ()
eof = (forall c.
 (() -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a ()
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\() -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp [String]
exp ->
  a
-> (a -> b -> Result (Position a) c)
-> Result (Position a) c
-> (String -> Result (Position a) c)
-> Result (Position a) c
forall a b c.
Stream a b =>
a -> (a -> b -> c) -> c -> (String -> c) -> c
primToken a
inp (\a
_ b
_ -> Reply a c
err (String
"end of file"String -> [String] -> [String]
forall a. a -> [a] -> [a]
:[String]
exp)) (() -> Reply a c -> a -> Reply a c
ok () Reply a c
err a
inp [String]
exp) (Position a -> String -> Result (Position a) c
forall a b. a -> String -> Result a b
Error (a -> Position a
forall a b. Stream a b => a -> Position a
position a
inp)))

-- User state

data UserState state stream = UserState { UserState state stream -> state
userState :: !state, UserState state stream -> stream
userStream :: !stream }

instance Stream a b => Stream (UserState state a) b where
  {-# INLINE primToken #-}
  primToken :: UserState state a
-> (UserState state a -> b -> c) -> c -> (String -> c) -> c
primToken (UserState state
state a
stream) UserState state a -> b -> c
ok c
err =
    a -> (a -> b -> c) -> c -> (String -> c) -> c
forall a b c.
Stream a b =>
a -> (a -> b -> c) -> c -> (String -> c) -> c
primToken a
stream (UserState state a -> b -> c
ok (UserState state a -> b -> c)
-> (a -> UserState state a) -> a -> b -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. state -> a -> UserState state a
forall state stream. state -> stream -> UserState state stream
UserState state
state) c
err
  type Position (UserState state a) = UserState state a
  position :: UserState state a -> Position (UserState state a)
position = UserState state a -> Position (UserState state a)
forall a. a -> a
id

{-# INLINE getState #-}
getState :: Parsec (UserState state a) state
getState :: Parsec (UserState state a) state
getState = (forall c.
 (state
  -> Reply (UserState state a) c
  -> UserState state a
  -> Reply (UserState state a) c)
 -> Reply (UserState state a) c
 -> UserState state a
 -> Reply (UserState state a) c)
-> Parsec (UserState state a) state
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\state
-> Reply (UserState state a) c
-> UserState state a
-> Reply (UserState state a) c
ok Reply (UserState state a) c
err inp :: UserState state a
inp@UserState{userState = state} [String]
exp -> state
-> Reply (UserState state a) c
-> UserState state a
-> Reply (UserState state a) c
ok state
state Reply (UserState state a) c
err UserState state a
inp [String]
exp)

{-# INLINE putState #-}
putState :: state -> Parsec (UserState state a) ()
putState :: state -> Parsec (UserState state a) ()
putState state
state = (forall c.
 (()
  -> Reply (UserState state a) c
  -> UserState state a
  -> Reply (UserState state a) c)
 -> Reply (UserState state a) c
 -> UserState state a
 -> Reply (UserState state a) c)
-> Parsec (UserState state a) ()
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\()
-> Reply (UserState state a) c
-> UserState state a
-> Reply (UserState state a) c
ok Reply (UserState state a) c
err UserState{userStream = stream} [String]
exp -> ()
-> Reply (UserState state a) c
-> UserState state a
-> Reply (UserState state a) c
ok () Reply (UserState state a) c
err (state -> a -> UserState state a
forall state stream. state -> stream -> UserState state stream
UserState state
state a
stream) [String]
exp)

{-# INLINE getPosition #-}
getPosition :: Stream a b => Parsec a (Position a)
getPosition :: Parsec a (Position a)
getPosition = (forall c.
 (Position a -> Reply a c -> a -> Reply a c)
 -> Reply a c -> a -> Reply a c)
-> Parsec a (Position a)
forall a b.
(forall c.
 (b -> Reply a c -> a -> Reply a c) -> Reply a c -> a -> Reply a c)
-> Parsec a b
Parsec (\Position a -> Reply a c -> a -> Reply a c
ok Reply a c
err a
inp [String]
exp -> Position a -> Reply a c -> a -> Reply a c
ok (a -> Position a
forall a b. Stream a b => a -> Position a
position a
inp) Reply a c
err a
inp [String]
exp)