{-# LANGUAGE MagicHash,
UnboxedTuples,
ScopedTypeVariables #-}
module UU.Parsing.Machine where
#if __GLASGOW_HASKELL__ >= 710
import Prelude hiding ( traverse )
#endif
import GHC.Prim
#if __GLASGOW_HASKELL__ >= 708
import GHC.Types (isTrue#)
#endif
import UU.Util.BinaryTrees
import UU.Parsing.MachineInterface
pDynE :: ParsRec state result s p a -> AnaParser state result s p a
pDynE v :: ParsRec state result s p a
v = ParsRec state result s p a -> AnaParser state result s p a
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a -> AnaParser state result s p a
anaDynE ParsRec state result s p a
v
pDynL :: ParsRec state result s p a -> AnaParser state result s p a
pDynL v :: ParsRec state result s p a
v = ParsRec state result s p a -> AnaParser state result s p a
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a -> AnaParser state result s p a
anaDynL ParsRec state result s p a
v
newtype RealParser state s p a = P(forall r' r'' . (a -> r'' -> r') ->
(state -> Steps r'' s p) -> state -> Steps r' s p)
newtype RealRecogn state s p = R(forall r . (state -> Steps r s p) -> state -> Steps r s p)
newtype RealAccept state result s p a = A(forall r . (state -> Steps r s p) -> state -> Steps (result a r) s p)
newtype ParsRec state result s p a = PR ( RealParser state s p a
, RealRecogn state s p
, RealAccept state result s p a
)
mkPR :: (RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR (P p :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p, R r :: forall r. (state -> Steps r s p) -> state -> Steps r s p
r) = (RealParser state s p a, RealRecogn state s p,
RealAccept state result s p a)
-> ParsRec state result s p a
forall state (result :: * -> * -> *) s p a.
(RealParser state s p a, RealRecogn state s p,
RealAccept state result s p a)
-> ParsRec state result s p a
PR ((forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R forall r. (state -> Steps r s p) -> state -> Steps r s p
r, (forall r.
(state -> Steps r s p) -> state -> Steps (result a r) s p)
-> RealAccept state result s p a
forall state (result :: * -> * -> *) s p a.
(forall r.
(state -> Steps r s p) -> state -> Steps (result a r) s p)
-> RealAccept state result s p a
A ((a -> r -> result a r)
-> (state -> Steps r s p) -> state -> Steps (result a r) s p
forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p a -> r -> result a r
forall (r :: * -> * -> *) v rest.
OutputState r =>
v -> rest -> r v rest
acceptR))
{-# INLINE unP #-}
{-# INLINE unR #-}
unP :: RealParser state s p a
-> (a -> r'' -> r')
-> (state -> Steps r'' s p)
-> state
-> Steps r' s p
unP (P p :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p) = (a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p
unR :: RealRecogn state s p
-> (state -> Steps r s p) -> state -> Steps r s p
unR (R p :: forall r. (state -> Steps r s p) -> state -> Steps r s p
p) = (state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
p
parseRecbasic :: (inp -> Steps (out c d) sym pos)
-> ParsRec inp out sym pos a
-> inp
-> Steps (out a (out c d)) sym pos
parseRecbasic :: (inp -> Steps (out c d) sym pos)
-> ParsRec inp out sym pos a
-> inp
-> Steps (out a (out c d)) sym pos
parseRecbasic eof :: inp -> Steps (out c d) sym pos
eof (PR ( P rp :: forall r' r''.
(a -> r'' -> r')
-> (inp -> Steps r'' sym pos) -> inp -> Steps r' sym pos
rp, rr :: RealRecogn inp sym pos
rr, A ra :: forall r.
(inp -> Steps r sym pos) -> inp -> Steps (out a r) sym pos
ra)) inp :: inp
inp = ((inp -> Steps (out c d) sym pos)
-> inp -> Steps (out a (out c d)) sym pos
forall r.
(inp -> Steps r sym pos) -> inp -> Steps (out a r) sym pos
ra inp -> Steps (out c d) sym pos
eof inp
inp)
parsebasic :: (inp -> Steps (out c d) sym pos)
-> AnaParser inp out sym pos a
-> inp
-> Steps (out a (out c d)) sym pos
parsebasic :: (inp -> Steps (out c d) sym pos)
-> AnaParser inp out sym pos a
-> inp
-> Steps (out a (out c d)) sym pos
parsebasic eof :: inp -> Steps (out c d) sym pos
eof (AnaParser inp out sym pos a
pp) inp :: inp
inp
= (inp -> Steps (out c d) sym pos)
-> ParsRec inp out sym pos a
-> inp
-> Steps (out a (out c d)) sym pos
forall inp (out :: * -> * -> *) c d sym pos a.
(inp -> Steps (out c d) sym pos)
-> ParsRec inp out sym pos a
-> inp
-> Steps (out a (out c d)) sym pos
parseRecbasic inp -> Steps (out c d) sym pos
eof (AnaParser inp out sym pos a -> ParsRec inp out sym pos a
forall state (result :: * -> * -> *) s p a.
AnaParser state result s p a -> ParsRec state result s p a
pars AnaParser inp out sym pos a
pp) inp
inp
libAccept :: (OutputState a, InputState b s p) => ParsRec b a s p s
libAccept :: ParsRec b a s p s
libAccept = (RealParser b s p s, RealRecogn b s p) -> ParsRec b a s p s
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ((forall r' r''.
(s -> r'' -> r') -> (b -> Steps r'' s p) -> b -> Steps r' s p)
-> RealParser b s p s
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (\ acc :: s -> r'' -> r'
acc k :: b -> Steps r'' s p
k state :: b
state ->
case b -> (# s, b #)
forall state s pos.
InputState state s pos =>
state -> (# s, state #)
splitState b
state of
(# s :: s
s, ss :: b
ss #) -> (r'' -> r') -> Steps r'' s p -> Steps r' s p
forall val s p a. (a -> val) -> Steps a s p -> Steps val s p
OkVal (s -> r'' -> r'
acc s
s) (b -> Steps r'' s p
k b
ss))
,(forall r. (b -> Steps r s p) -> b -> Steps r s p)
-> RealRecogn b s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R (\ k :: b -> Steps r s p
k state :: b
state ->
case b -> (# s, b #)
forall state s pos.
InputState state s pos =>
state -> (# s, state #)
splitState b
state of
(# s :: s
s, ss :: b
ss #) -> Steps r s p -> Steps r s p
forall val s p. Steps val s p -> Steps val s p
Ok (b -> Steps r s p
k b
ss))
)
libInsert :: Int# -> a -> Expecting a -> ParsRec state result a p a
libInsert c :: Int#
c sym :: a
sym firsts :: Expecting a
firsts =(RealParser state a p a, RealRecogn state a p)
-> ParsRec state result a p a
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR( (forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' a p) -> state -> Steps r' a p)
-> RealParser state a p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (\acc :: a -> r'' -> r'
acc k :: state -> Steps r'' a p
k state :: state
state -> let msg :: Message a p
msg = Expecting a -> p -> Action a -> Message a p
forall sym pos.
Expecting sym -> pos -> Action sym -> Message sym pos
Msg Expecting a
firsts
(state -> p
forall state s pos. InputState state s pos => state -> pos
getPosition state
state)
(a -> Action a
forall s. s -> Action s
Insert a
sym)
in Int# -> Message a p -> Steps r' a p -> Steps r' a p
forall val s p.
Int# -> Message s p -> Steps val s p -> Steps val s p
StRepair Int#
c Message a p
msg ((r'' -> r') -> Steps r'' a p -> Steps r' a p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val (a -> r'' -> r'
acc a
sym) (state -> Steps r'' a p
k (a -> state -> state
forall state s pos. InputState state s pos => s -> state -> state
insertSymbol a
sym (Message a p -> state -> state
forall state s pos.
InputState state s pos =>
Message s pos -> state -> state
reportError Message a p
msg state
state)))))
, (forall r. (state -> Steps r a p) -> state -> Steps r a p)
-> RealRecogn state a p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R (\ k :: state -> Steps r a p
k state :: state
state -> let msg :: Message a p
msg = Expecting a -> p -> Action a -> Message a p
forall sym pos.
Expecting sym -> pos -> Action sym -> Message sym pos
Msg Expecting a
firsts
(state -> p
forall state s pos. InputState state s pos => state -> pos
getPosition state
state)
(a -> Action a
forall s. s -> Action s
Insert a
sym)
in Int# -> Message a p -> Steps r a p -> Steps r a p
forall val s p.
Int# -> Message s p -> Steps val s p -> Steps val s p
StRepair Int#
c Message a p
msg (state -> Steps r a p
k (a -> state -> state
forall state s pos. InputState state s pos => s -> state -> state
insertSymbol a
sym (Message a p -> state -> state
forall state s pos.
InputState state s pos =>
Message s pos -> state -> state
reportError Message a p
msg state
state))))
)
libSucceed :: a -> ParsRec state result s p a
libSucceed v :: a
v =(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR( (forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (\ acc :: a -> r'' -> r'
acc -> let accv :: Steps r'' s p -> Steps r' s p
accv = (r'' -> r') -> Steps r'' s p -> Steps r' s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val (a -> r'' -> r'
acc a
v) in {-# SCC "machine" #-} \ k :: state -> Steps r'' s p
k state :: state
state -> Steps r'' s p -> Steps r' s p
forall s p. Steps r'' s p -> Steps r' s p
accv (state -> Steps r'' s p
k state
state))
, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R forall a. a -> a
forall r. (state -> Steps r s p) -> state -> Steps r s p
id
)
libSeq :: ParsRec state result s p (a -> a)
-> ParsRec state result s p a -> ParsRec state result s p a
libSeq (PR (P pp :: forall r' r''.
((a -> a) -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
pp, R pr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
pr, _)) ~(PR (P qp :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp, R qr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
qr, A qa :: forall r. (state -> Steps r s p) -> state -> Steps (result a r) s p
qa)) =(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ( (forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (\ acc :: a -> r'' -> r'
acc -> let p :: (state -> Steps (result a r'') s p) -> state -> Steps r' s p
p = ((a -> a) -> result a r'' -> r')
-> (state -> Steps (result a r'') s p) -> state -> Steps r' s p
forall r' r''.
((a -> a) -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
pp ((a -> r'' -> r') -> (a -> a) -> result a r'' -> r'
forall (r :: * -> * -> *) a rest rest' b.
OutputState r =>
(a -> rest -> rest') -> (b -> a) -> r b rest -> rest'
nextR a -> r'' -> r'
acc) in {-# SCC "machine" #-} \k :: state -> Steps r'' s p
k state :: state
state -> (state -> Steps (result a r'') s p) -> state -> Steps r' s p
p ((state -> Steps r'' s p) -> state -> Steps (result a r'') s p
forall r. (state -> Steps r s p) -> state -> Steps (result a r) s p
qa state -> Steps r'' s p
k) state
state)
, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R ( (state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
pr((state -> Steps r s p) -> state -> Steps r s p)
-> ((state -> Steps r s p) -> state -> Steps r s p)
-> (state -> Steps r s p)
-> state
-> Steps r s p
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
qr)
)
libDollar :: (a -> a)
-> ParsRec state result s p a -> ParsRec state result s p a
libDollar f :: a -> a
f (PR (P qp :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp, R qr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
qr, _ )) = (RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ( (forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (\ acc :: a -> r'' -> r'
acc -> {-# SCC "machine" #-} (a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp (a -> r'' -> r'
acc(a -> r'' -> r') -> (a -> a) -> a -> r'' -> r'
forall b c a. (b -> c) -> (a -> b) -> a -> c
.a -> a
f))
, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R forall r. (state -> Steps r s p) -> state -> Steps r s p
qr
)
libDollarL :: a -> ParsRec state result s p a -> ParsRec state result s p a
libDollarL f :: a
f (PR (P qp :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp, R qr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
qr, _ )) = (RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ( (forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (\ acc :: a -> r'' -> r'
acc -> let accf :: Steps r'' s p -> Steps r' s p
accf = (r'' -> r') -> Steps r'' s p -> Steps r' s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val (a -> r'' -> r'
acc a
f) in {-# SCC "machine" #-} \ k :: state -> Steps r'' s p
k state :: state
state -> (state -> Steps r' s p) -> state -> Steps r' s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
qr (\ inp :: state
inp -> Steps r'' s p -> Steps r' s p
forall s p. Steps r'' s p -> Steps r' s p
accf ( state -> Steps r'' s p
k state
inp)) state
state)
, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R forall r. (state -> Steps r s p) -> state -> Steps r s p
qr
)
libDollarR :: p -> ParsRec state result s p a -> ParsRec state result s p a
libDollarR f :: p
f (PR (P qp :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp, R qr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
qr, _ )) = (RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ((forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R forall r. (state -> Steps r s p) -> state -> Steps r s p
qr)
libSeqL :: ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
libSeqL (PR (P pp :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
pp, R pr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
pr, _ )) ~(PR (P qp :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp, R qr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
qr , _ )) = (RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ( (forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (\acc :: a -> r'' -> r'
acc -> let p :: (state -> Steps r'' s p) -> state -> Steps r' s p
p = (a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
pp a -> r'' -> r'
acc in {-# SCC "machine" #-}\k :: state -> Steps r'' s p
k state :: state
state -> (state -> Steps r'' s p) -> state -> Steps r' s p
p ((state -> Steps r'' s p) -> state -> Steps r'' s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
qr state -> Steps r'' s p
k) state
state)
, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R ((state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
pr((state -> Steps r s p) -> state -> Steps r s p)
-> ((state -> Steps r s p) -> state -> Steps r s p)
-> (state -> Steps r s p)
-> state
-> Steps r s p
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
qr)
)
libSeqR :: ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
libSeqR (PR (P pp :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
pp, R pr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
pr, _ )) ~(PR (P qp :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp, R qr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
qr, _ )) = (RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ( (forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (\acc :: a -> r'' -> r'
acc -> let q :: (state -> Steps r'' s p) -> state -> Steps r' s p
q = (a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp a -> r'' -> r'
acc in {-# SCC "machine" #-}\k :: state -> Steps r'' s p
k state :: state
state -> (state -> Steps r' s p) -> state -> Steps r' s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
pr ((state -> Steps r'' s p) -> state -> Steps r' s p
q state -> Steps r'' s p
k) state
state)
, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R ((state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
pr((state -> Steps r s p) -> state -> Steps r s p)
-> ((state -> Steps r s p) -> state -> Steps r s p)
-> (state -> Steps r s p)
-> state
-> Steps r s p
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
qr)
)
libOr :: ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
libOr (PR (P pp :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
pp, R pr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
pr,_ )) (PR (P qp :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp, R qr :: forall r. (state -> Steps r s p) -> state -> Steps r s p
qr, _ )) = (RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ( (forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (\ acc :: a -> r'' -> r'
acc -> let p :: (state -> Steps r'' s p) -> state -> Steps r' s p
p = (a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
pp a -> r'' -> r'
acc
q :: (state -> Steps r'' s p) -> state -> Steps r' s p
q = (a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
qp a -> r'' -> r'
acc
in {-# SCC "machine" #-} \ k :: state -> Steps r'' s p
k state :: state
state -> (state -> Steps r'' s p) -> state -> Steps r' s p
p state -> Steps r'' s p
k state
state Steps r' s p -> Steps r' s p -> Steps r' s p
forall s b p. Ord s => Steps b s p -> Steps b s p -> Steps b s p
`libBest` (state -> Steps r'' s p) -> state -> Steps r' s p
q state -> Steps r'' s p
k state
state)
, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R (\ k :: state -> Steps r s p
k state :: state
state -> (state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
pr state -> Steps r s p
k state
state Steps r s p -> Steps r s p -> Steps r s p
forall s b p. Ord s => Steps b s p -> Steps b s p -> Steps b s p
`libBest` (state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
qr state -> Steps r s p
k state
state)
)
libFail :: OutputState a => ParsRec b a c p d
libFail :: ParsRec b a c p d
libFail = (RealParser b c p d, RealRecogn b c p) -> ParsRec b a c p d
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ( (forall r' r''.
(d -> r'' -> r') -> (b -> Steps r'' c p) -> b -> Steps r' c p)
-> RealParser b c p d
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P (\ _ _ _ -> ([Char] -> Steps r' c p
forall a. [Char] -> a
usererror "calling an always failing parser" ))
, (forall r. (b -> Steps r c p) -> b -> Steps r c p)
-> RealRecogn b c p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R (\ _ _ -> ([Char] -> Steps r c p
forall a. [Char] -> a
usererror "calling an always failing recogniser"))
)
starting :: Steps a s p -> Expecting s
starting :: Steps a s p -> Expecting s
starting (StRepair _ m :: Message s p
m _ ) = Message s p -> Expecting s
forall sym pos. Message sym pos -> Expecting sym
getStart Message s p
m
starting (Best l :: Steps a s p
l _ _ ) = Steps a s p -> Expecting s
forall a s p. Steps a s p -> Expecting s
starting Steps a s p
l
starting _ = [Char] -> [Char] -> Expecting s
forall a. [Char] -> [Char] -> a
systemerror "UU.Parsing.Machine" "starting"
hasSuccess :: Steps a s p -> Bool
hasSuccess :: Steps a s p -> Bool
hasSuccess (StRepair _ _ _ ) = Bool
False
hasSuccess (Best _ _ _ ) = Bool
False
hasSuccess _ = Bool
True
getStart :: Message sym pos -> Expecting sym
getStart (Msg st :: Expecting sym
st _ _) = Expecting sym
st
addToMessage :: Message sym pos -> Expecting sym -> Message sym pos
addToMessage (Msg exp :: Expecting sym
exp pos :: pos
pos act :: Action sym
act) more :: Expecting sym
more = Expecting sym -> pos -> Action sym -> Message sym pos
forall sym pos.
Expecting sym -> pos -> Action sym -> Message sym pos
Msg (Expecting sym
more Expecting sym -> Expecting sym -> Expecting sym
forall a. Ord a => Expecting a -> Expecting a -> Expecting a
`eor` Expecting sym
exp) pos
pos Action sym
act
addexpecting :: Expecting s -> Steps val s p -> Steps val s p
addexpecting more :: Expecting s
more (StRepair cost :: Int#
cost msg :: Message s p
msg rest :: Steps val s p
rest) = Int# -> Message s p -> Steps val s p -> Steps val s p
forall val s p.
Int# -> Message s p -> Steps val s p -> Steps val s p
StRepair Int#
cost (Message s p -> Expecting s -> Message s p
forall sym pos.
Ord sym =>
Message sym pos -> Expecting sym -> Message sym pos
addToMessage Message s p
msg Expecting s
more) Steps val s p
rest
addexpecting more :: Expecting s
more (Best l :: Steps val s p
l sel :: Steps val s p
sel r :: Steps val s p
r) = Steps val s p -> Steps val s p -> Steps val s p -> Steps val s p
forall val s p.
Steps val s p -> Steps val s p -> Steps val s p -> Steps val s p
Best (Expecting s -> Steps val s p -> Steps val s p
addexpecting Expecting s
more Steps val s p
l)
(Expecting s -> Steps val s p -> Steps val s p
addexpecting Expecting s
more Steps val s p
sel)
(Expecting s -> Steps val s p -> Steps val s p
addexpecting Expecting s
more Steps val s p
r)
addexpecting more :: Expecting s
more (OkVal v :: a -> val
v rest :: Steps a s p
rest ) = [Char] -> [Char] -> Steps val s p
forall a. [Char] -> [Char] -> a
systemerror "UU_Parsing" ("addexpecting: OkVal")
addexpecting more :: Expecting s
more (Ok _ ) = [Char] -> [Char] -> Steps val s p
forall a. [Char] -> [Char] -> a
systemerror "UU_Parsing" ("addexpecting: Ok")
addexpecting more :: Expecting s
more (Cost _ _ ) = [Char] -> [Char] -> Steps val s p
forall a. [Char] -> [Char] -> a
systemerror "UU_Parsing" ("addexpecting: Cost")
addexpecting more :: Expecting s
more _ = [Char] -> [Char] -> Steps val s p
forall a. [Char] -> [Char] -> a
systemerror "UU_Parsing" ("addexpecting: other")
eor :: Ord a => Expecting a -> Expecting a -> Expecting a
eor :: Expecting a -> Expecting a -> Expecting a
eor p :: Expecting a
p q :: Expecting a
q = [Expecting a] -> Expecting a
forall s. [Expecting s] -> Expecting s
EOr ([Expecting a] -> [Expecting a] -> [Expecting a]
forall a. Ord a => [a] -> [a] -> [a]
merge (Expecting a -> [Expecting a]
forall s. Expecting s -> [Expecting s]
tolist Expecting a
p) (Expecting a -> [Expecting a]
forall s. Expecting s -> [Expecting s]
tolist Expecting a
q))
where merge :: [a] -> [a] -> [a]
merge x :: [a]
x@(l :: a
l:ll :: [a]
ll) y :: [a]
y@(r :: a
r:rr :: [a]
rr) = case a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare a
l a
r of
LT -> a
la -> [a] -> [a]
forall a. a -> [a] -> [a]
:( [a]
ll [a] -> [a] -> [a]
`merge` [a]
y)
GT -> a
ra -> [a] -> [a]
forall a. a -> [a] -> [a]
:( [a]
x [a] -> [a] -> [a]
`merge` [a]
rr)
EQ -> a
la -> [a] -> [a]
forall a. a -> [a] -> [a]
:( [a]
ll [a] -> [a] -> [a]
`merge` [a]
rr)
merge l :: [a]
l [] = [a]
l
merge [] r :: [a]
r = [a]
r
tolist :: Expecting s -> [Expecting s]
tolist (EOr l :: [Expecting s]
l) = [Expecting s]
l
tolist x :: Expecting s
x = [Expecting s
x]
libBest :: Ord s => Steps b s p -> Steps b s p -> Steps b s p
libBest :: Steps b s p -> Steps b s p -> Steps b s p
libBest ls :: Steps b s p
ls rs :: Steps b s p
rs = Steps b s p -> Steps b s p -> (b -> b) -> (b -> b) -> Steps b s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libBest' Steps b s p
ls Steps b s p
rs b -> b
forall a. a -> a
id b -> b
forall a. a -> a
id
libBest' :: Ord s => Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libBest' :: Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libBest' (OkVal v :: a -> b
v ls :: Steps a s p
ls) (OkVal w :: a -> c
w rs :: Steps a s p
rs) lf :: b -> d
lf rf :: c -> d
rf = Steps d s p -> Steps d s p
forall val s p. Steps val s p -> Steps val s p
Ok (Steps a s p -> Steps a s p -> (a -> d) -> (a -> d) -> Steps d s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libBest' Steps a s p
ls Steps a s p
rs (b -> d
lf(b -> d) -> (a -> b) -> a -> d
forall b c a. (b -> c) -> (a -> b) -> a -> c
.a -> b
v) (c -> d
rf(c -> d) -> (a -> c) -> a -> d
forall b c a. (b -> c) -> (a -> b) -> a -> c
.a -> c
w))
libBest' (OkVal v :: a -> b
v ls :: Steps a s p
ls) (Ok rs :: Steps c s p
rs) lf :: b -> d
lf rf :: c -> d
rf = Steps d s p -> Steps d s p
forall val s p. Steps val s p -> Steps val s p
Ok (Steps a s p -> Steps c s p -> (a -> d) -> (c -> d) -> Steps d s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libBest' Steps a s p
ls Steps c s p
rs (b -> d
lf(b -> d) -> (a -> b) -> a -> d
forall b c a. (b -> c) -> (a -> b) -> a -> c
.a -> b
v) c -> d
rf )
libBest' (Ok ls :: Steps b s p
ls) (OkVal w :: a -> c
w rs :: Steps a s p
rs) lf :: b -> d
lf rf :: c -> d
rf = Steps d s p -> Steps d s p
forall val s p. Steps val s p -> Steps val s p
Ok (Steps b s p -> Steps a s p -> (b -> d) -> (a -> d) -> Steps d s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libBest' Steps b s p
ls Steps a s p
rs b -> d
lf (c -> d
rf(c -> d) -> (a -> c) -> a -> d
forall b c a. (b -> c) -> (a -> b) -> a -> c
.a -> c
w))
libBest' (Ok ls :: Steps b s p
ls) (Ok rs :: Steps c s p
rs) lf :: b -> d
lf rf :: c -> d
rf = Steps d s p -> Steps d s p
forall val s p. Steps val s p -> Steps val s p
Ok (Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libBest' Steps b s p
ls Steps c s p
rs b -> d
lf c -> d
rf )
libBest' (OkVal v :: a -> b
v ls :: Steps a s p
ls) _ lf :: b -> d
lf rf :: c -> d
rf = (a -> d) -> Steps a s p -> Steps d s p
forall val s p a. (a -> val) -> Steps a s p -> Steps val s p
OkVal (b -> d
lf(b -> d) -> (a -> b) -> a -> d
forall b c a. (b -> c) -> (a -> b) -> a -> c
.a -> b
v) Steps a s p
ls
libBest' _ (OkVal w :: a -> c
w rs :: Steps a s p
rs) lf :: b -> d
lf rf :: c -> d
rf = (a -> d) -> Steps a s p -> Steps d s p
forall val s p a. (a -> val) -> Steps a s p -> Steps val s p
OkVal (c -> d
rf(c -> d) -> (a -> c) -> a -> d
forall b c a. (b -> c) -> (a -> b) -> a -> c
.a -> c
w) Steps a s p
rs
libBest' (Ok ls :: Steps b s p
ls) _ lf :: b -> d
lf rf :: c -> d
rf = (b -> d) -> Steps b s p -> Steps d s p
forall val s p a. (a -> val) -> Steps a s p -> Steps val s p
OkVal b -> d
lf Steps b s p
ls
libBest' _ (Ok rs :: Steps c s p
rs) lf :: b -> d
lf rf :: c -> d
rf = (c -> d) -> Steps c s p -> Steps d s p
forall val s p a. (a -> val) -> Steps a s p -> Steps val s p
OkVal c -> d
rf Steps c s p
rs
libBest' l :: Steps b s p
l@(Cost i :: Int#
i ls :: Steps b s p
ls ) r :: Steps c s p
r@(Cost j :: Int#
j rs :: Steps c s p
rs ) lf :: b -> d
lf rf :: c -> d
rf
| Int# -> Bool
isTrue (Int#
i Int# -> Int# -> Int#
==# Int#
j) = Int# -> Steps d s p -> Steps d s p
forall val s p. Int# -> Steps val s p -> Steps val s p
Cost Int#
i (Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libBest' Steps b s p
ls Steps c s p
rs b -> d
lf c -> d
rf)
| Int# -> Bool
isTrue (Int#
i Int# -> Int# -> Int#
<# Int#
j) = Int# -> Steps d s p -> Steps d s p
forall val s p. Int# -> Steps val s p -> Steps val s p
Cost Int#
i ((b -> d) -> Steps b s p -> Steps d s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val b -> d
lf Steps b s p
ls)
| Int# -> Bool
isTrue (Int#
i Int# -> Int# -> Int#
># Int#
j) = Int# -> Steps d s p -> Steps d s p
forall val s p. Int# -> Steps val s p -> Steps val s p
Cost Int#
j ((c -> d) -> Steps c s p -> Steps d s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val c -> d
rf Steps c s p
rs)
libBest' l :: Steps b s p
l@(NoMoreSteps v :: b
v) _ lf :: b -> d
lf rf :: c -> d
rf = d -> Steps d s p
forall val s p. val -> Steps val s p
NoMoreSteps (b -> d
lf b
v)
libBest' _ r :: Steps c s p
r@(NoMoreSteps w :: c
w) lf :: b -> d
lf rf :: c -> d
rf = d -> Steps d s p
forall val s p. val -> Steps val s p
NoMoreSteps (c -> d
rf c
w)
libBest' l :: Steps b s p
l@(Cost i :: Int#
i ls :: Steps b s p
ls) _ lf :: b -> d
lf rf :: c -> d
rf = Int# -> Steps d s p -> Steps d s p
forall val s p. Int# -> Steps val s p -> Steps val s p
Cost Int#
i ((b -> d) -> Steps b s p -> Steps d s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val b -> d
lf Steps b s p
ls)
libBest' _ r :: Steps c s p
r@(Cost j :: Int#
j rs :: Steps c s p
rs) lf :: b -> d
lf rf :: c -> d
rf = Int# -> Steps d s p -> Steps d s p
forall val s p. Int# -> Steps val s p -> Steps val s p
Cost Int#
j ((c -> d) -> Steps c s p -> Steps d s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val c -> d
rf Steps c s p
rs)
libBest' l :: Steps b s p
l r :: Steps c s p
r lf :: b -> d
lf rf :: c -> d
rf = Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libCorrect Steps b s p
l Steps c s p
r b -> d
lf c -> d
rf
#if __GLASGOW_HASKELL__ >= 708
isTrue :: Int# -> Bool
isTrue = Int# -> Bool
isTrue#
#else
isTrue = id
#endif
lib_correct :: Ord s => (b -> c -> Steps d s p) -> (b -> c -> Steps d s p) -> b -> c -> Steps d s p
lib_correct :: (b -> c -> Steps d s p)
-> (b -> c -> Steps d s p) -> b -> c -> Steps d s p
lib_correct p :: b -> c -> Steps d s p
p q :: b -> c -> Steps d s p
q = \k :: b
k inp :: c
inp -> Steps d s p -> Steps d s p -> (d -> d) -> (d -> d) -> Steps d s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libCorrect (b -> c -> Steps d s p
p b
k c
inp) ( b -> c -> Steps d s p
q b
k c
inp) d -> d
forall a. a -> a
id d -> d
forall a. a -> a
id
libCorrect :: Ord s => Steps a s p -> Steps c s p -> (a -> d) -> (c -> d) -> Steps d s p
libCorrect :: Steps a s p -> Steps c s p -> (a -> d) -> (c -> d) -> Steps d s p
libCorrect ls :: Steps a s p
ls rs :: Steps c s p
rs lf :: a -> d
lf rf :: c -> d
rf
= let (ToBeat _ choice :: Steps d s p
choice) = ToBeat (Steps d s p)
-> (Steps c s p -> Steps d s p, Steps c s p)
-> Int#
-> Int#
-> ToBeat (Steps d s p)
forall a s p v.
ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
traverse
(ToBeat (Steps d s p)
-> (Steps a s p -> Steps d s p, Steps a s p)
-> Int#
-> Int#
-> ToBeat (Steps d s p)
forall a s p v.
ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
traverse (Int# -> Steps d s p -> ToBeat (Steps d s p)
forall a. Int# -> a -> ToBeat a
ToBeat 999# ((a -> d) -> Steps a s p -> Steps d s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val a -> d
lf Steps a s p
newleft))
((a -> d) -> Steps a s p -> Steps d s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val a -> d
lf, Steps a s p
newleft) 0# 4#)
((c -> d) -> Steps c s p -> Steps d s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val c -> d
rf, Steps c s p
newright) 0# 4#
newleft :: Steps a s p
newleft = Expecting s -> Steps a s p -> Steps a s p
forall s val p.
Ord s =>
Expecting s -> Steps val s p -> Steps val s p
addexpecting (Steps c s p -> Expecting s
forall a s p. Steps a s p -> Expecting s
starting Steps c s p
rs) Steps a s p
ls
newright :: Steps c s p
newright = Expecting s -> Steps c s p -> Steps c s p
forall s val p.
Ord s =>
Expecting s -> Steps val s p -> Steps val s p
addexpecting (Steps a s p -> Expecting s
forall a s p. Steps a s p -> Expecting s
starting Steps a s p
ls) Steps c s p
rs
in Steps d s p -> Steps d s p -> Steps d s p -> Steps d s p
forall val s p.
Steps val s p -> Steps val s p -> Steps val s p -> Steps val s p
Best ((a -> d) -> Steps a s p -> Steps d s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val a -> d
lf Steps a s p
newleft)
Steps d s p
choice
((c -> d) -> Steps c s p -> Steps d s p
forall a b s p. (a -> b) -> Steps a s p -> Steps b s p
val c -> d
rf Steps c s p
newright)
data ToBeat a = ToBeat Int# a
traverse :: ToBeat (Steps a s p) -> (Steps v s p -> Steps a s p, Steps v s p) -> Int# -> Int# -> ToBeat (Steps a s p)
traverse :: ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
traverse b :: ToBeat (Steps a s p)
b@(ToBeat bv :: Int#
bv br :: Steps a s p
br) (f :: Steps v s p -> Steps a s p
f, s :: Steps v s p
s) v :: Int#
v 0# =
if Int# -> Bool
isTrue (Int#
bv Int# -> Int# -> Int#
<=# Int#
v)
then ToBeat (Steps a s p)
b
else Int# -> Steps a s p -> ToBeat (Steps a s p)
forall a. Int# -> a -> ToBeat a
ToBeat Int#
v (Steps v s p -> Steps a s p
f Steps v s p
s)
traverse b :: ToBeat (Steps a s p)
b@(ToBeat bv :: Int#
bv br :: Steps a s p
br) (f :: Steps v s p -> Steps a s p
f, Ok l :: Steps v s p
l) v :: Int#
v n :: Int#
n = ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
forall a s p v.
ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
traverse ToBeat (Steps a s p)
b (Steps v s p -> Steps a s p
f(Steps v s p -> Steps a s p)
-> (Steps v s p -> Steps v s p) -> Steps v s p -> Steps a s p
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Steps v s p -> Steps v s p
forall val s p. Steps val s p -> Steps val s p
Ok , Steps v s p
l) (Int#
v Int# -> Int# -> Int#
-# Int#
n Int# -> Int# -> Int#
+# 4#) (Int#
n Int# -> Int# -> Int#
-# 1#)
traverse b :: ToBeat (Steps a s p)
b@(ToBeat bv :: Int#
bv br :: Steps a s p
br) (f :: Steps v s p -> Steps a s p
f, OkVal w :: a -> v
w l :: Steps a s p
l) v :: Int#
v n :: Int#
n = ToBeat (Steps a s p)
-> (Steps a s p -> Steps a s p, Steps a s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
forall a s p v.
ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
traverse ToBeat (Steps a s p)
b (Steps v s p -> Steps a s p
f(Steps v s p -> Steps a s p)
-> (Steps a s p -> Steps v s p) -> Steps a s p -> Steps a s p
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(a -> v) -> Steps a s p -> Steps v s p
forall val s p a. (a -> val) -> Steps a s p -> Steps val s p
OkVal a -> v
w, Steps a s p
l) (Int#
v Int# -> Int# -> Int#
-# Int#
n Int# -> Int# -> Int#
+# 4#) (Int#
n Int# -> Int# -> Int#
-# 1#)
traverse b :: ToBeat (Steps a s p)
b@(ToBeat bv :: Int#
bv br :: Steps a s p
br) (f :: Steps v s p -> Steps a s p
f, Cost i :: Int#
i l :: Steps v s p
l) v :: Int#
v n :: Int#
n = if Int# -> Bool
isTrue (Int#
i Int# -> Int# -> Int#
+# Int#
v Int# -> Int# -> Int#
>=# Int#
bv)
then ToBeat (Steps a s p)
b
else ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
forall a s p v.
ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
traverse ToBeat (Steps a s p)
b (Steps v s p -> Steps a s p
f(Steps v s p -> Steps a s p)
-> (Steps v s p -> Steps v s p) -> Steps v s p -> Steps a s p
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Int# -> Steps v s p -> Steps v s p
forall val s p. Int# -> Steps val s p -> Steps val s p
Cost Int#
i, Steps v s p
l) (Int#
i Int# -> Int# -> Int#
+# Int#
v) Int#
n
traverse b :: ToBeat (Steps a s p)
b@(ToBeat bv :: Int#
bv br :: Steps a s p
br) (f :: Steps v s p -> Steps a s p
f, Best l :: Steps v s p
l _ r :: Steps v s p
r) v :: Int#
v n :: Int#
n = ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
forall a s p v.
ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
traverse (ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
forall a s p v.
ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
traverse ToBeat (Steps a s p)
b (Steps v s p -> Steps a s p
f, Steps v s p
l) Int#
v Int#
n) (Steps v s p -> Steps a s p
f, Steps v s p
r) Int#
v Int#
n
traverse b :: ToBeat (Steps a s p)
b@(ToBeat bv :: Int#
bv br :: Steps a s p
br) (f :: Steps v s p -> Steps a s p
f, StRepair i :: Int#
i msgs :: Message s p
msgs r :: Steps v s p
r) v :: Int#
v n :: Int#
n = if Int# -> Bool
isTrue (Int#
i Int# -> Int# -> Int#
+# Int#
v Int# -> Int# -> Int#
>=# Int#
bv) then ToBeat (Steps a s p)
b
else ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
forall a s p v.
ToBeat (Steps a s p)
-> (Steps v s p -> Steps a s p, Steps v s p)
-> Int#
-> Int#
-> ToBeat (Steps a s p)
traverse ToBeat (Steps a s p)
b (Steps v s p -> Steps a s p
f(Steps v s p -> Steps a s p)
-> (Steps v s p -> Steps v s p) -> Steps v s p -> Steps a s p
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Int# -> Message s p -> Steps v s p -> Steps v s p
forall val s p.
Int# -> Message s p -> Steps val s p -> Steps val s p
StRepair Int#
i Message s p
msgs, Steps v s p
r) (Int#
i Int# -> Int# -> Int#
+# Int#
v) (Int#
n Int# -> Int# -> Int#
-# 1#)
traverse b :: ToBeat (Steps a s p)
b@(ToBeat bv :: Int#
bv br :: Steps a s p
br) (f :: Steps v s p -> Steps a s p
f, t :: Steps v s p
t@(NoMoreSteps _)) v :: Int#
v n :: Int#
n = if Int# -> Bool
isTrue (Int#
bv Int# -> Int# -> Int#
<=# Int#
v) then ToBeat (Steps a s p)
b else Int# -> Steps a s p -> ToBeat (Steps a s p)
forall a. Int# -> a -> ToBeat a
ToBeat Int#
v (Steps v s p -> Steps a s p
f Steps v s p
t)
data AnaParser state result s p a
= AnaParser { AnaParser state result s p a -> ParsRec state result s p a
pars :: ParsRec state result s p a
, AnaParser state result s p a -> Nat
leng :: Nat
, AnaParser state result s p a
-> Maybe (Bool, Either a (ParsRec state result s p a))
zerop :: Maybe (Bool, Either a (ParsRec state result s p a))
, AnaParser state result s p a -> OneDescr state result s p a
onep :: OneDescr state result s p a
}
data OneDescr state result s p a
= OneDescr { OneDescr state result s p a -> Expecting s
firsts :: Expecting s
, OneDescr state result s p a
-> [(SymbolR s, TableEntry state result s p a)]
table :: [(SymbolR s, TableEntry state result s p a)]
}
data TableEntry state result s p a = TableEntry (ParsRec state result s p a) (Expecting s -> ParsRec state result s p a)
anaFail :: OutputState a => AnaParser b a c p d
anaFail :: AnaParser b a c p d
anaFail = AnaParser :: forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
AnaParser { pars :: ParsRec b a c p d
pars = ParsRec b a c p d
forall (a :: * -> * -> *) b c p d.
OutputState a =>
ParsRec b a c p d
libFail
, leng :: Nat
leng = Nat
Infinite
, zerop :: Maybe (Bool, Either d (ParsRec b a c p d))
zerop = Maybe (Bool, Either d (ParsRec b a c p d))
forall a. Maybe a
Nothing
, onep :: OneDescr b a c p d
onep = OneDescr b a c p d
forall state (result :: * -> * -> *) s p a.
OneDescr state result s p a
noOneParser
}
noOneParser :: OneDescr state result s p a
noOneParser = Expecting s
-> [(SymbolR s, TableEntry state result s p a)]
-> OneDescr state result s p a
forall state (result :: * -> * -> *) s p a.
Expecting s
-> [(SymbolR s, TableEntry state result s p a)]
-> OneDescr state result s p a
OneDescr ([Expecting s] -> Expecting s
forall s. [Expecting s] -> Expecting s
EOr []) []
pEmpty :: ParsRec state result s p a
-> (Bool, Either a (ParsRec state result s p a))
-> AnaParser state result s p a
pEmpty p :: ParsRec state result s p a
p zp :: (Bool, Either a (ParsRec state result s p a))
zp = AnaParser :: forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
AnaParser { pars :: ParsRec state result s p a
pars = ParsRec state result s p a
p
, leng :: Nat
leng = Nat
Zero
, zerop :: Maybe (Bool, Either a (ParsRec state result s p a))
zerop = (Bool, Either a (ParsRec state result s p a))
-> Maybe (Bool, Either a (ParsRec state result s p a))
forall a. a -> Maybe a
Just (Bool, Either a (ParsRec state result s p a))
zp
, onep :: OneDescr state result s p a
onep = OneDescr state result s p a
forall state (result :: * -> * -> *) s p a.
OneDescr state result s p a
noOneParser
}
anaSucceed :: a -> AnaParser state result s p a
anaSucceed v :: a
v = ParsRec state result s p a
-> (Bool, Either a (ParsRec state result s p a))
-> AnaParser state result s p a
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> (Bool, Either a (ParsRec state result s p a))
-> AnaParser state result s p a
pEmpty (a -> ParsRec state result s p a
forall (result :: * -> * -> *) a state s p.
OutputState result =>
a -> ParsRec state result s p a
libSucceed a
v) (Bool
False, a -> Either a (ParsRec state result s p a)
forall a b. a -> Either a b
Left a
v)
anaLow :: a -> AnaParser state result s p a
anaLow v :: a
v = ParsRec state result s p a
-> (Bool, Either a (ParsRec state result s p a))
-> AnaParser state result s p a
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> (Bool, Either a (ParsRec state result s p a))
-> AnaParser state result s p a
pEmpty (a -> ParsRec state result s p a
forall (result :: * -> * -> *) a state s p.
OutputState result =>
a -> ParsRec state result s p a
libSucceed a
v) (Bool
True, a -> Either a (ParsRec state result s p a)
forall a b. a -> Either a b
Left a
v)
anaDynE :: ParsRec state result s p a -> AnaParser state result s p a
anaDynE p :: ParsRec state result s p a
p = ParsRec state result s p a
-> (Bool, Either a (ParsRec state result s p a))
-> AnaParser state result s p a
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> (Bool, Either a (ParsRec state result s p a))
-> AnaParser state result s p a
pEmpty ParsRec state result s p a
p (Bool
False, ParsRec state result s p a -> Either a (ParsRec state result s p a)
forall a b. b -> Either a b
Right ParsRec state result s p a
p)
anaDynL :: ParsRec state result s p a -> AnaParser state result s p a
anaDynL p :: ParsRec state result s p a
p = ParsRec state result s p a
-> (Bool, Either a (ParsRec state result s p a))
-> AnaParser state result s p a
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> (Bool, Either a (ParsRec state result s p a))
-> AnaParser state result s p a
pEmpty ParsRec state result s p a
p (Bool
True , ParsRec state result s p a -> Either a (ParsRec state result s p a)
forall a b. b -> Either a b
Right ParsRec state result s p a
p)
anaOr :: AnaParser state result s p a
-> AnaParser state result s p a -> AnaParser state result s p a
anaOr ld :: AnaParser state result s p a
ld@(AnaParser _ ll :: Nat
ll zl :: Maybe (Bool, Either a (ParsRec state result s p a))
zl ol :: OneDescr state result s p a
ol) rd :: AnaParser state result s p a
rd@(AnaParser _ lr :: Nat
lr zr :: Maybe (Bool, Either a (ParsRec state result s p a))
zr or :: OneDescr state result s p a
or)
= Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
forall state s p (result :: * -> * -> *) a.
(InputState state s p, Symbol s, Ord s, OutputState result) =>
Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
mkParser Nat
newlength Maybe (Bool, Either a (ParsRec state result s p a))
newZeroDescr OneDescr state result s p a
newOneDescr
where (newlength :: Nat
newlength, maybeswap :: (b -> b -> c) -> b -> b -> c
maybeswap) = Nat
ll Nat -> Nat -> (Nat, (b -> b -> c) -> b -> b -> c)
forall b c. Nat -> Nat -> (Nat, (b -> b -> c) -> b -> b -> c)
`nat_min` Nat
lr
newZeroDescr :: Maybe (Bool, Either a (ParsRec state result s p a))
newZeroDescr = case Maybe (Bool, Either a (ParsRec state result s p a))
zl of {Nothing -> Maybe (Bool, Either a (ParsRec state result s p a))
zr
;_ -> case Maybe (Bool, Either a (ParsRec state result s p a))
zr of {Nothing -> Maybe (Bool, Either a (ParsRec state result s p a))
zl
;_ -> [Char] -> Maybe (Bool, Either a (ParsRec state result s p a))
forall a. [Char] -> a
usererror ("Two empty alternatives")
} }
newOneDescr :: OneDescr state result s p a
newOneDescr = (OneDescr state result s p a
-> OneDescr state result s p a
-> Bool
-> OneDescr state result s p a)
-> OneDescr state result s p a
-> OneDescr state result s p a
-> Bool
-> OneDescr state result s p a
forall b c. (b -> b -> c) -> b -> b -> c
maybeswap OneDescr state result s p a
-> OneDescr state result s p a
-> Bool
-> OneDescr state result s p a
forall s state (result :: * -> * -> *) p a.
Ord s =>
OneDescr state result s p a
-> OneDescr state result s p a
-> Bool
-> OneDescr state result s p a
orOneOneDescr OneDescr state result s p a
ol OneDescr state result s p a
or Bool
False
anaSeq :: (a -> ParsRec state result s p a -> ParsRec state result s p a)
-> (ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a)
-> (a -> a -> a)
-> AnaParser state result s p a
-> AnaParser state result s p a
-> AnaParser state result s p a
anaSeq libdollar :: a -> ParsRec state result s p a -> ParsRec state result s p a
libdollar libseq :: ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
libseq comb :: a -> a -> a
comb (AnaParser pl :: ParsRec state result s p a
pl ll :: Nat
ll zl :: Maybe (Bool, Either a (ParsRec state result s p a))
zl ol :: OneDescr state result s p a
ol) ~rd :: AnaParser state result s p a
rd@(AnaParser pr :: ParsRec state result s p a
pr lr :: Nat
lr zr :: Maybe (Bool, Either a (ParsRec state result s p a))
zr or :: OneDescr state result s p a
or)
= case Maybe (Bool, Either a (ParsRec state result s p a))
zl of
Just (b :: Bool
b, zp :: Either a (ParsRec state result s p a)
zp ) -> let newZeroDescr :: Maybe (Bool, Either a (ParsRec state result s p a))
newZeroDescr = Maybe (Bool, Either a (ParsRec state result s p a))
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> (a -> ParsRec state result s p a -> ParsRec state result s p a)
-> (ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a)
-> (a -> a -> a)
-> Maybe (Bool, Either a (ParsRec state result s p a))
forall (result :: * -> * -> *) t t a state s p b a.
OutputState result =>
Maybe (Bool, Either t t)
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> (t -> ParsRec state result s p a -> b)
-> (t -> ParsRec state result s p a -> b)
-> (t -> a -> a)
-> Maybe (Bool, Either a b)
seqZeroZero Maybe (Bool, Either a (ParsRec state result s p a))
zl Maybe (Bool, Either a (ParsRec state result s p a))
zr a -> ParsRec state result s p a -> ParsRec state result s p a
libdollar ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
libseq a -> a -> a
comb
newOneDescr :: OneDescr state result s p a
newOneDescr = let newOneOne :: OneDescr state result s p a
newOneOne = (ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
forall state (result :: * -> * -> *) s p a state
(result :: * -> * -> *) p a.
(ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
mapOnePars ( ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
`libseq` ParsRec state result s p a
pr) OneDescr state result s p a
ol
newZeroOne :: OneDescr state result s p a
newZeroOne = case Either a (ParsRec state result s p a)
zp of
Left f :: a
f -> (ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
forall state (result :: * -> * -> *) s p a state
(result :: * -> * -> *) p a.
(ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
mapOnePars (a
f a -> ParsRec state result s p a -> ParsRec state result s p a
`libdollar` ) OneDescr state result s p a
or
Right p :: ParsRec state result s p a
p -> (ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
forall state (result :: * -> * -> *) s p a state
(result :: * -> * -> *) p a.
(ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
mapOnePars (ParsRec state result s p a
p ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
`libseq` ) OneDescr state result s p a
or
in OneDescr state result s p a
-> OneDescr state result s p a
-> Bool
-> OneDescr state result s p a
forall s state (result :: * -> * -> *) p a.
Ord s =>
OneDescr state result s p a
-> OneDescr state result s p a
-> Bool
-> OneDescr state result s p a
orOneOneDescr OneDescr state result s p a
newZeroOne OneDescr state result s p a
newOneOne Bool
b
in Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
forall state s p (result :: * -> * -> *) a.
(InputState state s p, Symbol s, Ord s, OutputState result) =>
Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
mkParser Nat
lr Maybe (Bool, Either a (ParsRec state result s p a))
newZeroDescr OneDescr state result s p a
newOneDescr
_ -> ParsRec state result s p a
-> Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
AnaParser (ParsRec state result s p a
pl ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
`libseq` ParsRec state result s p a
pr) (Nat
ll Nat -> Nat -> Nat
`nat_add` Nat
lr) Maybe (Bool, Either a (ParsRec state result s p a))
forall a. Maybe a
Nothing ((ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
forall state (result :: * -> * -> *) s p a state
(result :: * -> * -> *) p a.
(ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
mapOnePars (ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
`libseq` ParsRec state result s p a
pr) OneDescr state result s p a
ol)
seqZeroZero :: Maybe (Bool, Either t t)
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> (t -> ParsRec state result s p a -> b)
-> (t -> ParsRec state result s p a -> b)
-> (t -> a -> a)
-> Maybe (Bool, Either a b)
seqZeroZero Nothing _ _ _ _ = Maybe (Bool, Either a b)
forall a. Maybe a
Nothing
seqZeroZero _ Nothing _ _ _ = Maybe (Bool, Either a b)
forall a. Maybe a
Nothing
seqZeroZero (Just (llow :: Bool
llow, left :: Either t t
left)) (Just (rlow :: Bool
rlow, right :: Either a (ParsRec state result s p a)
right)) libdollar :: t -> ParsRec state result s p a -> b
libdollar libseq :: t -> ParsRec state result s p a -> b
libseq comb :: t -> a -> a
comb
= (Bool, Either a b) -> Maybe (Bool, Either a b)
forall a. a -> Maybe a
Just ( Bool
llow Bool -> Bool -> Bool
|| Bool
rlow
, case Either t t
left of
Left lv :: t
lv -> case Either a (ParsRec state result s p a)
right of
Left rv :: a
rv -> a -> Either a b
forall a b. a -> Either a b
Left (t -> a -> a
comb t
lv a
rv)
Right rp :: ParsRec state result s p a
rp -> b -> Either a b
forall a b. b -> Either a b
Right (t
lv t -> ParsRec state result s p a -> b
`libdollar` ParsRec state result s p a
rp)
Right lp :: t
lp -> case Either a (ParsRec state result s p a)
right of
Left rv :: a
rv -> b -> Either a b
forall a b. b -> Either a b
Right (t
lp t -> ParsRec state result s p a -> b
`libseq` a -> ParsRec state result s p a
forall (result :: * -> * -> *) a state s p.
OutputState result =>
a -> ParsRec state result s p a
libSucceed a
rv)
Right rp :: ParsRec state result s p a
rp -> b -> Either a b
forall a b. b -> Either a b
Right (t
lp t -> ParsRec state result s p a -> b
`libseq` ParsRec state result s p a
rp)
)
orOneOneDescr :: OneDescr state result s p a
-> OneDescr state result s p a
-> Bool
-> OneDescr state result s p a
orOneOneDescr ~(OneDescr fl :: Expecting s
fl tl :: [(SymbolR s, TableEntry state result s p a)]
tl) ~(OneDescr fr :: Expecting s
fr tr :: [(SymbolR s, TableEntry state result s p a)]
tr) b :: Bool
b
= let keystr :: [SymbolR s]
keystr = ((SymbolR s, TableEntry state result s p a) -> SymbolR s)
-> [(SymbolR s, TableEntry state result s p a)] -> [SymbolR s]
forall a b. (a -> b) -> [a] -> [b]
map (SymbolR s, TableEntry state result s p a) -> SymbolR s
forall a b. (a, b) -> a
fst [(SymbolR s, TableEntry state result s p a)]
tr
lefttab :: [(SymbolR s, TableEntry state result s p a)]
lefttab = if Bool
b then [(SymbolR s, TableEntry state result s p a)
r | r :: (SymbolR s, TableEntry state result s p a)
r@(k :: SymbolR s
k,_) <- [(SymbolR s, TableEntry state result s p a)]
tl, Bool -> Bool
not (SymbolR s
k SymbolR s -> [SymbolR s] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [SymbolR s]
keystr)] else [(SymbolR s, TableEntry state result s p a)]
tl
in Expecting s
-> [(SymbolR s, TableEntry state result s p a)]
-> OneDescr state result s p a
forall state (result :: * -> * -> *) s p a.
Expecting s
-> [(SymbolR s, TableEntry state result s p a)]
-> OneDescr state result s p a
OneDescr (Expecting s
fl Expecting s -> Expecting s -> Expecting s
forall a. Ord a => Expecting a -> Expecting a -> Expecting a
`eor` Expecting s
fr) ([(SymbolR s, TableEntry state result s p a)]
lefttab [(SymbolR s, TableEntry state result s p a)]
-> [(SymbolR s, TableEntry state result s p a)]
-> [(SymbolR s, TableEntry state result s p a)]
forall a. [a] -> [a] -> [a]
++ [(SymbolR s, TableEntry state result s p a)]
tr)
anaCostRange :: Int# -> s -> SymbolR s -> AnaParser b a s p s
anaCostRange _ _ EmptyR = AnaParser b a s p s
forall (a :: * -> * -> *) b c p d.
OutputState a =>
AnaParser b a c p d
anaFail
anaCostRange ins_cost :: Int#
ins_cost ins_sym :: s
ins_sym range :: SymbolR s
range
= Nat
-> Maybe (Bool, Either s (ParsRec b a s p s))
-> OneDescr b a s p s
-> AnaParser b a s p s
forall state s p (result :: * -> * -> *) a.
(InputState state s p, Symbol s, Ord s, OutputState result) =>
Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
mkParser (Nat -> Nat
Succ Nat
Zero) Maybe (Bool, Either s (ParsRec b a s p s))
forall a. Maybe a
Nothing ( Expecting s
-> [(SymbolR s, TableEntry b a s p s)] -> OneDescr b a s p s
forall state (result :: * -> * -> *) s p a.
Expecting s
-> [(SymbolR s, TableEntry state result s p a)]
-> OneDescr state result s p a
OneDescr (SymbolR s -> Expecting s
forall s. SymbolR s -> Expecting s
ESym SymbolR s
range) [(SymbolR s
range, ParsRec b a s p s
-> (Expecting s -> ParsRec b a s p s) -> TableEntry b a s p s
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> (Expecting s -> ParsRec state result s p a)
-> TableEntry state result s p a
TableEntry ParsRec b a s p s
forall (a :: * -> * -> *) b s p.
(OutputState a, InputState b s p) =>
ParsRec b a s p s
libAccept
(Int# -> s -> Expecting s -> ParsRec b a s p s
forall (result :: * -> * -> *) state a p s s.
(OutputState result, InputState state s p, InputState state a p,
InputState state s p) =>
Int# -> a -> Expecting a -> ParsRec state result a p a
libInsert Int#
ins_cost s
ins_sym)
)])
anaGetFirsts :: AnaParser state result s p a -> Expecting s
anaGetFirsts (AnaParser p :: ParsRec state result s p a
p l :: Nat
l z :: Maybe (Bool, Either a (ParsRec state result s p a))
z od :: OneDescr state result s p a
od) = OneDescr state result s p a -> Expecting s
forall state (result :: * -> * -> *) s p a.
OneDescr state result s p a -> Expecting s
firsts OneDescr state result s p a
od
anaSetFirsts :: Expecting s
-> AnaParser state result s p a -> AnaParser state result s p a
anaSetFirsts newexp :: Expecting s
newexp (AnaParser _ l :: Nat
l zd :: Maybe (Bool, Either a (ParsRec state result s p a))
zd od :: OneDescr state result s p a
od)
= Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
forall state s p (result :: * -> * -> *) a.
(InputState state s p, Symbol s, Ord s, OutputState result) =>
Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
mkParser Nat
l Maybe (Bool, Either a (ParsRec state result s p a))
zd (OneDescr state result s p a
od{firsts :: Expecting s
firsts = Expecting s
newexp })
mapOnePars :: (ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
mapOnePars fp :: ParsRec state result s p a -> ParsRec state result s p a
fp ~(OneDescr fi :: Expecting s
fi t :: [(SymbolR s, TableEntry state result s p a)]
t) = Expecting s
-> [(SymbolR s, TableEntry state result s p a)]
-> OneDescr state result s p a
forall state (result :: * -> * -> *) s p a.
Expecting s
-> [(SymbolR s, TableEntry state result s p a)]
-> OneDescr state result s p a
OneDescr Expecting s
fi [ (SymbolR s
k, ParsRec state result s p a
-> (Expecting s -> ParsRec state result s p a)
-> TableEntry state result s p a
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> (Expecting s -> ParsRec state result s p a)
-> TableEntry state result s p a
TableEntry (ParsRec state result s p a -> ParsRec state result s p a
fp ParsRec state result s p a
p) (ParsRec state result s p a -> ParsRec state result s p a
fp(ParsRec state result s p a -> ParsRec state result s p a)
-> (Expecting s -> ParsRec state result s p a)
-> Expecting s
-> ParsRec state result s p a
forall b c a. (b -> c) -> (a -> b) -> a -> c
.Expecting s -> ParsRec state result s p a
corr))
| (k :: SymbolR s
k, TableEntry p :: ParsRec state result s p a
p corr :: Expecting s -> ParsRec state result s p a
corr ) <- [(SymbolR s, TableEntry state result s p a)]
t
]
mkParser :: (InputState state s p, Symbol s, Ord s, OutputState result) =>
Nat -> Maybe (Bool, Either a (ParsRec state result s p a)) -> OneDescr state result s p a -> AnaParser state result s p a
mkParser :: Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
mkParser length :: Nat
length zd :: Maybe (Bool, Either a (ParsRec state result s p a))
zd ~descr :: OneDescr state result s p a
descr@(OneDescr firsts :: Expecting s
firsts tab :: [(SymbolR s, TableEntry state result s p a)]
tab)
= let parstab :: [(SymbolR s, ParsRec state result s p a)]
parstab = ([(SymbolR s, ParsRec state result s p a)]
-> [(SymbolR s, ParsRec state result s p a)]
-> [(SymbolR s, ParsRec state result s p a)])
-> [[(SymbolR s, ParsRec state result s p a)]]
-> [(SymbolR s, ParsRec state result s p a)]
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 [(SymbolR s, ParsRec state result s p a)]
-> [(SymbolR s, ParsRec state result s p a)]
-> [(SymbolR s, ParsRec state result s p a)]
forall a (result :: * -> * -> *) s state p a.
(Ord a, Symbol a, OutputState result, Ord s) =>
[(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
mergeTables [[(SymbolR s
k, ParsRec state result s p a
p)]| (k :: SymbolR s
k, TableEntry p :: ParsRec state result s p a
p _) <- [(SymbolR s, TableEntry state result s p a)]
tab]
mkactualparser :: (ParsRec state result s p a -> t -> t -> Steps d s p)
-> t -> t -> Steps d s p
mkactualparser getp :: ParsRec state result s p a -> t -> t -> Steps d s p
getp
= let ptab :: [(SymbolR s, t -> t -> Steps d s p)]
ptab = [(SymbolR s
k, (ParsRec state result s p a -> t -> t -> Steps d s p
getp ParsRec state result s p a
pr) )| (k :: SymbolR s
k, pr :: ParsRec state result s p a
pr) <- [(SymbolR s, ParsRec state result s p a)]
parstab]
find :: s -> Maybe (t -> t -> Steps d s p)
find = case [(SymbolR s, t -> t -> Steps d s p)]
ptab of
[(s1 :: SymbolR s
s1, p1 :: t -> t -> Steps d s p
p1)] -> ({-# SCC "Locating" #-}\ s :: s
s -> if s -> Bool
r1 s
s then (t -> t -> Steps d s p) -> Maybe (t -> t -> Steps d s p)
forall a. a -> Maybe a
Just t -> t -> Steps d s p
p1 else Maybe (t -> t -> Steps d s p)
forall a. Maybe a
Nothing )
where r1 :: s -> Bool
r1 = SymbolR s -> s -> Bool
forall a. Ord a => SymbolR a -> a -> Bool
symInRange SymbolR s
s1
[(s1 :: SymbolR s
s1, p1 :: t -> t -> Steps d s p
p1), (s2 :: SymbolR s
s2, p2 :: t -> t -> Steps d s p
p2)] -> ({-# SCC "Locating" #-} \ s :: s
s -> if s -> Bool
r1 s
s then (t -> t -> Steps d s p) -> Maybe (t -> t -> Steps d s p)
forall a. a -> Maybe a
Just t -> t -> Steps d s p
p1 else
if s -> Bool
r2 s
s then (t -> t -> Steps d s p) -> Maybe (t -> t -> Steps d s p)
forall a. a -> Maybe a
Just t -> t -> Steps d s p
p2 else Maybe (t -> t -> Steps d s p)
forall a. Maybe a
Nothing)
where r1 :: s -> Bool
r1 = SymbolR s -> s -> Bool
forall a. Ord a => SymbolR a -> a -> Bool
symInRange SymbolR s
s1
r2 :: s -> Bool
r2 = SymbolR s -> s -> Bool
forall a. Ord a => SymbolR a -> a -> Bool
symInRange SymbolR s
s2
[(s1 :: SymbolR s
s1, p1 :: t -> t -> Steps d s p
p1), (s2 :: SymbolR s
s2, p2 :: t -> t -> Steps d s p
p2), (s3 :: SymbolR s
s3, p3 :: t -> t -> Steps d s p
p3)] -> ({-# SCC "Locating" #-}\ s :: s
s -> if s -> Bool
r1 s
s then (t -> t -> Steps d s p) -> Maybe (t -> t -> Steps d s p)
forall a. a -> Maybe a
Just t -> t -> Steps d s p
p1 else
if s -> Bool
r2 s
s then (t -> t -> Steps d s p) -> Maybe (t -> t -> Steps d s p)
forall a. a -> Maybe a
Just t -> t -> Steps d s p
p2 else
if s -> Bool
r3 s
s then (t -> t -> Steps d s p) -> Maybe (t -> t -> Steps d s p)
forall a. a -> Maybe a
Just t -> t -> Steps d s p
p3 else Maybe (t -> t -> Steps d s p)
forall a. Maybe a
Nothing)
where r1 :: s -> Bool
r1 = SymbolR s -> s -> Bool
forall a. Ord a => SymbolR a -> a -> Bool
symInRange SymbolR s
s1
r2 :: s -> Bool
r2 = SymbolR s -> s -> Bool
forall a. Ord a => SymbolR a -> a -> Bool
symInRange SymbolR s
s2
r3 :: s -> Bool
r3 = SymbolR s -> s -> Bool
forall a. Ord a => SymbolR a -> a -> Bool
symInRange SymbolR s
s3
_ -> BinSearchTree (SymbolR s, t -> t -> Steps d s p)
-> s -> Maybe (t -> t -> Steps d s p)
forall a b. Ord a => BinSearchTree (SymbolR a, b) -> a -> Maybe b
lookupSym ([(SymbolR s, t -> t -> Steps d s p)]
-> BinSearchTree (SymbolR s, t -> t -> Steps d s p)
forall av. [av] -> BinSearchTree av
tab2tree [(SymbolR s, t -> t -> Steps d s p)]
ptab)
zerop :: t -> t -> Steps d s p
zerop = ParsRec state result s p a -> t -> t -> Steps d s p
getp (case Maybe (Bool, Either a (ParsRec state result s p a))
zd of
Nothing -> ParsRec state result s p a
forall (a :: * -> * -> *) b c p d.
OutputState a =>
ParsRec b a c p d
libFail
Just (_, Left v :: a
v) -> a -> ParsRec state result s p a
forall (result :: * -> * -> *) a state s p.
OutputState result =>
a -> ParsRec state result s p a
libSucceed a
v
Just (_, Right p :: ParsRec state result s p a
p) -> ParsRec state result s p a
p
)
insertsyms :: t -> t -> Steps d s p
insertsyms = [t -> t -> Steps d s p] -> t -> t -> Steps d s p
forall a. [a] -> a
head [ ParsRec state result s p a -> t -> t -> Steps d s p
getp (Expecting s -> ParsRec state result s p a
pr Expecting s
firsts)| (_ , TableEntry _ pr :: Expecting s -> ParsRec state result s p a
pr) <- [(SymbolR s, TableEntry state result s p a)]
tab ]
correct :: t -> t -> Steps d s p
correct k :: t
k inp :: t
inp
= case t -> (# s, t #)
forall state s pos.
InputState state s pos =>
state -> (# s, state #)
splitState t
inp of
(# s :: s
s, ss :: t
ss #) -> let { msg :: Message s p
msg = Expecting s -> p -> Action s -> Message s p
forall sym pos.
Expecting sym -> pos -> Action sym -> Message sym pos
Msg Expecting s
firsts (t -> p
forall state s pos. InputState state s pos => state -> pos
getPosition t
inp) (s -> Action s
forall s. s -> Action s
Delete s
s)
; newinp :: t
newinp = s -> t -> t
forall state s pos. InputState state s pos => s -> state -> state
deleteSymbol s
s (Message s p -> t -> t
forall state s pos.
InputState state s pos =>
Message s pos -> state -> state
reportError Message s p
msg t
ss)
}
in Steps d s p -> Steps d s p -> (d -> d) -> (d -> d) -> Steps d s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libCorrect (Int# -> Message s p -> Steps d s p -> Steps d s p
forall val s p.
Int# -> Message s p -> Steps val s p -> Steps val s p
StRepair (s -> Int#
forall s. Symbol s => s -> Int#
deleteCost s
s) Message s p
msg (t -> t -> Steps d s p
result t
k t
newinp))
(t -> t -> Steps d s p
insertsyms t
k t
inp) d -> d
forall a. a -> a
id d -> d
forall a. a -> a
id
result :: t -> t -> Steps d s p
result = if [(SymbolR s, TableEntry state result s p a)] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(SymbolR s, TableEntry state result s p a)]
tab then t -> t -> Steps d s p
zerop
else case Maybe (Bool, Either a (ParsRec state result s p a))
zd of
Nothing ->({-# SCC "mkParser1" #-}\k :: t
k inp :: t
inp ->
case t -> Either' t s
forall state s pos.
InputState state s pos =>
state -> Either' state s
splitStateE t
inp of
Left' s :: s
s ss :: t
ss -> case s -> Maybe (t -> t -> Steps d s p)
find s
s of
Just p :: t -> t -> Steps d s p
p -> t -> t -> Steps d s p
p t
k t
inp
Nothing -> t -> t -> Steps d s p
correct t
k t
inp
Right' ss :: t
ss -> t -> t -> Steps d s p
insertsyms t
k t
ss)
Just (True, _) ->({-# SCC "mkParser2" #-}\k :: t
k inp :: t
inp ->
case t -> Either' t s
forall state s pos.
InputState state s pos =>
state -> Either' state s
splitStateE t
inp of
Left' s :: s
s ss :: t
ss -> case s -> Maybe (t -> t -> Steps d s p)
find s
s of
Just p :: t -> t -> Steps d s p
p -> t -> t -> Steps d s p
p t
k t
inp
Nothing -> let r :: Steps d s p
r = t -> t -> Steps d s p
zerop t
k t
inp
in if Steps d s p -> Bool
forall a s p. Steps a s p -> Bool
hasSuccess Steps d s p
r then Steps d s p
r else Steps d s p -> Steps d s p -> (d -> d) -> (d -> d) -> Steps d s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libCorrect Steps d s p
r (t -> t -> Steps d s p
correct t
k t
inp) d -> d
forall a. a -> a
id d -> d
forall a. a -> a
id
Right' ss :: t
ss -> t -> t -> Steps d s p
zerop t
k t
ss)
Just (False, _) ->({-# SCC "mkParser3" #-}\k :: t
k inp :: t
inp ->
case t -> Either' t s
forall state s pos.
InputState state s pos =>
state -> Either' state s
splitStateE t
inp of
Left' s :: s
s ss :: t
ss -> case s -> Maybe (t -> t -> Steps d s p)
find s
s of
Just p :: t -> t -> Steps d s p
p -> t -> t -> Steps d s p
p t
k t
inp Steps d s p -> Steps d s p -> Steps d s p
forall s b p. Ord s => Steps b s p -> Steps b s p -> Steps b s p
`libBest` t -> t -> Steps d s p
zerop t
k t
inp
Nothing -> let r :: Steps d s p
r = t -> t -> Steps d s p
zerop t
k t
inp
in if Steps d s p -> Bool
forall a s p. Steps a s p -> Bool
hasSuccess Steps d s p
r then Steps d s p
r else Steps d s p -> Steps d s p -> (d -> d) -> (d -> d) -> Steps d s p
forall s b p c d.
Ord s =>
Steps b s p -> Steps c s p -> (b -> d) -> (c -> d) -> Steps d s p
libCorrect Steps d s p
r (t -> t -> Steps d s p
correct t
k t
inp) d -> d
forall a. a -> a
id d -> d
forall a. a -> a
id
Right' ss :: t
ss -> t -> t -> Steps d s p
zerop t
k t
ss)
in t -> t -> Steps d s p
result
res :: ParsRec state result s p a
res = (RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ((forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P ( \ acc :: a -> r'' -> r'
acc -> (ParsRec state result s p a
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> (state -> Steps r'' s p) -> state -> Steps r' s p
forall t pos s p t d.
(InputState t s pos, InputState t s p, InputState t s p) =>
(ParsRec state result s p a -> t -> t -> Steps d s p)
-> t -> t -> Steps d s p
mkactualparser (\ (PR (P p :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p, _ , _)) -> (a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p a -> r'' -> r'
acc))
,(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R ( (ParsRec state result s p a
-> (state -> Steps r s p) -> state -> Steps r s p)
-> (state -> Steps r s p) -> state -> Steps r s p
forall t pos s p t d.
(InputState t s pos, InputState t s p, InputState t s p) =>
(ParsRec state result s p a -> t -> t -> Steps d s p)
-> t -> t -> Steps d s p
mkactualparser (\ (PR (_ , R p :: forall r. (state -> Steps r s p) -> state -> Steps r s p
p, _)) -> (state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
p ))
)
in ParsRec state result s p a
-> Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
AnaParser ParsRec state result s p a
res Nat
length Maybe (Bool, Either a (ParsRec state result s p a))
zd OneDescr state result s p a
descr
data Nat = Zero
| Succ Nat
| Infinite
deriving (Nat -> Nat -> Bool
(Nat -> Nat -> Bool) -> (Nat -> Nat -> Bool) -> Eq Nat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Nat -> Nat -> Bool
$c/= :: Nat -> Nat -> Bool
== :: Nat -> Nat -> Bool
$c== :: Nat -> Nat -> Bool
Eq, Int -> Nat -> ShowS
[Nat] -> ShowS
Nat -> [Char]
(Int -> Nat -> ShowS)
-> (Nat -> [Char]) -> ([Nat] -> ShowS) -> Show Nat
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Nat] -> ShowS
$cshowList :: [Nat] -> ShowS
show :: Nat -> [Char]
$cshow :: Nat -> [Char]
showsPrec :: Int -> Nat -> ShowS
$cshowsPrec :: Int -> Nat -> ShowS
Show)
nat_le :: Nat -> Nat -> Bool
nat_le Zero _ = Bool
True
nat_le _ Zero = Bool
False
nat_le Infinite _ = Bool
False
nat_le _ Infinite = Bool
True
nat_le (Succ l :: Nat
l) (Succ r :: Nat
r) = Nat -> Nat -> Bool
nat_le Nat
l Nat
r
nat_min :: Nat -> Nat -> (Nat, (b -> b -> c) -> b -> b -> c)
nat_min Infinite r :: Nat
r = (Nat
r, (b -> b -> c) -> b -> b -> c
forall a b c. (a -> b -> c) -> b -> a -> c
flip)
nat_min l :: Nat
l Infinite = (Nat
l, (b -> b -> c) -> b -> b -> c
forall a. a -> a
id)
nat_min Zero _ = (Nat
Zero, (b -> b -> c) -> b -> b -> c
forall a. a -> a
id)
nat_min _ Zero = (Nat
Zero, (b -> b -> c) -> b -> b -> c
forall a b c. (a -> b -> c) -> b -> a -> c
flip)
nat_min (Succ ll :: Nat
ll) (Succ rr :: Nat
rr) = let (v :: Nat
v, fl :: (b -> b -> c) -> b -> b -> c
fl) = Nat
ll Nat -> Nat -> (Nat, (b -> b -> c) -> b -> b -> c)
`nat_min` Nat
rr in (Nat -> Nat
Succ Nat
v, (b -> b -> c) -> b -> b -> c
fl)
nat_add :: Nat -> Nat -> Nat
nat_add Infinite _ = Nat
Infinite
nat_add Zero r :: Nat
r = Nat
r
nat_add (Succ l :: Nat
l) r :: Nat
r = Nat -> Nat
Succ (Nat -> Nat -> Nat
nat_add Nat
l Nat
r)
mergeTables :: [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
mergeTables l :: [(SymbolR a, ParsRec state result s p a)]
l [] = [(SymbolR a, ParsRec state result s p a)]
l
mergeTables [] r :: [(SymbolR a, ParsRec state result s p a)]
r = [(SymbolR a, ParsRec state result s p a)]
r
mergeTables lss :: [(SymbolR a, ParsRec state result s p a)]
lss@(l :: (SymbolR a, ParsRec state result s p a)
l@(le :: SymbolR a
le@(Range a :: a
a b :: a
b),ct :: ParsRec state result s p a
ct ):ls :: [(SymbolR a, ParsRec state result s p a)]
ls) rss :: [(SymbolR a, ParsRec state result s p a)]
rss@(r :: (SymbolR a, ParsRec state result s p a)
r@(re :: SymbolR a
re@(Range c :: a
c d :: a
d),ct' :: ParsRec state result s p a
ct'):rs :: [(SymbolR a, ParsRec state result s p a)]
rs)
= let ct'' :: ParsRec state result s p a
ct'' = ParsRec state result s p a
ct ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
forall (result :: * -> * -> *) s state (result :: * -> * -> *) p a
(result :: * -> * -> *).
(OutputState result, Ord s) =>
ParsRec state result s p a
-> ParsRec state result s p a -> ParsRec state result s p a
`libOr` ParsRec state result s p a
ct'
in if a
ca -> a -> Bool
forall a. Ord a => a -> a -> Bool
<a
a then [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
mergeTables [(SymbolR a, ParsRec state result s p a)]
rss [(SymbolR a, ParsRec state result s p a)]
lss
else if a
ba -> a -> Bool
forall a. Ord a => a -> a -> Bool
<a
c then (SymbolR a, ParsRec state result s p a)
l(SymbolR a, ParsRec state result s p a)
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
forall a. a -> [a] -> [a]
:[(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
mergeTables [(SymbolR a, ParsRec state result s p a)]
ls [(SymbolR a, ParsRec state result s p a)]
rss
else if a
aa -> a -> Bool
forall a. Ord a => a -> a -> Bool
<a
c then (a -> a -> SymbolR a
forall s. s -> s -> SymbolR s
Range a
a (a -> a
forall s. Symbol s => s -> s
symBefore a
c),ParsRec state result s p a
ct) (SymbolR a, ParsRec state result s p a)
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
forall a. a -> [a] -> [a]
:[(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
mergeTables ((a -> a -> SymbolR a
forall s. s -> s -> SymbolR s
Range a
c a
b,ParsRec state result s p a
ct)(SymbolR a, ParsRec state result s p a)
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
forall a. a -> [a] -> [a]
:[(SymbolR a, ParsRec state result s p a)]
ls) [(SymbolR a, ParsRec state result s p a)]
rss
else if a
ba -> a -> Bool
forall a. Ord a => a -> a -> Bool
<a
d then (a -> a -> SymbolR a
forall s. s -> s -> SymbolR s
Range a
a a
b,ParsRec state result s p a
ct'') (SymbolR a, ParsRec state result s p a)
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
forall a. a -> [a] -> [a]
:[(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
mergeTables ((a -> a -> SymbolR a
forall s. s -> s -> SymbolR s
Range (a -> a
forall s. Symbol s => s -> s
symAfter a
b) a
d,ParsRec state result s p a
ct')(SymbolR a, ParsRec state result s p a)
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
forall a. a -> [a] -> [a]
:[(SymbolR a, ParsRec state result s p a)]
rs) [(SymbolR a, ParsRec state result s p a)]
ls
else if a
ba -> a -> Bool
forall a. Ord a => a -> a -> Bool
>a
d then [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
mergeTables [(SymbolR a, ParsRec state result s p a)]
rss [(SymbolR a, ParsRec state result s p a)]
lss
else (SymbolR a
le,ParsRec state result s p a
ct'') (SymbolR a, ParsRec state result s p a)
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
forall a. a -> [a] -> [a]
: [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
-> [(SymbolR a, ParsRec state result s p a)]
mergeTables [(SymbolR a, ParsRec state result s p a)]
ls [(SymbolR a, ParsRec state result s p a)]
rs
libMap :: OutputState result =>
(forall r r'' . (b -> r -> r'') -> state -> Steps (a, r) s p -> ( state, Steps r'' s p))
-> (forall r . state -> Steps ( r) s p -> ( state, Steps r s p))
-> ParsRec state result s p a -> ParsRec state result s p b
libMap :: (forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p))
-> (forall r. state -> Steps r s p -> (state, Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
libMap f :: forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p)
f f' :: forall r. state -> Steps r s p -> (state, Steps r s p)
f' (PR (P p :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p, R r :: forall r. (state -> Steps r s p) -> state -> Steps r s p
r, _)) = (RealParser state s p b, RealRecogn state s p)
-> ParsRec state result s p b
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ( (forall r' r''.
(b -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p b
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P(\acc :: b -> r'' -> r'
acc -> let pp :: (state -> Steps b s p) -> state -> Steps (a, b) s p
pp = (a -> b -> (a, b))
-> (state -> Steps b s p) -> state -> Steps (a, b) s p
forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p (,)
facc :: state -> Steps (a, r'') s p -> (state, Steps r' s p)
facc = (b -> r'' -> r')
-> state -> Steps (a, r'') s p -> (state, Steps r' s p)
forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p)
f b -> r'' -> r'
acc
in \ k :: state -> Steps r'' s p
k instate :: state
instate -> let inresult :: Steps (a, r'') s p
inresult = (state -> Steps r'' s p) -> state -> Steps (a, r'') s p
forall b. (state -> Steps b s p) -> state -> Steps (a, b) s p
pp state -> Steps r'' s p
k state
outstate
(outstate :: state
outstate, outresult :: Steps r' s p
outresult) = state -> Steps (a, r'') s p -> (state, Steps r' s p)
facc state
instate Steps (a, r'') s p
inresult
in Steps r' s p
outresult
)
, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R(\ k :: state -> Steps r s p
k instate :: state
instate -> let inresult :: Steps r s p
inresult = (state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
r state -> Steps r s p
k state
outstate
(outstate :: state
outstate, outresult :: Steps r s p
outresult) = state -> Steps r s p -> (state, Steps r s p)
forall r. state -> Steps r s p -> (state, Steps r s p)
f' state
instate Steps r s p
inresult
in Steps r s p
outresult)
)
pMap :: OutputState result =>
(forall r r'' . (b -> r -> r'') -> state -> Steps (a, r) s p -> ( state, Steps r'' s p))
-> (forall r . state -> Steps ( r) s p -> ( state, Steps r s p))
-> AnaParser state result s p a -> AnaParser state result s p b
pMap :: (forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p))
-> (forall r. state -> Steps r s p -> (state, Steps r s p))
-> AnaParser state result s p a
-> AnaParser state result s p b
pMap f :: forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p)
f f' :: forall r. state -> Steps r s p -> (state, Steps r s p)
f' (AnaParser p :: ParsRec state result s p a
p l :: Nat
l z :: Maybe (Bool, Either a (ParsRec state result s p a))
z o :: OneDescr state result s p a
o) = ParsRec state result s p b
-> Nat
-> Maybe (Bool, Either b (ParsRec state result s p b))
-> OneDescr state result s p b
-> AnaParser state result s p b
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
AnaParser ((forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p))
-> (forall r. state -> Steps r s p -> (state, Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
forall (result :: * -> * -> *) b state a s p.
OutputState result =>
(forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p))
-> (forall r. state -> Steps r s p -> (state, Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
libMap forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p)
f forall r. state -> Steps r s p -> (state, Steps r s p)
f' ParsRec state result s p a
p)
Nat
l
(case Maybe (Bool, Either a (ParsRec state result s p a))
z of
Nothing -> Maybe (Bool, Either b (ParsRec state result s p b))
forall a. Maybe a
Nothing
Just (b :: Bool
b, v :: Either a (ParsRec state result s p a)
v) -> (Bool, Either b (ParsRec state result s p b))
-> Maybe (Bool, Either b (ParsRec state result s p b))
forall a. a -> Maybe a
Just (Bool
b, case Either a (ParsRec state result s p a)
v of
Left w :: a
w -> ParsRec state result s p b -> Either b (ParsRec state result s p b)
forall a b. b -> Either a b
Right ((forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p))
-> (forall r. state -> Steps r s p -> (state, Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
forall (result :: * -> * -> *) b state a s p.
OutputState result =>
(forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p))
-> (forall r. state -> Steps r s p -> (state, Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
libMap forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p)
f forall r. state -> Steps r s p -> (state, Steps r s p)
f' (a -> ParsRec state result s p a
forall (result :: * -> * -> *) a state s p.
OutputState result =>
a -> ParsRec state result s p a
libSucceed a
w))
Right pp :: ParsRec state result s p a
pp -> ParsRec state result s p b -> Either b (ParsRec state result s p b)
forall a b. b -> Either a b
Right ((forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p))
-> (forall r. state -> Steps r s p -> (state, Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
forall (result :: * -> * -> *) b state a s p.
OutputState result =>
(forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p))
-> (forall r. state -> Steps r s p -> (state, Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
libMap forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p)
f forall r. state -> Steps r s p -> (state, Steps r s p)
f' ParsRec state result s p a
pp)))
((ParsRec state result s p a -> ParsRec state result s p b)
-> OneDescr state result s p a -> OneDescr state result s p b
forall state (result :: * -> * -> *) s p a state
(result :: * -> * -> *) p a.
(ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
mapOnePars ((forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p))
-> (forall r. state -> Steps r s p -> (state, Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
forall (result :: * -> * -> *) b state a s p.
OutputState result =>
(forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p))
-> (forall r. state -> Steps r s p -> (state, Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
libMap forall r r''.
(b -> r -> r'')
-> state -> Steps (a, r) s p -> (state, Steps r'' s p)
f forall r. state -> Steps r s p -> (state, Steps r s p)
f') OneDescr state result s p a
o)
libWrap :: OutputState result =>
(forall r r'' . (b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r . state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> ParsRec state result s p a -> ParsRec state result s p b
libWrap :: (forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
libWrap f :: forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p)
f f' :: forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p)
f' (PR (P p :: forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p, R r :: forall r. (state -> Steps r s p) -> state -> Steps r s p
r, _)) = (RealParser state s p b, RealRecogn state s p)
-> ParsRec state result s p b
forall (result :: * -> * -> *) state s p a.
OutputState result =>
(RealParser state s p a, RealRecogn state s p)
-> ParsRec state result s p a
mkPR ( (forall r' r''.
(b -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p b
forall state s p a.
(forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p)
-> RealParser state s p a
P(\ acc :: b -> r'' -> r'
acc -> let pp :: (state -> Steps b s p) -> state -> Steps (a, b) s p
pp = (a -> b -> (a, b))
-> (state -> Steps b s p) -> state -> Steps (a, b) s p
forall r' r''.
(a -> r'' -> r')
-> (state -> Steps r'' s p) -> state -> Steps r' s p
p (,)
facc :: state
-> Steps (a, r'') s p
-> (state -> Steps r'' s p)
-> (state, Steps r' s p, state -> Steps r'' s p)
facc = (b -> r'' -> r')
-> state
-> Steps (a, r'') s p
-> (state -> Steps r'' s p)
-> (state, Steps r' s p, state -> Steps r'' s p)
forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p)
f b -> r'' -> r'
acc
in \ k :: state -> Steps r'' s p
k instate :: state
instate -> let (stl :: state
stl, ar :: Steps r' s p
ar, str2rr :: state -> Steps r'' s p
str2rr) = state
-> Steps (a, r'') s p
-> (state -> Steps r'' s p)
-> (state, Steps r' s p, state -> Steps r'' s p)
facc state
instate Steps (a, r'') s p
rl state -> Steps r'' s p
k
rl :: Steps (a, r'') s p
rl = (state -> Steps r'' s p) -> state -> Steps (a, r'') s p
forall b. (state -> Steps b s p) -> state -> Steps (a, b) s p
pp state -> Steps r'' s p
str2rr state
stl
in Steps r' s p
ar
)
, (forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
forall state s p.
(forall r. (state -> Steps r s p) -> state -> Steps r s p)
-> RealRecogn state s p
R(\ k :: state -> Steps r s p
k instate :: state
instate -> let (stl :: state
stl, ar :: Steps r s p
ar, str2rr :: state -> Steps r s p
str2rr) = state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p)
forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p)
f' state
instate Steps r s p
rl state -> Steps r s p
k
rl :: Steps r s p
rl = (state -> Steps r s p) -> state -> Steps r s p
forall r. (state -> Steps r s p) -> state -> Steps r s p
r state -> Steps r s p
str2rr state
stl
in Steps r s p
ar)
)
pWrap :: OutputState result
=> (forall r r'' . (b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r . state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> AnaParser state result s p a -> AnaParser state result s p b
pWrap :: (forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> AnaParser state result s p a
-> AnaParser state result s p b
pWrap f :: forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p)
f f' :: forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p)
f' (AnaParser p :: ParsRec state result s p a
p l :: Nat
l z :: Maybe (Bool, Either a (ParsRec state result s p a))
z o :: OneDescr state result s p a
o) = ParsRec state result s p b
-> Nat
-> Maybe (Bool, Either b (ParsRec state result s p b))
-> OneDescr state result s p b
-> AnaParser state result s p b
forall state (result :: * -> * -> *) s p a.
ParsRec state result s p a
-> Nat
-> Maybe (Bool, Either a (ParsRec state result s p a))
-> OneDescr state result s p a
-> AnaParser state result s p a
AnaParser ((forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
forall (result :: * -> * -> *) b state a s p.
OutputState result =>
(forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
libWrap forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p)
f forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p)
f' ParsRec state result s p a
p)
Nat
l
(case Maybe (Bool, Either a (ParsRec state result s p a))
z of
Nothing -> Maybe (Bool, Either b (ParsRec state result s p b))
forall a. Maybe a
Nothing
Just (b :: Bool
b, v :: Either a (ParsRec state result s p a)
v) -> (Bool, Either b (ParsRec state result s p b))
-> Maybe (Bool, Either b (ParsRec state result s p b))
forall a. a -> Maybe a
Just (Bool
b, case Either a (ParsRec state result s p a)
v of
Left w :: a
w -> ParsRec state result s p b -> Either b (ParsRec state result s p b)
forall a b. b -> Either a b
Right ((forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
forall (result :: * -> * -> *) b state a s p.
OutputState result =>
(forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
libWrap forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p)
f forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p)
f' (a -> ParsRec state result s p a
forall (result :: * -> * -> *) a state s p.
OutputState result =>
a -> ParsRec state result s p a
libSucceed a
w))
Right pp :: ParsRec state result s p a
pp -> ParsRec state result s p b -> Either b (ParsRec state result s p b)
forall a b. b -> Either a b
Right ((forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
forall (result :: * -> * -> *) b state a s p.
OutputState result =>
(forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
libWrap forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p)
f forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p)
f' ParsRec state result s p a
pp)))
((ParsRec state result s p a -> ParsRec state result s p b)
-> OneDescr state result s p a -> OneDescr state result s p b
forall state (result :: * -> * -> *) s p a state
(result :: * -> * -> *) p a.
(ParsRec state result s p a -> ParsRec state result s p a)
-> OneDescr state result s p a -> OneDescr state result s p a
mapOnePars ((forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
forall (result :: * -> * -> *) b state a s p.
OutputState result =>
(forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p))
-> (forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p))
-> ParsRec state result s p a
-> ParsRec state result s p b
libWrap forall r r''.
(b -> r -> r'')
-> state
-> Steps (a, r) s p
-> (state -> Steps r s p)
-> (state, Steps r'' s p, state -> Steps r s p)
f forall r.
state
-> Steps r s p
-> (state -> Steps r s p)
-> (state, Steps r s p, state -> Steps r s p)
f') OneDescr state result s p a
o)
lookupSym :: Ord a => BinSearchTree (SymbolR a, b) -> a -> Maybe b
lookupSym :: BinSearchTree (SymbolR a, b) -> a -> Maybe b
lookupSym = (SymbolR a -> a -> Ordering)
-> BinSearchTree (SymbolR a, b) -> a -> Maybe b
forall a b c.
(a -> b -> Ordering) -> BinSearchTree (a, c) -> b -> Maybe c
btFind SymbolR a -> a -> Ordering
forall a. Ord a => SymbolR a -> a -> Ordering
symRS