{-# LANGUAGE DerivingVia #-}
{-# LANGUAGE QualifiedDo #-}

-- | This module defines a "Prettyprinter" backend for format descriptors.
module Text.Pup.Backend.Prettyprinter
  ( -- * Concrete backend
    Backend (..),
    run,
    tell,
    modify,

    -- * Re-exports
    module Text.Pup.Class,
  )
where

import Control.Additive (Additive)
import Control.Additive qualified as Additive
import Control.Applicative
import Control.Comonad.Identity
import Control.Comonad.Traced qualified as Comonad
import Control.Monad
import Control.Monad.Indexed qualified as Indexed
import Control.Monad.Indexed.Cont2 (Cont2W)
import Control.Monad.Indexed.Cont2 qualified as Cont2
import Data.Text (Text)
import Prettyprinter qualified
import Text.Pup.Backend.Megaparsec qualified as Megaparsec
import Text.Pup.Class
import Prelude hiding (Applicative (..), Monad (..))
import Prelude qualified

-- | `e` is a phantom type for the parse error type. This is required by the
-- functional dependency on 'MonadParsec'.
newtype Backend ann r r' a = Backend (Cont2W (Comonad.Traced (Prettyprinter.Doc ann)) r r' a)
  deriving newtype ((forall a b. (a -> b) -> Backend ann r r' a -> Backend ann r r' b)
-> (forall a b. a -> Backend ann r r' b -> Backend ann r r' a)
-> Functor (Backend ann r r')
forall a b. a -> Backend ann r r' b -> Backend ann r r' a
forall a b. (a -> b) -> Backend ann r r' a -> Backend ann r r' b
forall ann r r' a b. a -> Backend ann r r' b -> Backend ann r r' a
forall ann r r' a b.
(a -> b) -> Backend ann r r' a -> Backend ann 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 ann r r' a b.
(a -> b) -> Backend ann r r' a -> Backend ann r r' b
fmap :: forall a b. (a -> b) -> Backend ann r r' a -> Backend ann r r' b
$c<$ :: forall ann r r' a b. a -> Backend ann r r' b -> Backend ann r r' a
<$ :: forall a b. a -> Backend ann r r' b -> Backend ann r r' a
Functor, (forall i j. Functor (Backend ann i j),
 forall i. Applicative (Backend ann i i)) =>
(forall a i. a -> Backend ann i i a)
-> (forall i j a b k1.
    Backend ann i j (a -> b)
    -> Backend ann j k1 a -> Backend ann i k1 b)
-> (forall a b c i j k1.
    (a -> b -> c)
    -> Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 c)
-> (forall i j a k1 b.
    Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 b)
-> (forall i j a k1 b.
    Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 a)
-> Applicative (Backend ann)
forall i. Applicative (Backend ann i i)
forall i j. Functor (Backend ann i j)
forall ann i. Applicative (Backend ann i i)
forall a i. a -> Backend ann i i a
forall ann r r'. Functor (Backend ann r r')
forall ann a i. a -> Backend ann i i a
forall i j a k1 b.
Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 a
forall i j a k1 b.
Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 b
forall i j a b k1.
Backend ann i j (a -> b)
-> Backend ann j k1 a -> Backend ann i k1 b
forall ann i j a k1 b.
Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 a
forall ann i j a k1 b.
Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 b
forall ann i j a b k1.
Backend ann i j (a -> b)
-> Backend ann j k1 a -> Backend ann i k1 b
forall a b c i j k1.
(a -> b -> c)
-> Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 c
forall ann a b c i j k1.
(a -> b -> c)
-> Backend ann i j a -> Backend ann j k1 b -> Backend ann 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 ann a i. a -> Backend ann i i a
pure :: forall a i. a -> Backend ann i i a
$c<*> :: forall ann i j a b k1.
Backend ann i j (a -> b)
-> Backend ann j k1 a -> Backend ann i k1 b
<*> :: forall i j a b k1.
Backend ann i j (a -> b)
-> Backend ann j k1 a -> Backend ann i k1 b
$cliftA2 :: forall ann a b c i j k1.
(a -> b -> c)
-> Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 c
liftA2 :: forall a b c i j k1.
(a -> b -> c)
-> Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 c
$c*> :: forall ann i j a k1 b.
Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 b
*> :: forall i j a k1 b.
Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 b
$c<* :: forall ann i j a k1 b.
Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 a
<* :: forall i j a k1 b.
Backend ann i j a -> Backend ann j k1 b -> Backend ann i k1 a
Indexed.Applicative, Applicative (Backend ann)
(Applicative (Backend ann), forall i. Monad (Backend ann i i)) =>
(forall i j a k1 b.
 Backend ann i j a
 -> (a -> Backend ann j k1 b) -> Backend ann i k1 b)
-> Monad (Backend ann)
forall i. Monad (Backend ann i i)
forall ann. Applicative (Backend ann)
forall ann i. Monad (Backend ann i i)
forall i j a k1 b.
Backend ann i j a
-> (a -> Backend ann j k1 b) -> Backend ann i k1 b
forall ann i j a k1 b.
Backend ann i j a
-> (a -> Backend ann j k1 b) -> Backend ann 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 ann i j a k1 b.
Backend ann i j a
-> (a -> Backend ann j k1 b) -> Backend ann i k1 b
>>= :: forall i j a k1 b.
Backend ann i j a
-> (a -> Backend ann j k1 b) -> Backend ann i k1 b
Indexed.Monad, (forall r' r r''.
 ((r' -> r') -> r -> Backend ann r r'' r'') -> Backend ann r r' ())
-> Stacked (Backend ann)
forall r' r r''.
((r' -> r') -> r -> Backend ann r r'' r'') -> Backend ann r r' ()
forall ann r' r r''.
((r' -> r') -> r -> Backend ann r r'' r'') -> Backend ann r r' ()
forall (m :: * -> * -> * -> *).
(forall r' r r''. ((r' -> r') -> r -> m r r'' r'') -> m r r' ())
-> Stacked m
$cshift_ :: forall ann r' r r''.
((r' -> r') -> r -> Backend ann r r'' r'') -> Backend ann r r' ()
shift_ :: forall r' r r''.
((r' -> r') -> r -> Backend ann r r'' r'') -> Backend ann r r' ()
Cont2.Stacked, Stacked (Backend ann)
Stacked (Backend ann) =>
(forall a r' r k.
 ((a -> r' -> r') -> r -> Backend ann r k k) -> Backend ann r r' a)
-> Shifty (Backend ann)
forall ann. Stacked (Backend ann)
forall a r' r k.
((a -> r' -> r') -> r -> Backend ann r k k) -> Backend ann r r' a
forall ann a r' r k.
((a -> r' -> r') -> r -> Backend ann r k k) -> Backend ann 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
$cshift :: forall ann a r' r k.
((a -> r' -> r') -> r -> Backend ann r k k) -> Backend ann r r' a
shift :: forall a r' r k.
((a -> r' -> r') -> r -> Backend ann r k k) -> Backend ann r r' a
Cont2.Shifty, Backend ann r r' a
Backend ann r r' a -> Backend ann r r' a -> Backend ann r r' a
Backend ann r r' a
-> (Backend ann r r' a -> Backend ann r r' a -> Backend ann r r' a)
-> Additive (Backend ann r r' a)
forall a. a -> (a -> a -> a) -> Additive a
forall ann r r' a. Backend ann r r' a
forall ann r r' a.
Backend ann r r' a -> Backend ann r r' a -> Backend ann r r' a
$cempty :: forall ann r r' a. Backend ann r r' a
empty :: Backend ann r r' a
$c<|> :: forall ann r r' a.
Backend ann r r' a -> Backend ann r r' a -> Backend ann r r' a
<|> :: Backend ann r r' a -> Backend ann r r' a -> Backend ann r r' a
Additive)
  deriving ((forall a r. Backend ann (a -> r) r a -> Backend ann (a -> r) r a)
-> (forall r a. Backend ann r r a -> Backend ann r r ())
-> LookAhead (Backend ann)
forall r a. Backend ann r r a -> Backend ann r r ()
forall a r. Backend ann (a -> r) r a -> Backend ann (a -> r) r a
forall ann r a. Backend ann r r a -> Backend ann r r ()
forall ann a r.
Backend ann (a -> r) r a -> Backend ann (a -> r) r a
forall (m :: * -> * -> * -> *).
(forall a r. m (a -> r) r a -> m (a -> r) r a)
-> (forall r a. m r r a -> m r r ()) -> LookAhead m
$clookAhead :: forall ann a r.
Backend ann (a -> r) r a -> Backend ann (a -> r) r a
lookAhead :: forall a r. Backend ann (a -> r) r a -> Backend ann (a -> r) r a
$cnotFollowedBy :: forall ann r a. Backend ann r r a -> Backend ann r r ()
notFollowedBy :: forall r a. Backend ann r r a -> Backend ann r r ()
LookAhead) via (Trivial (Backend ann))

deriving newtype instance Prelude.Applicative (Backend ann r r)

deriving newtype instance Alternative (Backend ann r r)

deriving newtype instance Prelude.Monad (Backend ann r r)

deriving newtype instance MonadPlus (Backend ann r r)

instance Indexed.Fail (Backend ann) where
  fail :: forall i j a. String -> Backend ann i j a
fail String
_msg = Backend ann i j a
forall a. Additive a => a
Additive.empty

run :: forall a b ann. Backend ann (a -> Maybe (Prettyprinter.Doc ann)) (Maybe (Prettyprinter.Doc ann)) b -> a -> Maybe (Prettyprinter.Doc ann)
run :: forall a b ann.
Backend ann (a -> Maybe (Doc ann)) (Maybe (Doc ann)) b
-> a -> Maybe (Doc ann)
run (Backend Cont2W
  (Traced (Doc ann)) (a -> Maybe (Doc ann)) (Maybe (Doc ann)) b
prnt) = Cont2W
  (Traced (Doc ann)) (a -> Maybe (Doc ann)) (Maybe (Doc ann)) b
-> Traced (Doc ann) (b -> Maybe (Doc ann) -> Maybe (Doc ann))
-> (a -> Maybe (Doc ann))
-> a
-> Maybe (Doc ann)
forall (w :: * -> *) r r' a.
Cont2W w r r' a -> w (a -> r' -> r') -> r -> r
Cont2.runCont2W Cont2W
  (Traced (Doc ann)) (a -> Maybe (Doc ann)) (Maybe (Doc ann)) b
prnt ((Doc ann -> b -> Maybe (Doc ann) -> Maybe (Doc ann))
-> Traced (Doc ann) (b -> Maybe (Doc ann) -> Maybe (Doc ann))
forall m a. (m -> a) -> Traced m a
Comonad.traced (\Doc ann
s b
_ Maybe (Doc ann)
_ -> Doc ann -> Maybe (Doc ann)
forall a. a -> Maybe a
Just Doc ann
s)) (\a
_ -> Maybe (Doc ann)
forall a. Maybe a
Nothing)

tell :: Prettyprinter.Doc ann -> Backend ann r r ()
tell :: forall ann r. Doc ann -> Backend ann r r ()
tell Doc ann
doc = Cont2W (Traced (Doc ann)) r r () -> Backend ann r r ()
forall ann r r' a.
Cont2W (Traced (Doc ann)) r r' a -> Backend ann r r' a
Backend (Cont2W (Traced (Doc ann)) r r () -> Backend ann r r ())
-> Cont2W (Traced (Doc ann)) r r () -> Backend ann r r ()
forall a b. (a -> b) -> a -> b
$ (Traced (Doc ann) r -> r) -> Cont2W (Traced (Doc ann)) r r ()
forall (w :: * -> *) r. Comonad w => (w r -> r) -> Cont2W w r r ()
Cont2.yield_ ((Traced (Doc ann) r -> r) -> Cont2W (Traced (Doc ann)) r r ())
-> (Traced (Doc ann) r -> r) -> Cont2W (Traced (Doc ann)) r r ()
forall a b. (a -> b) -> a -> b
$ Doc ann -> Traced (Doc ann) r -> r
forall a. Doc ann -> TracedT (Doc ann) Identity a -> a
forall m (w :: * -> *) a. ComonadTraced m w => m -> w a -> a
Comonad.trace Doc ann
doc

modify :: (Prettyprinter.Doc ann -> Prettyprinter.Doc ann) -> Backend ann r r' a -> Backend ann r r' a
modify :: forall ann r r' a.
(Doc ann -> Doc ann) -> Backend ann r r' a -> Backend ann r r' a
modify Doc ann -> Doc ann
f (Backend (Cont2.Cont2W Traced (Doc ann) (a -> r' -> r') -> r -> r
a)) = Cont2W (Traced (Doc ann)) r r' a -> Backend ann r r' a
forall ann r r' a.
Cont2W (Traced (Doc ann)) r r' a -> Backend ann r r' a
Backend (Cont2W (Traced (Doc ann)) r r' a -> Backend ann r r' a)
-> Cont2W (Traced (Doc ann)) r r' a -> Backend ann r r' a
forall a b. (a -> b) -> a -> b
$ (Traced (Doc ann) (a -> r' -> r') -> r -> r)
-> Cont2W (Traced (Doc ann)) r r' a
forall (w :: * -> *) r r' a.
(w (a -> r' -> r') -> r -> r) -> Cont2W w r r' a
Cont2.Cont2W ((Traced (Doc ann) (a -> r' -> r') -> r -> r)
 -> Cont2W (Traced (Doc ann)) r r' a)
-> (Traced (Doc ann) (a -> r' -> r') -> r -> r)
-> Cont2W (Traced (Doc ann)) r r' a
forall a b. (a -> b) -> a -> b
$ \(Comonad.TracedT (Identity Doc ann -> a -> r' -> r'
wk)) r
fl -> Traced (Doc ann) (a -> r' -> r') -> r -> r
a (Identity (Doc ann -> a -> r' -> r')
-> Traced (Doc ann) (a -> r' -> r')
forall m (w :: * -> *) a. w (m -> a) -> TracedT m w a
Comonad.TracedT ((Doc ann -> a -> r' -> r') -> Identity (Doc ann -> a -> r' -> r')
forall a. a -> Identity a
Identity (Doc ann -> a -> r' -> r'
wk (Doc ann -> a -> r' -> r')
-> (Doc ann -> Doc ann) -> Doc ann -> a -> r' -> r'
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc ann -> Doc ann
f))) r
fl

instance Tokens Char Text (Backend ann) where
  label :: forall r r' a. String -> Backend ann r r' a -> Backend ann r r' a
label String
_ = Backend ann r r' a -> Backend ann r r' a
forall a. a -> a
id
  eof :: forall r. Backend ann r r ()
eof = () -> Backend ann r r ()
forall a i. a -> Backend ann i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure ()
  satisfy :: forall r. (Char -> Bool) -> Backend ann (Char -> r) r Char
satisfy Char -> Bool
p = Indexed.do
    Char
tok <- Backend ann (Char -> r) r Char
forall (m :: * -> * -> * -> *) a i.
(Applicative m, Shifty m) =>
m (a -> i) i a
Cont2.pop
    Bool -> Backend ann r r ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Char -> Bool
p Char
tok)
    Doc ann -> Backend ann r r ()
forall ann r. Doc ann -> Backend ann r r ()
tell (Char -> Doc ann
forall ann. Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Prettyprinter.pretty Char
tok)
    Char -> Backend ann r r Char
forall a i. a -> Backend ann i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure Char
tok
  single :: forall r. Char -> Backend ann r r Char
single Char
t = Indexed.do
    Doc ann -> Backend ann r r ()
forall ann r. Doc ann -> Backend ann r r ()
tell (Char -> Doc ann
forall ann. Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Prettyprinter.pretty Char
t)
    Char -> Backend ann r r Char
forall a i. a -> Backend ann i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure Char
t
  tokens :: forall r.
(Text -> Text -> Bool) -> Text -> Backend ann (Text -> r) r Text
tokens Text -> Text -> Bool
_matches Text
_chunk = Indexed.do
    Text
toks <- Backend ann (Text -> r) r Text
forall (m :: * -> * -> * -> *) a i.
(Applicative m, Shifty m) =>
m (a -> i) i a
Cont2.pop
    Doc ann -> Backend ann r r ()
forall ann r. Doc ann -> Backend ann r r ()
tell (Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
Prettyprinter.pretty Text
toks)
    Text -> Backend ann r r Text
forall a i. a -> Backend ann i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure Text
toks
  takeP :: forall r. Maybe String -> Int -> Backend ann (Text -> r) r Text
takeP Maybe String
_label Int
_n = Indexed.do
    Text
toks <- Backend ann (Text -> r) r Text
forall (m :: * -> * -> * -> *) a i.
(Applicative m, Shifty m) =>
m (a -> i) i a
Cont2.pop
    Doc ann -> Backend ann r r ()
forall ann r. Doc ann -> Backend ann r r ()
tell (Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
Prettyprinter.pretty Text
toks)
    Text -> Backend ann r r Text
forall a i. a -> Backend ann i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure Text
toks
  takeWhileP :: forall r.
Maybe String -> (Char -> Bool) -> Backend ann (Text -> r) r Text
takeWhileP Maybe String
_label Char -> Bool
_pred = Indexed.do
    Text
toks <- Backend ann (Text -> r) r Text
forall (m :: * -> * -> * -> *) a i.
(Applicative m, Shifty m) =>
m (a -> i) i a
Cont2.pop
    Doc ann -> Backend ann r r ()
forall ann r. Doc ann -> Backend ann r r ()
tell (Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
Prettyprinter.pretty Text
toks)
    Text -> Backend ann r r Text
forall a i. a -> Backend ann i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure Text
toks
  takeWhile1P :: forall r.
Maybe String -> (Char -> Bool) -> Backend ann (Text -> r) r Text
takeWhile1P Maybe String
_label Char -> Bool
_pred = Indexed.do
    Text
toks <- Backend ann (Text -> r) r Text
forall (m :: * -> * -> * -> *) a i.
(Applicative m, Shifty m) =>
m (a -> i) i a
Cont2.pop
    Doc ann -> Backend ann r r ()
forall ann r. Doc ann -> Backend ann r r ()
tell (Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Text -> Doc ann
Prettyprinter.pretty Text
toks)
    Text -> Backend ann r r Text
forall a i. a -> Backend ann i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure Text
toks

instance Breaks (Backend ann) where
  space :: forall r. Backend ann r r ()
space = () -> Backend ann r r ()
forall a i. a -> Backend ann i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure ()
  space1 :: forall r. Backend ann r r ()
space1 = Doc ann -> Backend ann r r ()
forall ann r. Doc ann -> Backend ann r r ()
tell Doc ann
forall ann. Doc ann
Prettyprinter.line
  hardline :: forall r. Backend ann r r ()
hardline = Doc ann -> Backend ann r r ()
forall ann r. Doc ann -> Backend ann r r ()
tell Doc ann
forall ann. Doc ann
Prettyprinter.hardline

instance ParseErrors e' (Backend ann) where
  parseError :: forall r r' a. e' -> Backend ann r r' a
parseError e'
_ = Backend ann r r' a
forall a. Additive a => a
Additive.empty
  withRecovery :: forall r r' a.
(e' -> Backend ann r r' a)
-> Backend ann r r' a -> Backend ann r r' a
withRecovery e' -> Backend ann r r' a
_ = Backend ann r r' a -> Backend ann r r' a
forall a. a -> a
id
  observing :: forall b r a.
Backend ann (b -> r) r a
-> Backend ann (Either e' b -> r) r (Either e' a)
observing Backend ann (b -> r) r a
pr = Indexed.do
    Either e' b
v <- Backend ann (Either e' b -> r) r (Either e' b)
forall (m :: * -> * -> * -> *) a i.
(Applicative m, Shifty m) =>
m (a -> i) i a
Cont2.pop
    case Either e' b
v of
      Right b
b -> a -> Either e' a
forall a b. b -> Either a b
Right (a -> Either e' a)
-> Backend ann r r a -> Backend ann r r (Either e' a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Backend ann (b -> r) r a
pr Backend ann (b -> r) r a -> b -> Backend ann r r a
forall (m :: * -> * -> * -> *) a i j b.
(Applicative m, Stacked m) =>
m (a -> i) j b -> a -> m i j b
Cont2.@ b
b
      Left e'
err -> Either e' a -> Backend ann r r (Either e' a)
forall a i. a -> Backend ann i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure (Either e' a -> Backend ann r r (Either e' a))
-> Either e' a -> Backend ann r r (Either e' a)
forall a b. (a -> b) -> a -> b
$ e' -> Either e' a
forall a b. a -> Either a b
Left e'
err

instance Megaparsec.MonadParsec Text (Backend ann) where
  try :: forall r r' a. Backend ann r r' a -> Backend ann r r' a
try = Backend ann r r' a -> Backend ann r r' a
forall a. a -> a
id
  token :: forall a r.
(Token Text -> Maybe a)
-> Set (ErrorItem (Token Text))
-> (a -> Token Text)
-> Backend ann (a -> r) r a
token Token Text -> Maybe a
_match Set (ErrorItem (Token Text))
_expected a -> Token Text
pr = Indexed.do
    a
tok <- Backend ann (a -> r) r a
forall (m :: * -> * -> * -> *) a i.
(Applicative m, Shifty m) =>
m (a -> i) i a
Cont2.pop
    Doc ann -> Backend ann r r ()
forall ann r. Doc ann -> Backend ann r r ()
tell (Char -> Doc ann
forall ann. Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
Prettyprinter.pretty (a -> Token Text
pr a
tok))
    a -> Backend ann r r a
forall a i. a -> Backend ann i i a
forall {k} (f :: k -> k -> * -> *) a (i :: k).
Applicative f =>
a -> f i i a
Indexed.pure a
tok

instance WadlerLeijen (Backend ann) where
  group :: forall r r' a. Backend ann r r' a -> Backend ann r r' a
group = (Doc ann -> Doc ann) -> Backend ann r r' a -> Backend ann r r' a
forall ann r r' a.
(Doc ann -> Doc ann) -> Backend ann r r' a -> Backend ann r r' a
modify Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
Prettyprinter.group

  nest :: forall r r' a. Int -> Backend ann r r' a -> Backend ann r r' a
nest Int
n = (Doc ann -> Doc ann) -> Backend ann r r' a -> Backend ann r r' a
forall ann r r' a.
(Doc ann -> Doc ann) -> Backend ann r r' a -> Backend ann r r' a
modify (Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
Prettyprinter.nest Int
n)

instance Annotations ann (Backend ann) where
  annotate :: forall r r' a. ann -> Backend ann r r' a -> Backend ann r r' a
annotate ann
ann = (Doc ann -> Doc ann) -> Backend ann r r' a -> Backend ann r r' a
forall ann r r' a.
(Doc ann -> Doc ann) -> Backend ann r r' a -> Backend ann r r' a
modify (ann -> Doc ann -> Doc ann
forall ann. ann -> Doc ann -> Doc ann
Prettyprinter.annotate ann
ann)