{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE QualifiedDo #-}

-- | This module defines a pup with a
-- [Megaparsec](https://hackage.haskell.org/package/megaparsec) backend for the
-- parser side and a
-- [Prettyprinter](https://hackage.haskell.org/package/prettyprinter) backend
-- for the parser.
--
-- Start with 'Pup'' if you don't have any advanced need, change to the more
-- general 'Pup' if you want pretty-printing annotations or custom parse error.
module Text.Pup.MPR
  ( -- * A simple pup to get you started
    Pup',
    print,
    parse,

    -- * More general version
    Pup (..),

    -- * Re-exports
    module Text.Pup.Class,
    module Text.Pup.Class.Char,
    Megaparsec.MonadParsec (..),
  )
where

import Control.Additive
import Control.Applicative
import Control.Monad
import Control.Monad.Indexed qualified as Indexed
import Control.Monad.Indexed.Cont2 qualified as Cont2
import Data.String qualified as String
import Data.Text (Text)
import Data.Void (Void)
import Prettyprinter qualified
import Text.Megaparsec qualified as Text.Megaparsec
import Text.Pup.Backend.Megaparsec qualified as Megaparsec
import Text.Pup.Backend.Prettyprinter qualified as Print
import Text.Pup.Class
import Text.Pup.Class.Char
import Prelude hiding (print)

-- | The more general type of Megaparsec+Prettyprinter pup. You can still use
-- 'print' and 'parse' with it.
newtype Pup err ann r r' a = MkPup ((Print.Backend ann Indexed.:*: Megaparsec.Backend err Text) r r' a)
  deriving newtype
    ( (forall a b. (a -> b) -> Pup err ann r r' a -> Pup err ann r r' b)
-> (forall a b. a -> Pup err ann r r' b -> Pup err ann r r' a)
-> Functor (Pup err ann r r')
forall a b. a -> Pup err ann r r' b -> Pup err ann r r' a
forall a b. (a -> b) -> Pup err ann r r' a -> Pup err ann r r' b
forall err ann r r' a b.
a -> Pup err ann r r' b -> Pup err ann r r' a
forall err ann r r' a b.
(a -> b) -> Pup err ann r r' a -> Pup err 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 err ann r r' a b.
(a -> b) -> Pup err ann r r' a -> Pup err ann r r' b
fmap :: forall a b. (a -> b) -> Pup err ann r r' a -> Pup err ann r r' b
$c<$ :: forall err ann r r' a b.
a -> Pup err ann r r' b -> Pup err ann r r' a
<$ :: forall a b. a -> Pup err ann r r' b -> Pup err ann r r' a
Functor,
      (forall i j. Functor (Pup err ann i j),
 forall i. Applicative (Pup err ann i i)) =>
(forall a i. a -> Pup err ann i i a)
-> (forall i j a b k1.
    Pup err ann i j (a -> b)
    -> Pup err ann j k1 a -> Pup err ann i k1 b)
-> (forall a b c i j k1.
    (a -> b -> c)
    -> Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 c)
-> (forall i j a k1 b.
    Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 b)
-> (forall i j a k1 b.
    Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 a)
-> Applicative (Pup err ann)
forall i. Applicative (Pup err ann i i)
forall i j. Functor (Pup err ann i j)
forall a i. a -> Pup err ann i i a
forall err ann i. Applicative (Pup err ann i i)
forall err ann r r'. Functor (Pup err ann r r')
forall err ann a i. a -> Pup err ann i i a
forall i j a k1 b.
Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 a
forall i j a k1 b.
Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 b
forall i j a b k1.
Pup err ann i j (a -> b)
-> Pup err ann j k1 a -> Pup err ann i k1 b
forall a b c i j k1.
(a -> b -> c)
-> Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 c
forall err ann i j a k1 b.
Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 a
forall err ann i j a k1 b.
Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 b
forall err ann i j a b k1.
Pup err ann i j (a -> b)
-> Pup err ann j k1 a -> Pup err ann i k1 b
forall err ann a b c i j k1.
(a -> b -> c)
-> Pup err ann i j a -> Pup err ann j k1 b -> Pup err 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 err ann a i. a -> Pup err ann i i a
pure :: forall a i. a -> Pup err ann i i a
$c<*> :: forall err ann i j a b k1.
Pup err ann i j (a -> b)
-> Pup err ann j k1 a -> Pup err ann i k1 b
<*> :: forall i j a b k1.
Pup err ann i j (a -> b)
-> Pup err ann j k1 a -> Pup err ann i k1 b
$cliftA2 :: forall err ann a b c i j k1.
(a -> b -> c)
-> Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 c
liftA2 :: forall a b c i j k1.
(a -> b -> c)
-> Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 c
$c*> :: forall err ann i j a k1 b.
Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 b
*> :: forall i j a k1 b.
Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 b
$c<* :: forall err ann i j a k1 b.
Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 a
<* :: forall i j a k1 b.
Pup err ann i j a -> Pup err ann j k1 b -> Pup err ann i k1 a
Indexed.Applicative,
      Applicative (Pup err ann)
(Applicative (Pup err ann), forall i. Monad (Pup err ann i i)) =>
(forall i j a k1 b.
 Pup err ann i j a
 -> (a -> Pup err ann j k1 b) -> Pup err ann i k1 b)
-> Monad (Pup err ann)
forall i. Monad (Pup err ann i i)
forall err ann. Applicative (Pup err ann)
forall err ann i. Monad (Pup err ann i i)
forall i j a k1 b.
Pup err ann i j a
-> (a -> Pup err ann j k1 b) -> Pup err ann i k1 b
forall err ann i j a k1 b.
Pup err ann i j a
-> (a -> Pup err ann j k1 b) -> Pup err 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 err ann i j a k1 b.
Pup err ann i j a
-> (a -> Pup err ann j k1 b) -> Pup err ann i k1 b
>>= :: forall i j a k1 b.
Pup err ann i j a
-> (a -> Pup err ann j k1 b) -> Pup err ann i k1 b
Indexed.Monad,
      (forall i j a. String -> Pup err ann i j a) -> Fail (Pup err ann)
forall i j a. String -> Pup err ann i j a
forall err ann i j a. String -> Pup err ann i j a
forall {k} {k1} {k2} (m :: k -> k1 -> k2 -> *).
(forall (i :: k) (j :: k1) (a :: k2). String -> m i j a) -> Fail m
$cfail :: forall err ann i j a. String -> Pup err ann i j a
fail :: forall i j a. String -> Pup err ann i j a
Indexed.Fail,
      (forall r' r r''.
 ((r' -> r') -> r -> Pup err ann r r'' r'') -> Pup err ann r r' ())
-> Stacked (Pup err ann)
forall r' r r''.
((r' -> r') -> r -> Pup err ann r r'' r'') -> Pup err ann r r' ()
forall err ann r' r r''.
((r' -> r') -> r -> Pup err ann r r'' r'') -> Pup err ann r r' ()
forall (m :: * -> * -> * -> *).
(forall r' r r''. ((r' -> r') -> r -> m r r'' r'') -> m r r' ())
-> Stacked m
$cshift_ :: forall err ann r' r r''.
((r' -> r') -> r -> Pup err ann r r'' r'') -> Pup err ann r r' ()
shift_ :: forall r' r r''.
((r' -> r') -> r -> Pup err ann r r'' r'') -> Pup err ann r r' ()
Cont2.Stacked,
      Pup err ann r r' a
Pup err ann r r' a -> Pup err ann r r' a -> Pup err ann r r' a
Pup err ann r r' a
-> (Pup err ann r r' a -> Pup err ann r r' a -> Pup err ann r r' a)
-> Additive (Pup err ann r r' a)
forall a. a -> (a -> a -> a) -> Additive a
forall err ann r r' a. Ord err => Pup err ann r r' a
forall err ann r r' a.
Ord err =>
Pup err ann r r' a -> Pup err ann r r' a -> Pup err ann r r' a
$cempty :: forall err ann r r' a. Ord err => Pup err ann r r' a
empty :: Pup err ann r r' a
$c<|> :: forall err ann r r' a.
Ord err =>
Pup err ann r r' a -> Pup err ann r r' a -> Pup err ann r r' a
<|> :: Pup err ann r r' a -> Pup err ann r r' a -> Pup err ann r r' a
Additive,
      Tokens Char Text,
      (forall r. Pup err ann r r ())
-> (forall r. Pup err ann r r ())
-> (forall r. Pup err ann r r ())
-> Breaks (Pup err ann)
forall r. Pup err ann r r ()
forall err ann r. Ord err => Pup err ann 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 err ann r. Ord err => Pup err ann r r ()
space :: forall r. Pup err ann r r ()
$cspace1 :: forall err ann r. Ord err => Pup err ann r r ()
space1 :: forall r. Pup err ann r r ()
$chardline :: forall err ann r. Ord err => Pup err ann r r ()
hardline :: forall r. Pup err ann r r ()
Breaks,
      Breaks (Pup err ann)
Breaks (Pup err ann) =>
(forall r r' a. Pup err ann r r' a -> Pup err ann r r' a)
-> (forall r r' a. Int -> Pup err ann r r' a -> Pup err ann r r' a)
-> WadlerLeijen (Pup err ann)
forall err ann. Ord err => Breaks (Pup err ann)
forall err ann r r' a.
Ord err =>
Int -> Pup err ann r r' a -> Pup err ann r r' a
forall err ann r r' a.
Ord err =>
Pup err ann r r' a -> Pup err ann r r' a
forall r r' a. Int -> Pup err ann r r' a -> Pup err ann r r' a
forall r r' a. Pup err ann r r' a -> Pup err ann r r' a
forall {k} (m :: k -> k -> * -> *).
Breaks m =>
(forall (r :: k) (r' :: k) a. m r r' a -> m r r' a)
-> (forall (r :: k) (r' :: k) a. Int -> m r r' a -> m r r' a)
-> WadlerLeijen m
$cgroup :: forall err ann r r' a.
Ord err =>
Pup err ann r r' a -> Pup err ann r r' a
group :: forall r r' a. Pup err ann r r' a -> Pup err ann r r' a
$cnest :: forall err ann r r' a.
Ord err =>
Int -> Pup err ann r r' a -> Pup err ann r r' a
nest :: forall r r' a. Int -> Pup err ann r r' a -> Pup err ann r r' a
WadlerLeijen,
      (forall a r. Pup err ann (a -> r) r a -> Pup err ann (a -> r) r a)
-> (forall r a. Pup err ann r r a -> Pup err ann r r ())
-> LookAhead (Pup err ann)
forall err ann r a.
Ord err =>
Pup err ann r r a -> Pup err ann r r ()
forall err ann a r.
Ord err =>
Pup err ann (a -> r) r a -> Pup err ann (a -> r) r a
forall r a. Pup err ann r r a -> Pup err ann r r ()
forall a r. Pup err ann (a -> r) r a -> Pup err 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 err ann a r.
Ord err =>
Pup err ann (a -> r) r a -> Pup err ann (a -> r) r a
lookAhead :: forall a r. Pup err ann (a -> r) r a -> Pup err ann (a -> r) r a
$cnotFollowedBy :: forall err ann r a.
Ord err =>
Pup err ann r r a -> Pup err ann r r ()
notFollowedBy :: forall r a. Pup err ann r r a -> Pup err ann r r ()
LookAhead,
      ParseErrors (Text.Megaparsec.ParseError Text err),
      Megaparsec.MonadParsec Text,
      Annotations ann
    )

deriving newtype instance Applicative (Pup err ann r r)

deriving newtype instance (Ord err) => Alternative (Pup err ann r r)

deriving newtype instance Monad (Pup err ann r r)

deriving newtype instance (Ord err) => MonadPlus (Pup err ann r r)

instance (Ord err, r ~ r', a ~ ()) => String.IsString (Pup err ann r r' a) where
  fromString :: String -> Pup err ann r r' a
fromString = Text -> Pup err ann r r' a
Text -> Pup err ann r' r' ()
forall (m :: * -> * -> * -> *) tok chunk r.
(Applicative m, Stacked m, Tokens tok chunk m) =>
chunk -> m r r ()
chunk (Text -> Pup err ann r r' a)
-> (String -> Text) -> String -> Pup err ann r r' a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
forall a. IsString a => String -> a
String.fromString

type Pup' = Pup Void ()

print :: Pup err ann (a -> Maybe (Prettyprinter.Doc ann)) (Maybe (Prettyprinter.Doc ann)) b -> a -> Maybe (Prettyprinter.Doc ann)
print :: forall err ann a b.
Pup err ann (a -> Maybe (Doc ann)) (Maybe (Doc ann)) b
-> a -> Maybe (Doc ann)
print (MkPup (Backend ann (a -> Maybe (Doc ann)) (Maybe (Doc ann)) b
prnt Indexed.:*: Backend err Text (a -> Maybe (Doc ann)) (Maybe (Doc ann)) b
_)) = Backend ann (a -> Maybe (Doc ann)) (Maybe (Doc ann)) b
-> a -> Maybe (Doc ann)
forall a b ann.
Backend ann (a -> Maybe (Doc ann)) (Maybe (Doc ann)) b
-> a -> Maybe (Doc ann)
Print.run Backend ann (a -> Maybe (Doc ann)) (Maybe (Doc ann)) b
prnt

parse :: (Text.Megaparsec.ShowErrorComponent err) => Pup err ann r r' a -> String -> Text -> Either String a
parse :: forall err ann r r' a.
ShowErrorComponent err =>
Pup err ann r r' a -> String -> Text -> Either String a
parse (MkPup (Backend ann r r' a
_ Indexed.:*: Backend err Text r r' a
prse)) = Backend err Text r r' a -> String -> Text -> Either String a
forall err s r r' a.
(ShowErrorComponent err, VisualStream s, TraversableStream s) =>
Backend err s r r' a -> String -> s -> Either String a
Megaparsec.run Backend err Text r r' a
prse