{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE NoImplicitPrelude #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Text.ParserCombinators.ReadPrec
-- Copyright   :  (c) The University of Glasgow 2002
-- License     :  BSD-style (see the file libraries/base/LICENSE)
--
-- Maintainer  :  libraries@haskell.org
-- Stability   :  provisional
-- Portability :  non-portable (uses Text.ParserCombinators.ReadP)
--
-- This library defines parser combinators for precedence parsing.

-----------------------------------------------------------------------------

module Text.ParserCombinators.ReadPrec
  (
  ReadPrec,

  -- * Precedences
  Prec,
  minPrec,

  -- * Precedence operations
  lift,
  prec,
  step,
  reset,

  -- * Other operations
  -- | All are based directly on their similarly-named 'ReadP' counterparts.
  get,
  look,
  (+++),
  (<++),
  pfail,
  choice,

  -- * Converters
  readPrec_to_P,
  readP_to_Prec,
  readPrec_to_S,
  readS_to_Prec,
  )
 where


import Text.ParserCombinators.ReadP
  ( ReadP
  , ReadS
  , readP_to_S
  , readS_to_P
  )

import qualified Text.ParserCombinators.ReadP as ReadP
  ( get
  , look
  , (+++), (<++)
  , pfail
  )

import GHC.Num( Num(..) )
import GHC.Base

import Control.Monad.Fail

-- ---------------------------------------------------------------------------
-- The readPrec type

newtype ReadPrec a = P (Prec -> ReadP a)

-- Functor, Monad, MonadPlus

-- | @since 2.01
instance Functor ReadPrec where
  fmap :: forall a b. (a -> b) -> ReadPrec a -> ReadPrec b
fmap a -> b
h (P Prec -> ReadP a
f) = (Prec -> ReadP b) -> ReadPrec b
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
n -> (a -> b) -> ReadP a -> ReadP b
forall a b. (a -> b) -> ReadP a -> ReadP b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
h (Prec -> ReadP a
f Prec
n))

-- | @since 4.6.0.0
instance Applicative ReadPrec where
    pure :: forall a. a -> ReadPrec a
pure a
x  = (Prec -> ReadP a) -> ReadPrec a
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
_ -> a -> ReadP a
forall a. a -> ReadP a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x)
    <*> :: forall a b. ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b
(<*>) = ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap
    liftA2 :: forall a b c.
(a -> b -> c) -> ReadPrec a -> ReadPrec b -> ReadPrec c
liftA2 = (a -> b -> c) -> ReadPrec a -> ReadPrec b -> ReadPrec c
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2

-- | @since 2.01
instance Monad ReadPrec where
  P Prec -> ReadP a
f >>= :: forall a b. ReadPrec a -> (a -> ReadPrec b) -> ReadPrec b
>>= a -> ReadPrec b
k = (Prec -> ReadP b) -> ReadPrec b
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
n -> do a
a <- Prec -> ReadP a
f Prec
n; let P Prec -> ReadP b
f' = a -> ReadPrec b
k a
a in Prec -> ReadP b
f' Prec
n)

-- | @since 4.9.0.0
instance MonadFail ReadPrec where
  fail :: forall a. String -> ReadPrec a
fail String
s    = (Prec -> ReadP a) -> ReadPrec a
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
_ -> String -> ReadP a
forall a. String -> ReadP a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
s)

-- | @since 2.01
instance MonadPlus ReadPrec

-- | @since 4.6.0.0
instance Alternative ReadPrec where
  empty :: forall a. ReadPrec a
empty = ReadPrec a
forall a. ReadPrec a
pfail
  <|> :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
(<|>) = ReadPrec a -> ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
(+++)

-- precedences
type Prec = Int

minPrec :: Prec
minPrec :: Prec
minPrec = Prec
0

-- ---------------------------------------------------------------------------
-- Operations over ReadPrec

lift :: ReadP a -> ReadPrec a
-- ^ Lift a precedence-insensitive 'ReadP' to a 'ReadPrec'.
lift :: forall a. ReadP a -> ReadPrec a
lift ReadP a
m = (Prec -> ReadP a) -> ReadPrec a
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
_ -> ReadP a
m)

step :: ReadPrec a -> ReadPrec a
-- ^ Increases the precedence context by one.
step :: forall a. ReadPrec a -> ReadPrec a
step (P Prec -> ReadP a
f) = (Prec -> ReadP a) -> ReadPrec a
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
n -> Prec -> ReadP a
f (Prec
nPrec -> Prec -> Prec
forall a. Num a => a -> a -> a
+Prec
1))

reset :: ReadPrec a -> ReadPrec a
-- ^ Resets the precedence context to zero.
reset :: forall a. ReadPrec a -> ReadPrec a
reset (P Prec -> ReadP a
f) = (Prec -> ReadP a) -> ReadPrec a
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
_ -> Prec -> ReadP a
f Prec
minPrec)

