License  GPL2 

Maintainer  yidevel@googlegroups.com 
Stability  experimental 
Portability  portable 
Safe Haskell  None 
Language  Haskell2010 
Extensions 

This is a library of interactive processes combinators, usable to define extensible keymaps.
(Inspired by the Parsec library, written by Koen Claessen)
The processes are:
 composable: in parallel using
<>
, in sequence using monadic bind.  extensible: it is always possible to override a behaviour by combination of
adjustPriority
and<>
. (See also<
for a convenient combination of the two.)  monadic: sequencing is done via monadic bind. (leveraging the whole battery of monadic tools that Haskell provides)
The processes can parse input, and write output that depends on it.
The semantics are quite obvious; only disjunction deserve a bit more explanation:
in p = (a
, what happens if <>
b)a
and b
recognize the same
input (prefix), but produce conflicting output?
 if the output is the same (as by the Eq class), then the processes (prefixes) are "merged"
 if a Write is more prioritized than the other, the one with low priority will be discarded
 otherwise, the output will be delayed until one of the branches can be discarded.
 if there is no way to disambiguate, then no output will be generated anymore.
This situation can be detected by using
possibleActions
however.
Synopsis
 data I ev w a
 data P event w
 data InteractState event w
 class (Eq w, Monad m, Alternative m, Applicative m, MonadPlus m) => MonadInteract m w e  m > w e where
 write :: w > m ()
 eventBounds :: Ord e => Maybe e > Maybe e > m e
 adjustPriority :: Int > m ()
 deprioritize :: MonadInteract f w e => f ()
 important :: MonadInteract f w e => f a > f a > f a
 (<) :: MonadInteract f w e => f a > f a > f a
 (>) :: MonadInteract f w e => f a > f a > f a
 option :: MonadInteract m w e => a > m a > m a
 oneOf :: (Ord event, MonadInteract m w event, MonadFail m) => [event] > m event
 processOneEvent :: Eq w => P event w > event > ([w], P event w)
 computeState :: Eq w => P event w > InteractState event w
 event :: (Ord event, MonadInteract m w event) => event > m event
 events :: (Ord event, MonadInteract m w event) => [event] > m [event]
 choice :: (MonadInteract m w e, MonadFail m) => [m a] > m a
 mkAutomaton :: Eq w => I ev w a > P ev w
 idAutomaton :: (Ord a, Eq a) => P a a
 runWrite :: Eq w => P event w > [event] > [w]
 anyEvent :: (Ord event, MonadInteract m w event) => m event
 eventBetween :: (Ord e, MonadInteract m w e) => e > e > m e
 accepted :: Show ev => Int > P ev w > [[Text]]
Documentation
Interactive process description
Operational representation of a process
data InteractState event w Source #
Abstraction of the automaton state.
Instances
Semigroup (InteractState event w) Source #  
Defined in Yi.Interact (<>) :: InteractState event w > InteractState event w > InteractState event w # sconcat :: NonEmpty (InteractState event w) > InteractState event w # stimes :: Integral b => b > InteractState event w > InteractState event w #  
Monoid (InteractState event w) Source #  
Defined in Yi.Interact mempty :: InteractState event w # mappend :: InteractState event w > InteractState event w > InteractState event w # mconcat :: [InteractState event w] > InteractState event w # 
class (Eq w, Monad m, Alternative m, Applicative m, MonadPlus m) => MonadInteract m w e  m > w e where Source #
Abstraction of monadic interactive processes
Outputs a result.
eventBounds :: Ord e => Maybe e > Maybe e > m e Source #
Consumes and returns the next character. Fails if there is no input left, or outside the given bounds.
adjustPriority :: Int > m () Source #
Instances
MonadInteract m w e => MonadInteract (StateT s m) w e Source #  
Eq w => MonadInteract (I event w) w event Source #  
deprioritize :: MonadInteract f w e => f () Source #
important :: MonadInteract f w e => f a > f a > f a Source #
Just like (<)
but in prefix form. It deprioritize
s the
second argument.
(<) :: MonadInteract f w e => f a > f a > f a infixl 3 Source #
(>) :: MonadInteract f w e => f a > f a > f a Source #
option :: MonadInteract m w e => a > m a > m a Source #
option x p
will either parse p
or return x
without consuming
any input.
computeState :: Eq w => P event w > InteractState event w Source #
event :: (Ord event, MonadInteract m w event) => event > m event Source #
Parses and returns the specified character.
events :: (Ord event, MonadInteract m w event) => [event] > m [event] Source #
Parses and returns the specified list of events (lazily).
choice :: (MonadInteract m w e, MonadFail m) => [m a] > m a Source #
Combines all parsers in the specified list.
anyEvent :: (Ord event, MonadInteract m w event) => m event Source #
eventBetween :: (Ord e, MonadInteract m w e) => e > e > m e Source #