{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE ImpredicativeTypes #-}
{-# LANGUAGE UndecidableInstances #-}

-- | This module declares common high-level format-descriptor classes which are
-- largely independent from the particular backend. Classes in this module are
-- abstract over the type of token that you parse or print. Classes specialised
-- to certain tokens can be found in "Text.Pup.Class.Char".
--
-- The relevant class are re-exported by the modules which define backends. So
-- unless you are defining a new backend, you shouldn't have to import this
-- module.
--
-- Many docstrings in this module are adapted from Megparsec (see
-- "Text.Megaparsec") and Prettyprinter (see "Prettyprinter").
module Text.Pup.Class
  ( -- * Basic token format descriptors
    Tokens (..),
    (<?>),
    chunk,
    anySingle,
    anySingleBut,
    oneOf,
    noneOf,
    takeRest,
    atEnd,

    -- * Breaks
    Breaks (..),

    -- * Wadler-Leijen-style grouping
    WadlerLeijen (..),

    -- * Look-ahead descriptors
    LookAhead (..),

    -- * Semantic tagging
    Annotations (..),

    -- * Parse errors
    ParseErrors (..),

    -- * Deriving-via
    Trivial (..),
  )
where

import Control.Additive
import Control.Monad.Indexed qualified as Indexed
import Control.Monad.Indexed.Cont2 qualified as Cont2
import Data.Functor

-- | This class declares the basic format descriptors for tokens (what the
-- theory of grammars call terminals).
class (Eq tok, Eq chunk) => Tokens tok chunk m | m -> tok chunk where
  -- | As a parser, only succeeds at the end of input. No-op as a printer.
  eof :: m r r ()

  -- | As a parser, @'single' t@ only matches the single token @t@. As a
  -- printer, @'single' t@  prints the token @t@.
  --
  -- > semicolon = single ';'
  --
  -- See also: 'token', 'anySingle', 'Text.Pup.Class.Char'.
  single :: tok -> m r r tok

  -- | As a parser @'satisfy' p@ succeeds for any token for which the supplied
  -- predicate pf@ returns 'True'. As a printer @'satisfy' p@ prints its input
  -- token, provided predicate @p@ returns 'True', and fails otherwise.
  --
  -- > digitChar = satisfy isDigit <?> "digit"
  -- > oneOf cs  = satisfy (`elem` cs)
  --
  -- See also: 'anySingle', 'anySingleBut', 'oneOf', 'noneOf'.
  satisfy :: (tok -> Bool) -> m (tok -> r) r tok

  -- | As a parser @'tokens' test chk@ takes chunk @chk'@ of input of length @length
  -- chk@ and returns @chk'@ if the equality test @test chk chk'@ succeeds, and
  -- fails otherwise. As a printer, @'tokens' test chk@ prints its input chunk
  -- @chk'@ provided that @length chk' = length chk@ and the equality test @test
  -- chk chk'@ succeeds, and fails otherwise.
  --
  -- This can be used for example to write 'chunk':
  --
  -- > chunk = tokens (==)
  tokens ::
    -- | Predicate to check equality of chunks
    (chunk -> chunk -> Bool) ->
    -- | Chunk of input to match against
    chunk ->
    m (chunk -> r) r chunk

  -- | As a parser, parses /zero/ or more tokens for which the supplied
  -- predicate holds. As a printer, prints its input chunk of tokens, provided
  -- that each token in the chunk satisfies the predicate.
  --
  -- This is an optimised variant of a format descriptor built with
  -- 'Control.Monad.Indexed.Cont2.many':
  --
  -- > takeWhileP (Just "foo") f = many (satisfy f <?> "foo")
  -- > takeWhileP Nothing      f = many (satisfy f)
  --
  -- The parser side never fails, although it may parse the empty chunk.
  takeWhileP ::
    -- | (Optional) name for a single token, can be used in error messages
    Maybe String ->
    -- | Predicate to use to test tokens
    (tok -> Bool) ->
    m (chunk -> r) r chunk

  -- | Similar to 'takeWhileP', but fails if it can't parse or print at least one
  -- token.
  --
  -- This is an optimised variant of a format descriptor built with
  -- 'Control.Monad.Indexed.Cont2.some':
  --
  -- > takeWhile1P (Just "foo") f = some (satisfy f <?> "foo")
  -- > takeWhile1P Nothing      f = some (satisfy f)
  takeWhile1P ::
    -- | (Optional) name for a single token, can be used in error messages
    Maybe String ->
    -- | Predicate to use to test tokens
    (tok -> Bool) ->
    m (chunk -> r) r chunk

  -- | As a parser @takeP lbl n@ returns the next @n@ tokens from the input (it
  -- fails if there are not enough tokens in the input). As a printer, it
  -- prints its input chunk of tokens, provided that the chunk has exactly @n@
  -- tokens.
  takeP ::
    -- | Name for a single token in the row
    Maybe String ->
    -- | How many tokens to extract
    Int ->
    m (chunk -> r) r chunk

  -- | @'label' lbl p@ gives a name to the next token expected by @p@. This is
  -- only really useful for the parser side, where it can be used to report
  -- error messages of the form “unexpected ..., expected lbl”.
  label :: String -> m r r' a -> m r r' a

  -- | @'hidden' p@ silences error messages of the form “unexpected ...,
  -- expected ...” in @p@ (only relevant on the parser side).
  hidden :: m r r' a -> m r r' a
  hidden = String -> m r r' a -> m r r' a
forall r r' a. String -> m r r' a -> m r r' a
forall tok chunk (m :: * -> * -> * -> *) r r' a.
Tokens tok chunk m =>
String -> m r r' a -> m r r' a
label String
""

-- | A synonym for 'label' in the form of an operator.
(<?>) :: (Tokens chunk tok m) => m r r' a -> String -> m r r' a
<?> :: forall chunk tok (m :: * -> * -> * -> *) r r' a.
Tokens chunk tok m =>
m r r' a -> String -> m r r' a
(<?>) = (String -> m r r' a -> m r r' a) -> m r r' a -> String -> m r r' a
forall a b c. (a -> b -> c) -> b -> a -> c
flip String -> m r r' a -> m r r' a
forall r r' a. String -> m r r' a -> m r r' a
forall tok chunk (m :: * -> * -> * -> *) r r' a.
Tokens tok chunk m =>
String -> m r r' a -> m r r' a
label
{-# INLINE (<?>) #-}

infix 0 <?>

-- | Parses/prints a single token.
--
-- > anySingle = satisfy (const True)
--
-- See also: 'satisfy', 'anySingleBut'.
anySingle :: (Tokens tok chunk m) => m (tok -> r) r (tok)
anySingle :: forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
m (tok -> r) r tok
anySingle = (tok -> Bool) -> m (tok -> r) r tok
forall r. (tok -> Bool) -> m (tok -> r) r tok
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
(tok -> Bool) -> m (tok -> r) r tok
satisfy (Bool -> tok -> Bool
forall a b. a -> b -> a
const Bool
True)
{-# INLINE anySingle #-}

-- | Parse/print any token but the given one. It's a good idea to attach a
-- 'label' to this format descriptor.
--
-- > anySingleBut t = satisfy (/= t)
--
-- See also: 'single', 'anySingle', 'satisfy'.
anySingleBut ::
  (Tokens tok chunk m) =>
  -- | Token we should not match
  tok ->
  m (tok -> r) r tok
anySingleBut :: forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
tok -> m (tok -> r) r tok
anySingleBut tok
t = (tok -> Bool) -> m (tok -> r) r tok
forall r. (tok -> Bool) -> m (tok -> r) r tok
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
(tok -> Bool) -> m (tok -> r) r tok
satisfy (tok -> tok -> Bool
forall a. Eq a => a -> a -> Bool
/= tok
t)
{-# INLINE anySingleBut #-}

-- | @'oneOf' ts@ parses/prints any token from @ts@. Note that, as a parser,
-- @'oneOf' ts@ can't automatically generate “expected” tokens in error
-- messages, so you should usually label it manually with 'label' or ('<?>').
--
-- > oneOf cs = satisfy (`elem` cs)
--
-- See also: 'satisfy'.
--
-- > digit = oneOf ['0'..'9'] <?> "digit"
oneOf ::
  (Foldable f, Tokens tok chunk m) =>
  -- | Collection of matching tokens
  f tok ->
  m (tok -> r) r tok
oneOf :: forall (f :: * -> *) tok chunk (m :: * -> * -> * -> *) r.
(Foldable f, Tokens tok chunk m) =>
f tok -> m (tok -> r) r tok
oneOf f tok
cs = (tok -> Bool) -> m (tok -> r) r tok
forall r. (tok -> Bool) -> m (tok -> r) r tok
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
(tok -> Bool) -> m (tok -> r) r tok
satisfy (\tok
x -> tok -> f tok -> Bool
forall a. Eq a => a -> f a -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
elem tok
x f tok
cs)
{-# INLINE oneOf #-}

-- | As the dual of 'oneOf', @'noneOf' ts@ succeeds and parses/prints the
-- current token if the current token /isn't/ in @ts@.
-- Note that, as a parser, @'oneOf' ts@ can't automatically generate “expected”
-- tokens in error messages, so you should usually label it manually with
-- 'label' or ('<?>').
--
-- > noneOf cs = satisfy (`notElem` cs)
--
-- See also: 'satisfy'.
noneOf ::
  (Foldable f, Tokens tok chunk m) =>
  -- | Collection of taken we should not match
  f tok ->
  m (tok -> r) r tok
noneOf :: forall (f :: * -> *) tok chunk (m :: * -> * -> * -> *) r.
(Foldable f, Tokens tok chunk m) =>
f tok -> m (tok -> r) r tok
noneOf f tok
cs = (tok -> Bool) -> m (tok -> r) r tok
forall r. (tok -> Bool) -> m (tok -> r) r tok
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
(tok -> Bool) -> m (tok -> r) r tok
satisfy (\tok
x -> tok -> f tok -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
notElem tok
x f tok
cs)
{-# INLINE noneOf #-}

-- | @'chunk' chk@ only matches the chunk @chk@.
--
-- > divOrMod = chunk "div" <|> chunk "mod"
--
-- When @tok@ is 'Char', it's customary for format descriptors to implement
-- the 'IsString' class with @'fromString' = 'chunk'@.
--
-- See also: 'tokens', 'Text.Pup.Class.Char.string'.
chunk ::
  (Indexed.Applicative m, Cont2.Stacked m, Tokens tok chunk m) =>
  -- | Chunk to match
  chunk ->
  m r r ()
chunk :: forall (m :: * -> * -> * -> *) tok chunk r.
(Applicative m, Stacked m, Tokens tok chunk m) =>
chunk -> m r r ()
chunk chunk
s = m r r chunk -> m r r ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (m r r chunk -> m r r ()) -> m r r chunk -> m r r ()
forall a b. (a -> b) -> a -> b
$ (chunk -> chunk -> Bool) -> chunk -> m (chunk -> r) r chunk
forall r.
(chunk -> chunk -> Bool) -> chunk -> m (chunk -> r) r chunk
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
(chunk -> chunk -> Bool) -> chunk -> m (chunk -> r) r chunk
tokens chunk -> chunk -> Bool
forall a. Eq a => a -> a -> Bool
(==) chunk
s m (chunk -> r) r chunk -> chunk -> m r r chunk
forall (m :: * -> * -> * -> *) a i j b.
(Applicative m, Stacked m) =>
m (a -> i) j b -> a -> m i j b
Cont2.@ chunk
s
{-# INLINE chunk #-}

-- | As a parser, consume the rest of the input and return it as a chunk. As a parser
-- 'takeRest' never fails, but may return the empty chunk. As a printer,
-- 'takeRest' simply prints its input chunk.
--
-- > takeRest = takeWhileP Nothing (const True)
takeRest :: (Tokens tok chunk m) => m (chunk -> r) r chunk
takeRest :: forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
m (chunk -> r) r chunk
takeRest = Maybe String -> (tok -> Bool) -> m (chunk -> r) r chunk
forall r. Maybe String -> (tok -> Bool) -> m (chunk -> r) r chunk
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
Maybe String -> (tok -> Bool) -> m (chunk -> r) r chunk
takeWhileP Maybe String
forall a. Maybe a
Nothing (Bool -> tok -> Bool
forall a b. a -> b -> a
const Bool
True)
{-# INLINE takeRest #-}

-- | Return 'True' when end of input has been reached.
--
-- > atEnd = option False (True <$ hidden eof)
atEnd :: (Indexed.Alternative m, Tokens tok chunk m) => m r r Bool
atEnd :: forall (m :: * -> * -> * -> *) tok chunk r.
(Alternative m, Tokens tok chunk m) =>
m r r Bool
atEnd = (Bool
True Bool -> m r r () -> m r r Bool
forall a b. a -> m r r b -> m r r a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ m r r () -> m r r ()
forall r r' a. m r r' a -> m r r' a
forall tok chunk (m :: * -> * -> * -> *) r r' a.
Tokens tok chunk m =>
m r r' a -> m r r' a
hidden m r r ()
forall r. m r r ()
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
m r r ()
eof) m r r Bool -> m r r Bool -> m r r Bool
forall a. Additive a => a -> a -> a
<|> Bool -> m r r Bool
forall a i. a -> m i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure Bool
False
{-# INLINE atEnd #-}

instance (Tokens tok chunk m1, Tokens tok chunk m2) => Tokens tok chunk (m1 Indexed.:*: m2) where
  label :: forall r r' a. String -> (:*:) m1 m2 r r' a -> (:*:) m1 m2 r r' a
label String
s (m1 r r' a
a Indexed.:*: m2 r r' a
b) = String -> m1 r r' a -> m1 r r' a
forall r r' a. String -> m1 r r' a -> m1 r r' a
forall tok chunk (m :: * -> * -> * -> *) r r' a.
Tokens tok chunk m =>
String -> m r r' a -> m r r' a
label String
s m1 r r' a
a m1 r r' a -> m2 r r' a -> (:*:) m1 m2 r r' a
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: String -> m2 r r' a -> m2 r r' a
forall r r' a. String -> m2 r r' a -> m2 r r' a
forall tok chunk (m :: * -> * -> * -> *) r r' a.
Tokens tok chunk m =>
String -> m r r' a -> m r r' a
label String
s m2 r r' a
b
  hidden :: forall r r' a. (:*:) m1 m2 r r' a -> (:*:) m1 m2 r r' a
hidden (m1 r r' a
a Indexed.:*: m2 r r' a
b) = m1 r r' a -> m1 r r' a
forall r r' a. m1 r r' a -> m1 r r' a
forall tok chunk (m :: * -> * -> * -> *) r r' a.
Tokens tok chunk m =>
m r r' a -> m r r' a
hidden m1 r r' a
a m1 r r' a -> m2 r r' a -> (:*:) m1 m2 r r' a
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: m2 r r' a -> m2 r r' a
forall r r' a. m2 r r' a -> m2 r r' a
forall tok chunk (m :: * -> * -> * -> *) r r' a.
Tokens tok chunk m =>
m r r' a -> m r r' a
hidden m2 r r' a
b
  single :: forall r. tok -> (:*:) m1 m2 r r tok
single tok
t = tok -> m1 r r tok
forall r. tok -> m1 r r tok
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
tok -> m r r tok
single tok
t m1 r r tok -> m2 r r tok -> (:*:) m1 m2 r r tok
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: tok -> m2 r r tok
forall r. tok -> m2 r r tok
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
tok -> m r r tok
single tok
t
  satisfy :: forall r. (tok -> Bool) -> (:*:) m1 m2 (tok -> r) r tok
satisfy tok -> Bool
f = (tok -> Bool) -> m1 (tok -> r) r tok
forall r. (tok -> Bool) -> m1 (tok -> r) r tok
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
(tok -> Bool) -> m (tok -> r) r tok
satisfy tok -> Bool
f m1 (tok -> r) r tok
-> m2 (tok -> r) r tok -> (:*:) m1 m2 (tok -> r) r tok
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: (tok -> Bool) -> m2 (tok -> r) r tok
forall r. (tok -> Bool) -> m2 (tok -> r) r tok
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
(tok -> Bool) -> m (tok -> r) r tok
satisfy tok -> Bool
f
  eof :: forall r. (:*:) m1 m2 r r ()
eof = m1 r r ()
forall r. m1 r r ()
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
m r r ()
eof m1 r r () -> m2 r r () -> (:*:) m1 m2 r r ()
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: m2 r r ()
forall r. m2 r r ()
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
m r r ()
eof
  tokens :: forall r.
(chunk -> chunk -> Bool)
-> chunk -> (:*:) m1 m2 (chunk -> r) r chunk
tokens chunk -> chunk -> Bool
f chunk
s = (chunk -> chunk -> Bool) -> chunk -> m1 (chunk -> r) r chunk
forall r.
(chunk -> chunk -> Bool) -> chunk -> m1 (chunk -> r) r chunk
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
(chunk -> chunk -> Bool) -> chunk -> m (chunk -> r) r chunk
tokens chunk -> chunk -> Bool
f chunk
s m1 (chunk -> r) r chunk
-> m2 (chunk -> r) r chunk -> (:*:) m1 m2 (chunk -> r) r chunk
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: (chunk -> chunk -> Bool) -> chunk -> m2 (chunk -> r) r chunk
forall r.
(chunk -> chunk -> Bool) -> chunk -> m2 (chunk -> r) r chunk
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
(chunk -> chunk -> Bool) -> chunk -> m (chunk -> r) r chunk
tokens chunk -> chunk -> Bool
f chunk
s
  takeWhileP :: forall r.
Maybe String -> (tok -> Bool) -> (:*:) m1 m2 (chunk -> r) r chunk
takeWhileP Maybe String
s tok -> Bool
f = Maybe String -> (tok -> Bool) -> m1 (chunk -> r) r chunk
forall r. Maybe String -> (tok -> Bool) -> m1 (chunk -> r) r chunk
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
Maybe String -> (tok -> Bool) -> m (chunk -> r) r chunk
takeWhileP Maybe String
s tok -> Bool
f m1 (chunk -> r) r chunk
-> m2 (chunk -> r) r chunk -> (:*:) m1 m2 (chunk -> r) r chunk
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: Maybe String -> (tok -> Bool) -> m2 (chunk -> r) r chunk
forall r. Maybe String -> (tok -> Bool) -> m2 (chunk -> r) r chunk
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
Maybe String -> (tok -> Bool) -> m (chunk -> r) r chunk
takeWhileP Maybe String
s tok -> Bool
f
  takeWhile1P :: forall r.
Maybe String -> (tok -> Bool) -> (:*:) m1 m2 (chunk -> r) r chunk
takeWhile1P Maybe String
s tok -> Bool
f = Maybe String -> (tok -> Bool) -> m1 (chunk -> r) r chunk
forall r. Maybe String -> (tok -> Bool) -> m1 (chunk -> r) r chunk
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
Maybe String -> (tok -> Bool) -> m (chunk -> r) r chunk
takeWhile1P Maybe String
s tok -> Bool
f m1 (chunk -> r) r chunk
-> m2 (chunk -> r) r chunk -> (:*:) m1 m2 (chunk -> r) r chunk
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: Maybe String -> (tok -> Bool) -> m2 (chunk -> r) r chunk
forall r. Maybe String -> (tok -> Bool) -> m2 (chunk -> r) r chunk
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
Maybe String -> (tok -> Bool) -> m (chunk -> r) r chunk
takeWhile1P Maybe String
s tok -> Bool
f
  takeP :: forall r. Maybe String -> Int -> (:*:) m1 m2 (chunk -> r) r chunk
takeP Maybe String
s Int
n = Maybe String -> Int -> m1 (chunk -> r) r chunk
forall r. Maybe String -> Int -> m1 (chunk -> r) r chunk
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
Maybe String -> Int -> m (chunk -> r) r chunk
takeP Maybe String
s Int
n m1 (chunk -> r) r chunk
-> m2 (chunk -> r) r chunk -> (:*:) m1 m2 (chunk -> r) r chunk
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: Maybe String -> Int -> m2 (chunk -> r) r chunk
forall r. Maybe String -> Int -> m2 (chunk -> r) r chunk
forall tok chunk (m :: * -> * -> * -> *) r.
Tokens tok chunk m =>
Maybe String -> Int -> m (chunk -> r) r chunk
takeP Maybe String
s Int
n

-- | The typeclass @'Breaks' m@ implements format descriptors which represents
-- breaks. These are typically spaces and newlines. Because breaks can be many
-- spaces and/or newlines, the printer side must make decisions about how many
-- of which should be printed for a single break. Which is why these format
-- descriptors aren't merely derived from 'satisfy'.
class Breaks m where
  -- | This parses 0 or more spaces/newline characters. As a printer a typical
  -- choice is to print no space at all.
  space :: m r r ()

  -- | This parses 1 or more spaces/newline characters. As a printer a typical
  -- choice is to print a soft newline (see also 'group').
  space1 :: m r r ()

  -- | This parses/prints a newline character.
  hardline :: m r r ()

instance (Breaks m1, Breaks m2) => Breaks (m1 Indexed.:*: m2) where
  space :: forall (r :: k). (:*:) m1 m2 r r ()
space = m1 r r ()
forall (r :: k). m1 r r ()
forall {k} (m :: k -> k -> * -> *) (r :: k). Breaks m => m r r ()
space m1 r r () -> m2 r r () -> (:*:) m1 m2 r r ()
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: m2 r r ()
forall (r :: k). m2 r r ()
forall {k} (m :: k -> k -> * -> *) (r :: k). Breaks m => m r r ()
space
  space1 :: forall (r :: k). (:*:) m1 m2 r r ()
space1 = m1 r r ()
forall (r :: k). m1 r r ()
forall {k} (m :: k -> k -> * -> *) (r :: k). Breaks m => m r r ()
space1 m1 r r () -> m2 r r () -> (:*:) m1 m2 r r ()
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: m2 r r ()
forall (r :: k). m2 r r ()
forall {k} (m :: k -> k -> * -> *) (r :: k). Breaks m => m r r ()
space1
  hardline :: forall (r :: k). (:*:) m1 m2 r r ()
hardline = m1 r r ()
forall (r :: k). m1 r r ()
forall {k} (m :: k -> k -> * -> *) (r :: k). Breaks m => m r r ()
hardline m1 r r () -> m2 r r () -> (:*:) m1 m2 r r ()
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: m2 r r ()
forall (r :: k). m2 r r ()
forall {k} (m :: k -> k -> * -> *) (r :: k). Breaks m => m r r ()
hardline

-- | A class abstracting over the layout strategy of Wadler-Leijen-type pretty
-- printers. All these format descriptors are no-ops on the parser side.
class (Breaks m) => WadlerLeijen m where
  -- | @'group' x@ tries laying out @x@ into a single line by interpreting the
  -- contained line breaks (/e.g./ space1') as spaces; if this does not fit the
  -- page, or when a hardline (see 'hardline') within @x@ prevents it from being
  -- flattened, @x@ is laid out without any changes.
  group :: m r r' a -> m r r' a

  -- | @'nest' i x@ lays out the document @x@ with the current nesting level
  -- (indentation of the following lines) increased by @i@. Negative values are
  -- allowed, and decrease the nesting level accordingly.
  --
  -- >>> nest 4 ("lorem" <> space1 <> "ipsum" <> "dolor") <> line <> "sit" <> line "amet"
  -- lorem
  --     ipsum
  --     dolor
  -- sit
  -- amet
  nest :: Int -> m r r' a -> m r r' a

instance (WadlerLeijen m1, WadlerLeijen m2) => WadlerLeijen (m1 Indexed.:*: m2) where
  group :: forall (r :: k) (r' :: k) a.
(:*:) m1 m2 r r' a -> (:*:) m1 m2 r r' a
group (m1 r r' a
a Indexed.:*: m2 r r' a
b) = m1 r r' a -> m1 r r' a
forall (r :: k) (r' :: k) a. m1 r r' a -> m1 r r' a
forall {k} (m :: k -> k -> * -> *) (r :: k) (r' :: k) a.
WadlerLeijen m =>
m r r' a -> m r r' a
group m1 r r' a
a m1 r r' a -> m2 r r' a -> (:*:) m1 m2 r r' a
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: m2 r r' a -> m2 r r' a
forall (r :: k) (r' :: k) a. m2 r r' a -> m2 r r' a
forall {k} (m :: k -> k -> * -> *) (r :: k) (r' :: k) a.
WadlerLeijen m =>
m r r' a -> m r r' a
group m2 r r' a
b
  nest :: forall (r :: k) (r' :: k) a.
Int -> (:*:) m1 m2 r r' a -> (:*:) m1 m2 r r' a
nest Int
n (m1 r r' a
a Indexed.:*: m2 r r' a
b) = Int -> m1 r r' a -> m1 r r' a
forall (r :: k) (r' :: k) a. Int -> m1 r r' a -> m1 r r' a
forall {k} (m :: k -> k -> * -> *) (r :: k) (r' :: k) a.
WadlerLeijen m =>
Int -> m r r' a -> m r r' a
nest Int
n m1 r r' a
a m1 r r' a -> m2 r r' a -> (:*:) m1 m2 r r' a
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: Int -> m2 r r' a -> m2 r r' a
forall (r :: k) (r' :: k) a. Int -> m2 r r' a -> m2 r r' a
forall {k} (m :: k -> k -> * -> *) (r :: k) (r' :: k) a.
WadlerLeijen m =>
Int -> m r r' a -> m r r' a
nest Int
n m2 r r' a
b

instance (Breaks m) => WadlerLeijen (Trivial m) where
  group :: forall (r :: k) (r' :: k) a. Trivial m r r' a -> Trivial m r r' a
group = Trivial m r r' a -> Trivial m r r' a
forall a. a -> a
id
  nest :: forall (r :: k) (r' :: k) a.
Int -> Trivial m r r' a -> Trivial m r r' a
nest Int
_n = Trivial m r r' a -> Trivial m r r' a
forall a. a -> a
id

-- | This class declares look-ahead combinators. These allow parsers to react to
-- the upcomming of the input without consuming it. They are ignored by printers.
class LookAhead m where
  -- | If @p@ in @'lookAhead' p@ succeeds (either consuming input or not) the
  -- whole parser behaves like @p@ succeeded without consuming anything (parser
  -- state is not updated as well). If @p@ fails @'lookAhead' p@ fails without
  -- consuming input.
  lookAhead :: m (a -> r) r a -> m (a -> r) r a

  -- | @'notFollowedBy' p@ only succeeds when the parser @p@ fails. This
  -- parser /never consumes/ any input and /never modifies/ parser state. It
  -- can be used to implement the “longest match” rule.
  notFollowedBy :: m r r a -> m r r ()

instance (LookAhead m1, LookAhead m2) => LookAhead (m1 Indexed.:*: m2) where
  lookAhead :: forall a r. (:*:) m1 m2 (a -> r) r a -> (:*:) m1 m2 (a -> r) r a
lookAhead (m1 (a -> r) r a
a Indexed.:*: m2 (a -> r) r a
b) = m1 (a -> r) r a -> m1 (a -> r) r a
forall a r. m1 (a -> r) r a -> m1 (a -> r) r a
forall (m :: * -> * -> * -> *) a r.
LookAhead m =>
m (a -> r) r a -> m (a -> r) r a
lookAhead m1 (a -> r) r a
a m1 (a -> r) r a -> m2 (a -> r) r a -> (:*:) m1 m2 (a -> r) r a
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: m2 (a -> r) r a -> m2 (a -> r) r a
forall a r. m2 (a -> r) r a -> m2 (a -> r) r a
forall (m :: * -> * -> * -> *) a r.
LookAhead m =>
m (a -> r) r a -> m (a -> r) r a
lookAhead m2 (a -> r) r a
b
  notFollowedBy :: forall r a. (:*:) m1 m2 r r a -> (:*:) m1 m2 r r ()
notFollowedBy (m1 r r a
a Indexed.:*: m2 r r a
b) = m1 r r a -> m1 r r ()
forall r a. m1 r r a -> m1 r r ()
forall (m :: * -> * -> * -> *) r a.
LookAhead m =>
m r r a -> m r r ()
notFollowedBy m1 r r a
a m1 r r () -> m2 r r () -> (:*:) m1 m2 r r ()
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: m2 r r a -> m2 r r ()
forall r a. m2 r r a -> m2 r r ()
forall (m :: * -> * -> * -> *) r a.
LookAhead m =>
m r r a -> m r r ()
notFollowedBy m2 r r a
b

instance (Indexed.Applicative m, Cont2.Shifty m) => LookAhead (Trivial m) where
  lookAhead :: forall a r. Trivial m (a -> r) r a -> Trivial m (a -> r) r a
lookAhead Trivial m (a -> r) r a
_ = Trivial m (a -> r) r a
forall (m :: * -> * -> * -> *) a i.
(Applicative m, Shifty m) =>
m (a -> i) i a
Cont2.pop
  notFollowedBy :: forall r a. Trivial m r r a -> Trivial m r r ()
notFollowedBy Trivial m r r a
_ = () -> Trivial m r r ()
forall a i. a -> Trivial m i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure ()

-- | This class represents semantic tagging for printers. For instance,
-- instructions to add colour or font styles which may not be available in all
-- backends. A pup is `'Annotate' ann` when it supports tags of type `ann`'.
--
-- See also "Prettyprinter.annotate".
class Annotations ann m where
  annotate :: ann -> m r r' a -> m r r' a

instance (Annotations ann m1, Annotations ann m2) => Annotations ann (m1 Indexed.:*: m2) where
  annotate :: forall (r :: k) (r' :: k) (a :: k).
ann -> (:*:) m1 m2 r r' a -> (:*:) m1 m2 r r' a
annotate ann
ann (m1 r r' a
a Indexed.:*: m2 r r' a
b) = ann -> m1 r r' a -> m1 r r' a
forall (r :: k) (r' :: k) (a :: k). ann -> m1 r r' a -> m1 r r' a
forall {k} {k} {k} ann (m :: k -> k -> k -> *) (r :: k) (r' :: k)
       (a :: k).
Annotations ann m =>
ann -> m r r' a -> m r r' a
annotate ann
ann m1 r r' a
a m1 r r' a -> m2 r r' a -> (:*:) m1 m2 r r' a
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: ann -> m2 r r' a -> m2 r r' a
forall (r :: k) (r' :: k) (a :: k). ann -> m2 r r' a -> m2 r r' a
forall {k} {k} {k} ann (m :: k -> k -> k -> *) (r :: k) (r' :: k)
       (a :: k).
Annotations ann m =>
ann -> m r r' a -> m r r' a
annotate ann
ann m2 r r' a
b

instance Annotations ann (Trivial m) where
  annotate :: forall (r :: k) (r' :: k) (a :: k).
ann -> Trivial m r r' a -> Trivial m r r' a
annotate ann
_ = Trivial m r r' a -> Trivial m r r' a
forall a. a -> a
id

-- | A class for error handling in parsers.
class ParseErrors e m where
  -- | Stop parsing and report the 'e' as a parsing error. No-op as a printer.
  parseError :: e -> m r r' a

  -- | @'withRecovery' r p@ allows us to continue parsing even if the parser
  -- @p@ fails. In this case @r@ is called with the actual 'ParseError' as
  -- its argument. Typical usage is to return a value signifying failure to
  -- parse this particular object and to consume some part of the input up
  -- to the point where the next object starts.
  --
  -- Note that if @r@ fails, the original error message is reported as if
  -- without 'withRecovery'. In no way recovering parser @r@ can influence
  -- error messages.
  --
  -- No-op as a printer.
  withRecovery ::
    -- | How to recover from failure
    (e -> m r r' a) ->
    -- | Original parser
    m r r' a ->
    -- | Parser that can recover from failures
    m r r' a

  -- | @'observing' p@ allows us to "observe" failure of the @p@ parser,
  -- should it happen, without actually ending parsing but instead getting
  -- the 'ParseError' in 'Left', and no input is consumed. On success parsed value is returned in
  -- 'Right' as usual.
  --
  -- As a printer @'observing' p@ is a no-op on 'Left' and behaves like @p@ on
  -- 'Right'.
  observing ::
    -- | The parser to run
    m (b -> r) r a ->
    m ((Either e b) -> r) r (Either e a)

instance (ParseErrors e m1, ParseErrors e m2) => ParseErrors e (m1 Indexed.:*: m2) where
  parseError :: forall r r' a. e -> (:*:) m1 m2 r r' a
parseError e
e = e -> m1 r r' a
forall r r' a. e -> m1 r r' a
forall e (m :: * -> * -> * -> *) r r' a.
ParseErrors e m =>
e -> m r r' a
parseError e
e m1 r r' a -> m2 r r' a -> (:*:) m1 m2 r r' a
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: e -> m2 r r' a
forall r r' a. e -> m2 r r' a
forall e (m :: * -> * -> * -> *) r r' a.
ParseErrors e m =>
e -> m r r' a
parseError e
e
  withRecovery :: forall r r' a.
(e -> (:*:) m1 m2 r r' a)
-> (:*:) m1 m2 r r' a -> (:*:) m1 m2 r r' a
withRecovery e -> (:*:) m1 m2 r r' a
f (m1 r r' a
a Indexed.:*: m2 r r' a
b) = (e -> m1 r r' a) -> m1 r r' a -> m1 r r' a
forall r r' a. (e -> m1 r r' a) -> m1 r r' a -> m1 r r' a
forall e (m :: * -> * -> * -> *) r r' a.
ParseErrors e m =>
(e -> m r r' a) -> m r r' a -> m r r' a
withRecovery ((:*:) m1 m2 r r' a -> m1 r r' a
forall {k1} {k2} {k3} (f :: k1 -> k2 -> k3 -> *)
       (g :: k1 -> k2 -> k3 -> *) (i :: k1) (j :: k2) (a :: k3).
(:*:) f g i j a -> f i j a
Indexed.fst_star ((:*:) m1 m2 r r' a -> m1 r r' a)
-> (e -> (:*:) m1 m2 r r' a) -> e -> m1 r r' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> (:*:) m1 m2 r r' a
f) m1 r r' a
a m1 r r' a -> m2 r r' a -> (:*:) m1 m2 r r' a
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: (e -> m2 r r' a) -> m2 r r' a -> m2 r r' a
forall r r' a. (e -> m2 r r' a) -> m2 r r' a -> m2 r r' a
forall e (m :: * -> * -> * -> *) r r' a.
ParseErrors e m =>
(e -> m r r' a) -> m r r' a -> m r r' a
withRecovery ((:*:) m1 m2 r r' a -> m2 r r' a
forall {k1} {k2} {k3} (f :: k1 -> k2 -> k3 -> *)
       (g :: k1 -> k2 -> k3 -> *) (i :: k1) (j :: k2) (a :: k3).
(:*:) f g i j a -> g i j a
Indexed.snd_star ((:*:) m1 m2 r r' a -> m2 r r' a)
-> (e -> (:*:) m1 m2 r r' a) -> e -> m2 r r' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> (:*:) m1 m2 r r' a
f) m2 r r' a
b
  observing :: forall b r a.
(:*:) m1 m2 (b -> r) r a
-> (:*:) m1 m2 (Either e b -> r) r (Either e a)
observing (m1 (b -> r) r a
a Indexed.:*: m2 (b -> r) r a
b) = m1 (b -> r) r a -> m1 (Either e b -> r) r (Either e a)
forall b r a.
m1 (b -> r) r a -> m1 (Either e b -> r) r (Either e a)
forall e (m :: * -> * -> * -> *) b r a.
ParseErrors e m =>
m (b -> r) r a -> m (Either e b -> r) r (Either e a)
observing m1 (b -> r) r a
a m1 (Either e b -> r) r (Either e a)
-> m2 (Either e b -> r) r (Either e a)
-> (:*:) m1 m2 (Either e b -> r) r (Either e a)
forall {k} {k1} {k2} (f :: k -> k1 -> k2 -> *)
       (g :: k -> k1 -> k2 -> *) (i :: k) (j :: k1) (a :: k2).
f i j a -> g i j a -> (:*:) f g i j a
Indexed.:*: m2 (b -> r) r a -> m2 (Either e b -> r) r (Either e a)
forall b r a.
m2 (b -> r) r a -> m2 (Either e b -> r) r (Either e a)
forall e (m :: * -> * -> * -> *) b r a.
ParseErrors e m =>
m (b -> r) r a -> m (Either e b -> r) r (Either e a)
observing m2 (b -> r) r a
b

-- | A deriving-via constructor to derive instances for the classes in this
-- module which can be implemented as no-ops.
newtype Trivial m r r' a = MkTrivial (m r r' a)
  deriving newtype ((forall a b. (a -> b) -> Trivial m r r' a -> Trivial m r r' b)
-> (forall a b. a -> Trivial m r r' b -> Trivial m r r' a)
-> Functor (Trivial m r r')
forall a b. a -> Trivial m r r' b -> Trivial m r r' a
forall a b. (a -> b) -> Trivial m r r' a -> Trivial m r r' b
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Functor (m r r') =>
a -> Trivial m r r' b -> Trivial m r r' a
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Functor (m r r') =>
(a -> b) -> Trivial m r r' a -> Trivial m r r' b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Functor (m r r') =>
(a -> b) -> Trivial m r r' a -> Trivial m r r' b
fmap :: forall a b. (a -> b) -> Trivial m r r' a -> Trivial m r r' b
$c<$ :: forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Functor (m r r') =>
a -> Trivial m r r' b -> Trivial m r r' a
<$ :: forall a b. a -> Trivial m r r' b -> Trivial m r r' a
Functor, Functor (Trivial m r r')
Functor (Trivial m r r') =>
(forall a. a -> Trivial m r r' a)
-> (forall a b.
    Trivial m r r' (a -> b) -> Trivial m r r' a -> Trivial m r r' b)
-> (forall a b c.
    (a -> b -> c)
    -> Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' c)
-> (forall a b.
    Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' b)
-> (forall a b.
    Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' a)
-> Applicative (Trivial m r r')
forall a. a -> Trivial m r r' a
forall a b.
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' a
forall a b.
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' b
forall a b.
Trivial m r r' (a -> b) -> Trivial m r r' a -> Trivial m r r' b
forall a b c.
(a -> b -> c)
-> Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' c
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k).
Applicative (m r r') =>
Functor (Trivial m r r')
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a.
Applicative (m r r') =>
a -> Trivial m r r' a
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Applicative (m r r') =>
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' a
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Applicative (m r r') =>
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' b
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Applicative (m r r') =>
Trivial m r r' (a -> b) -> Trivial m r r' a -> Trivial m r r' b
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b c.
Applicative (m r r') =>
(a -> b -> c)
-> Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a.
Applicative (m r r') =>
a -> Trivial m r r' a
pure :: forall a. a -> Trivial m r r' a
$c<*> :: forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Applicative (m r r') =>
Trivial m r r' (a -> b) -> Trivial m r r' a -> Trivial m r r' b
<*> :: forall a b.
Trivial m r r' (a -> b) -> Trivial m r r' a -> Trivial m r r' b
$cliftA2 :: forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b c.
Applicative (m r r') =>
(a -> b -> c)
-> Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' c
liftA2 :: forall a b c.
(a -> b -> c)
-> Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' c
$c*> :: forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Applicative (m r r') =>
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' b
*> :: forall a b.
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' b
$c<* :: forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Applicative (m r r') =>
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' a
<* :: forall a b.
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' a
Applicative, Applicative (Trivial m r r')
Applicative (Trivial m r r') =>
(forall a b.
 Trivial m r r' a -> (a -> Trivial m r r' b) -> Trivial m r r' b)
-> (forall a b.
    Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' b)
-> (forall a. a -> Trivial m r r' a)
-> Monad (Trivial m r r')
forall a. a -> Trivial m r r' a
forall a b.
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' b
forall a b.
Trivial m r r' a -> (a -> Trivial m r r' b) -> Trivial m r r' b
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k).
Monad (m r r') =>
Applicative (Trivial m r r')
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a.
Monad (m r r') =>
a -> Trivial m r r' a
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Monad (m r r') =>
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' b
forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Monad (m r r') =>
Trivial m r r' a -> (a -> Trivial m r r' b) -> Trivial m r r' b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
$c>>= :: forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Monad (m r r') =>
Trivial m r r' a -> (a -> Trivial m r r' b) -> Trivial m r r' b
>>= :: forall a b.
Trivial m r r' a -> (a -> Trivial m r r' b) -> Trivial m r r' b
$c>> :: forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a b.
Monad (m r r') =>
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' b
>> :: forall a b.
Trivial m r r' a -> Trivial m r r' b -> Trivial m r r' b
$creturn :: forall k k (m :: k -> k -> * -> *) (r :: k) (r' :: k) a.
Monad (m r r') =>
a -> Trivial m r r' a
return :: forall a. a -> Trivial m r r' a
Monad, Trivial m r r' a
Trivial m r r' a -> Trivial m r r' a -> Trivial m r r' a
Trivial m r r' a
-> (Trivial m r r' a -> Trivial m r r' a -> Trivial m r r' a)
-> Additive (Trivial m r r' a)
forall a. a -> (a -> a -> a) -> Additive a
forall k k k (m :: k -> k -> k -> *) (r :: k) (r' :: k) (a :: k).
Additive (m r r' a) =>
Trivial m r r' a
forall k k k (m :: k -> k -> k -> *) (r :: k) (r' :: k) (a :: k).
Additive (m r r' a) =>
Trivial m r r' a -> Trivial m r r' a -> Trivial m r r' a
$cempty :: forall k k k (m :: k -> k -> k -> *) (r :: k) (r' :: k) (a :: k).
Additive (m r r' a) =>
Trivial m r r' a
empty :: Trivial m r r' a
$c<|> :: forall k k k (m :: k -> k -> k -> *) (r :: k) (r' :: k) (a :: k).
Additive (m r r' a) =>
Trivial m r r' a -> Trivial m r r' a -> Trivial m r r' a
<|> :: Trivial m r r' a -> Trivial m r r' a -> Trivial m r r' a
Additive, (forall (i :: k) (j :: k). Functor (Trivial m i j),
 forall (i :: k). Applicative (Trivial m i i)) =>
(forall a (i :: k). a -> Trivial m i i a)
-> (forall (i :: k) (j :: k) a b (k1 :: k).
    Trivial m i j (a -> b) -> Trivial m j k1 a -> Trivial m i k1 b)
-> (forall a b c (i :: k) (j :: k) (k1 :: k).
    (a -> b -> c)
    -> Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 c)
-> (forall (i :: k) (j :: k) a (k1 :: k) b.
    Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 b)
-> (forall (i :: k) (j :: k) a (k1 :: k) b.
    Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 a)
-> Applicative (Trivial m)
forall (i :: k). Applicative (Trivial m i i)
forall (i :: k) (j :: k). Functor (Trivial m i j)
forall (i :: k) (j :: k) a (k1 :: k) b.
Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 a
forall (i :: k) (j :: k) a (k1 :: k) b.
Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 b
forall (i :: k) (j :: k) a b (k1 :: k).
Trivial m i j (a -> b) -> Trivial m j k1 a -> Trivial m i k1 b
forall a (i :: k). a -> Trivial m i i a
forall a b c (i :: k) (j :: k) (k1 :: k).
(a -> b -> c)
-> Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 c
forall k (m :: k -> k -> * -> *) (i :: k).
Applicative m =>
Applicative (Trivial m i i)
forall k (m :: k -> k -> * -> *) (i :: k) (j :: k).
Applicative m =>
Functor (Trivial m i j)
forall k (m :: k -> k -> * -> *) (i :: k) (j :: k) a (k1 :: k) b.
Applicative m =>
Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 a
forall k (m :: k -> k -> * -> *) (i :: k) (j :: k) a (k1 :: k) b.
Applicative m =>
Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 b
forall k (m :: k -> k -> * -> *) (i :: k) (j :: k) a b (k1 :: k).
Applicative m =>
Trivial m i j (a -> b) -> Trivial m j k1 a -> Trivial m i k1 b
forall k (m :: k -> k -> * -> *) a (i :: k).
Applicative m =>
a -> Trivial m i i a
forall k (m :: k -> k -> * -> *) a b c (i :: k) (j :: k) (k1 :: k).
Applicative m =>
(a -> b -> c)
-> Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 c
forall {k} (f :: k -> k -> * -> *).
(forall (i :: k) (j :: k). Functor (f i j),
 forall (i :: k). Applicative (f i i)) =>
(forall a (i :: k). a -> f i i a)
-> (forall (i :: k) (j :: k) a b (k1 :: k).
    f i j (a -> b) -> f j k1 a -> f i k1 b)
-> (forall a b c (i :: k) (j :: k) (k1 :: k).
    (a -> b -> c) -> f i j a -> f j k1 b -> f i k1 c)
-> (forall (i :: k) (j :: k) a (k1 :: k) b.
    f i j a -> f j k1 b -> f i k1 b)
-> (forall (i :: k) (j :: k) a (k1 :: k) b.
    f i j a -> f j k1 b -> f i k1 a)
-> Applicative f
$cpure :: forall k (m :: k -> k -> * -> *) a (i :: k).
Applicative m =>
a -> Trivial m i i a
pure :: forall a (i :: k). a -> Trivial m i i a
$c<*> :: forall k (m :: k -> k -> * -> *) (i :: k) (j :: k) a b (k1 :: k).
Applicative m =>
Trivial m i j (a -> b) -> Trivial m j k1 a -> Trivial m i k1 b
<*> :: forall (i :: k) (j :: k) a b (k1 :: k).
Trivial m i j (a -> b) -> Trivial m j k1 a -> Trivial m i k1 b
$cliftA2 :: forall k (m :: k -> k -> * -> *) a b c (i :: k) (j :: k) (k1 :: k).
Applicative m =>
(a -> b -> c)
-> Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 c
liftA2 :: forall a b c (i :: k) (j :: k) (k1 :: k).
(a -> b -> c)
-> Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 c
$c*> :: forall k (m :: k -> k -> * -> *) (i :: k) (j :: k) a (k1 :: k) b.
Applicative m =>
Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 b
*> :: forall (i :: k) (j :: k) a (k1 :: k) b.
Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 b
$c<* :: forall k (m :: k -> k -> * -> *) (i :: k) (j :: k) a (k1 :: k) b.
Applicative m =>
Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 a
<* :: forall (i :: k) (j :: k) a (k1 :: k) b.
Trivial m i j a -> Trivial m j k1 b -> Trivial m i k1 a
Indexed.Applicative, Applicative (Trivial m)
(Applicative (Trivial m),
 forall (i :: k). Monad (Trivial m i i)) =>
(forall (i :: k) (j :: k) a (k1 :: k) b.
 Trivial m i j a -> (a -> Trivial m j k1 b) -> Trivial m i k1 b)
-> Monad (Trivial m)
forall (i :: k). Monad (Trivial m i i)
forall (i :: k) (j :: k) a (k1 :: k) b.
Trivial m i j a -> (a -> Trivial m j k1 b) -> Trivial m i k1 b
forall k (m :: k -> k -> * -> *).
Monad m =>
Applicative (Trivial m)
forall k (m :: k -> k -> * -> *) (i :: k).
Monad m =>
Monad (Trivial m i i)
forall k (m :: k -> k -> * -> *) (i :: k) (j :: k) a (k1 :: k) b.
Monad m =>
Trivial m i j a -> (a -> Trivial m j k1 b) -> Trivial m i k1 b
forall {k} (m :: k -> k -> * -> *).
(Applicative m, forall (i :: k). Monad (m i i)) =>
(forall (i :: k) (j :: k) a (k1 :: k) b.
 m i j a -> (a -> m j k1 b) -> m i k1 b)
-> Monad m
$c>>= :: forall k (m :: k -> k -> * -> *) (i :: k) (j :: k) a (k1 :: k) b.
Monad m =>
Trivial m i j a -> (a -> Trivial m j k1 b) -> Trivial m i k1 b
>>= :: forall (i :: k) (j :: k) a (k1 :: k) b.
Trivial m i j a -> (a -> Trivial m j k1 b) -> Trivial m i k1 b
Indexed.Monad, (forall r' r r''.
 ((r' -> r') -> r -> Trivial m r r'' r'') -> Trivial m r r' ())
-> Stacked (Trivial m)
forall r' r r''.
((r' -> r') -> r -> Trivial m r r'' r'') -> Trivial m r r' ()
forall (m :: * -> * -> * -> *) r' r r''.
Stacked m =>
((r' -> r') -> r -> Trivial m r r'' r'') -> Trivial m r r' ()
forall (m :: * -> * -> * -> *).
(forall r' r r''. ((r' -> r') -> r -> m r r'' r'') -> m r r' ())
-> Stacked m
$cshift_ :: forall (m :: * -> * -> * -> *) r' r r''.
Stacked m =>
((r' -> r') -> r -> Trivial m r r'' r'') -> Trivial m r r' ()
shift_ :: forall r' r r''.
((r' -> r') -> r -> Trivial m r r'' r'') -> Trivial m r r' ()
Cont2.Stacked, Stacked (Trivial m)
Stacked (Trivial m) =>
(forall a r' r k.
 ((a -> r' -> r') -> r -> Trivial m r k k) -> Trivial m r r' a)
-> Shifty (Trivial m)
forall a r' r k.
((a -> r' -> r') -> r -> Trivial m r k k) -> Trivial m r r' a
forall (m :: * -> * -> * -> *).
Stacked m =>
(forall a r' r k. ((a -> r' -> r') -> r -> m r k k) -> m r r' a)
-> Shifty m
forall (m :: * -> * -> * -> *). Shifty m => Stacked (Trivial m)
forall (m :: * -> * -> * -> *) a r' r k.
Shifty m =>
((a -> r' -> r') -> r -> Trivial m r k k) -> Trivial m r r' a
$cshift :: forall (m :: * -> * -> * -> *) a r' r k.
Shifty m =>
((a -> r' -> r') -> r -> Trivial m r k k) -> Trivial m r r' a
shift :: forall a r' r k.
((a -> r' -> r') -> r -> Trivial m r k k) -> Trivial m r r' a
Cont2.Shifty, (forall (r :: k). Trivial m r r ())
-> (forall (r :: k). Trivial m r r ())
-> (forall (r :: k). Trivial m r r ())
-> Breaks (Trivial m)
forall (r :: k). Trivial m r r ()
forall k (m :: k -> k -> * -> *) (r :: k).
Breaks m =>
Trivial m r r ()
forall {k} (m :: k -> k -> * -> *).
(forall (r :: k). m r r ())
-> (forall (r :: k). m r r ())
-> (forall (r :: k). m r r ())
-> Breaks m
$cspace :: forall k (m :: k -> k -> * -> *) (r :: k).
Breaks m =>
Trivial m r r ()
space :: forall (r :: k). Trivial m r r ()
$cspace1 :: forall k (m :: k -> k -> * -> *) (r :: k).
Breaks m =>
Trivial m r r ()
space1 :: forall (r :: k). Trivial m r r ()
$chardline :: forall k (m :: k -> k -> * -> *) (r :: k).
Breaks m =>
Trivial m r r ()
hardline :: forall (r :: k). Trivial m r r ()
Breaks)