prec :: Prec -> ReadPrec a -> ReadPrec a
-- ^ @(prec n p)@ checks whether the precedence context is
--   less than or equal to @n@, and
--
--   * if not, fails
--
--   * if so, parses @p@ in context @n@.
prec :: forall a. Prec -> ReadPrec a -> ReadPrec a
prec Prec
n (P Prec -> ReadP a
f) = (Prec -> ReadP a) -> ReadPrec a
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
c -> if Prec
c Prec -> Prec -> Bool
forall a. Ord a => a -> a -> Bool
<= Prec
n then Prec -> ReadP a
f Prec
n else ReadP a
forall a. ReadP a
ReadP.pfail)

-- ---------------------------------------------------------------------------
-- Derived operations

get :: ReadPrec Char
-- ^ Consumes and returns the next character.
--   Fails if there is no input left.
get :: ReadPrec Char
get = ReadP Char -> ReadPrec Char
forall a. ReadP a -> ReadPrec a
lift ReadP Char
ReadP.get

look :: ReadPrec String
-- ^ Look-ahead: returns the part of the input that is left, without
--   consuming it.
look :: ReadPrec String
look = ReadP String -> ReadPrec String
forall a. ReadP a -> ReadPrec a
lift ReadP String
ReadP.look

(+++) :: ReadPrec a -> ReadPrec a -> ReadPrec a
-- ^ Symmetric choice.
P Prec -> ReadP a
f1 +++ :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
+++ P Prec -> ReadP a
f2 = (Prec -> ReadP a) -> ReadPrec a
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
n -> Prec -> ReadP a
f1 Prec
n ReadP a -> ReadP a -> ReadP a
forall a. ReadP a -> ReadP a -> ReadP a
ReadP.+++ Prec -> ReadP a
f2 Prec
n)

(<++) :: ReadPrec a -> ReadPrec a -> ReadPrec a
-- ^ Local, exclusive, left-biased choice: If left parser
--   locally produces any result at all, then right parser is
--   not used.
P Prec -> ReadP a
f1 <++ :: forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
<++ P Prec -> ReadP a
f2 = (Prec -> ReadP a) -> ReadPrec a
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
n -> Prec -> ReadP a
f1 Prec
n ReadP a -> ReadP a -> ReadP a
forall a. ReadP a -> ReadP a -> ReadP a
ReadP.<++ Prec -> ReadP a
f2 Prec
n)

pfail :: ReadPrec a
-- ^ Always fails.
pfail :: forall a. ReadPrec a
pfail = ReadP a -> ReadPrec a
forall a. ReadP a -> ReadPrec a
lift ReadP a
forall a. ReadP a
ReadP.pfail

choice :: [ReadPrec a] -> ReadPrec a
-- ^ Combines all parsers in the specified list.
choice :: forall a. [ReadPrec a] -> ReadPrec a
choice [ReadPrec a]
ps = (ReadPrec a -> ReadPrec a -> ReadPrec a)
-> ReadPrec a -> [ReadPrec a] -> ReadPrec a
forall a b. (a -> b -> b) -> b -> [a] -> b
foldr ReadPrec a -> ReadPrec a -> ReadPrec a
forall a. ReadPrec a -> ReadPrec a -> ReadPrec a
(+++) ReadPrec a
forall a. ReadPrec a
pfail [ReadPrec a]
ps

-- ---------------------------------------------------------------------------
-- Converting between ReadPrec and Read

readPrec_to_P :: ReadPrec a -> (Int -> ReadP a)
readPrec_to_P :: forall a. ReadPrec a -> Prec -> ReadP a
readPrec_to_P (P Prec -> ReadP a
f) = Prec -> ReadP a
f

readP_to_Prec :: (Int -> ReadP a) -> ReadPrec a
readP_to_Prec :: forall a. (Prec -> ReadP a) -> ReadPrec a
readP_to_Prec Prec -> ReadP a
f = (Prec -> ReadP a) -> ReadPrec a
forall a. (Prec -> ReadP a) -> ReadPrec a
P Prec -> ReadP a
f

readPrec_to_S :: ReadPrec a -> (Int -> ReadS a)
readPrec_to_S :: forall a. ReadPrec a -> Prec -> ReadS a
readPrec_to_S (P Prec -> ReadP a
f) Prec
n = ReadP a -> ReadS a
forall a. ReadP a -> ReadS a
readP_to_S (Prec -> ReadP a
f Prec
n)

readS_to_Prec :: (Int -> ReadS a) -> ReadPrec a
readS_to_Prec :: forall a. (Prec -> ReadS a) -> ReadPrec a
readS_to_Prec Prec -> ReadS a
f = (Prec -> ReadP a) -> ReadPrec a
forall a. (Prec -> ReadP a) -> ReadPrec a
P (\Prec
n -> ReadS a -> ReadP a
forall a. ReadS a -> ReadP a
readS_to_P (Prec -> ReadS a
f Prec
n))