-----------------------------------------------------------------------------
--
-- Module      :  $Headers
-- Copyright   :  (c) 2021 Brian W Bush
-- License     :  MIT
--
-- Maintainer  :  Brian W Bush <code@functionally.io>
-- Stability   :  Experimental
-- Portability :  Portable
--
-- | Mantra types.
--
-----------------------------------------------------------------------------


{-# LANGUAGE GeneralizedNewtypeDeriving #-}


module Mantra.Types (
-- * Mantra monad
  MantraM(..)
, mantraM
, runMantraToIO
-- * Printing
, logMantra
, printMantra
, debugMantra
-- * Lifting and hoisting
, foistMantra
, foistMantraEither
, foistMantraEitherIO
, foistMantraExcept
, foistMantraExceptIO
, foistMantraMaybe
, foistMantraMaybeIO
-- * Exceptions
, throwMantra
-- * Slots
, SlotRef(..)
) where


import Control.Arrow (first)
import Control.Monad.IO.Class (MonadIO, liftIO)
import Control.Monad.Except (MonadError)
import Control.Monad.Trans (MonadTrans, lift)
import Control.Monad.Trans.Except (ExceptT(..), runExceptT, throwE, withExceptT)
import Control.Monad.Trans.Except.Extra (hoistExceptT)
import System.IO (hPutStrLn, stderr)


-- | Mantra monad.
newtype MantraM m a = MantraM {MantraM m a -> ExceptT String m a
runMantraM :: ExceptT String m a}
  deriving (Functor (MantraM m)
a -> MantraM m a
Functor (MantraM m)
-> (forall a. a -> MantraM m a)
-> (forall a b. MantraM m (a -> b) -> MantraM m a -> MantraM m b)
-> (forall a b c.
    (a -> b -> c) -> MantraM m a -> MantraM m b -> MantraM m c)
-> (forall a b. MantraM m a -> MantraM m b -> MantraM m b)
-> (forall a b. MantraM m a -> MantraM m b -> MantraM m a)
-> Applicative (MantraM m)
MantraM m a -> MantraM m b -> MantraM m b
MantraM m a -> MantraM m b -> MantraM m a
MantraM m (a -> b) -> MantraM m a -> MantraM m b
(a -> b -> c) -> MantraM m a -> MantraM m b -> MantraM m c
forall a. a -> MantraM m a
forall a b. MantraM m a -> MantraM m b -> MantraM m a
forall a b. MantraM m a -> MantraM m b -> MantraM m b
forall a b. MantraM m (a -> b) -> MantraM m a -> MantraM m b
forall a b c.
(a -> b -> c) -> MantraM m a -> MantraM m b -> MantraM m c
forall (m :: * -> *). Monad m => Functor (MantraM m)
forall (m :: * -> *) a. Monad m => a -> MantraM m a
forall (m :: * -> *) a b.
Monad m =>
MantraM m a -> MantraM m b -> MantraM m a
forall (m :: * -> *) a b.
Monad m =>
MantraM m a -> MantraM m b -> MantraM m b
forall (m :: * -> *) a b.
Monad m =>
MantraM m (a -> b) -> MantraM m a -> MantraM m b
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> MantraM m a -> MantraM m b -> MantraM m 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
<* :: MantraM m a -> MantraM m b -> MantraM m a
$c<* :: forall (m :: * -> *) a b.
Monad m =>
MantraM m a -> MantraM m b -> MantraM m a
*> :: MantraM m a -> MantraM m b -> MantraM m b
$c*> :: forall (m :: * -> *) a b.
Monad m =>
MantraM m a -> MantraM m b -> MantraM m b
liftA2 :: (a -> b -> c) -> MantraM m a -> MantraM m b -> MantraM m c
$cliftA2 :: forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> c) -> MantraM m a -> MantraM m b -> MantraM m c
<*> :: MantraM m (a -> b) -> MantraM m a -> MantraM m b
$c<*> :: forall (m :: * -> *) a b.
Monad m =>
MantraM m (a -> b) -> MantraM m a -> MantraM m b
pure :: a -> MantraM m a
$cpure :: forall (m :: * -> *) a. Monad m => a -> MantraM m a
$cp1Applicative :: forall (m :: * -> *). Monad m => Functor (MantraM m)
Applicative, a -> MantraM m b -> MantraM m a
(a -> b) -> MantraM m a -> MantraM m b
(forall a b. (a -> b) -> MantraM m a -> MantraM m b)
-> (forall a b. a -> MantraM m b -> MantraM m a)
-> Functor (MantraM m)
forall a b. a -> MantraM m b -> MantraM m a
forall a b. (a -> b) -> MantraM m a -> MantraM m b
forall (m :: * -> *) a b.
Functor m =>
a -> MantraM m b -> MantraM m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> MantraM m a -> MantraM m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> MantraM m b -> MantraM m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> MantraM m b -> MantraM m a
fmap :: (a -> b) -> MantraM m a -> MantraM m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> MantraM m a -> MantraM m b
Functor, Applicative (MantraM m)
a -> MantraM m a
Applicative (MantraM m)
-> (forall a b. MantraM m a -> (a -> MantraM m b) -> MantraM m b)
-> (forall a b. MantraM m a -> MantraM m b -> MantraM m b)
-> (forall a. a -> MantraM m a)
-> Monad (MantraM m)
MantraM m a -> (a -> MantraM m b) -> MantraM m b
MantraM m a -> MantraM m b -> MantraM m b
forall a. a -> MantraM m a
forall a b. MantraM m a -> MantraM m b -> MantraM m b
forall a b. MantraM m a -> (a -> MantraM m b) -> MantraM m b
forall (m :: * -> *). Monad m => Applicative (MantraM m)
forall (m :: * -> *) a. Monad m => a -> MantraM m a
forall (m :: * -> *) a b.
Monad m =>
MantraM m a -> MantraM m b -> MantraM m b
forall (m :: * -> *) a b.
Monad m =>
MantraM m a -> (a -> MantraM m b) -> MantraM m 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
return :: a -> MantraM m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> MantraM m a
>> :: MantraM m a -> MantraM m b -> MantraM m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
MantraM m a -> MantraM m b -> MantraM m b
>>= :: MantraM m a -> (a -> MantraM m b) -> MantraM m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
MantraM m a -> (a -> MantraM m b) -> MantraM m b
$cp1Monad :: forall (m :: * -> *). Monad m => Applicative (MantraM m)
Monad, MonadError String, Monad (MantraM m)
Monad (MantraM m)
-> (forall a. String -> MantraM m a) -> MonadFail (MantraM m)
String -> MantraM m a
forall a. String -> MantraM m a
forall (m :: * -> *).
Monad m -> (forall a. String -> m a) -> MonadFail m
forall (m :: * -> *). MonadFail m => Monad (MantraM m)
forall (m :: * -> *) a. MonadFail m => String -> MantraM m a
fail :: String -> MantraM m a
$cfail :: forall (m :: * -> *) a. MonadFail m => String -> MantraM m a
$cp1MonadFail :: forall (m :: * -> *). MonadFail m => Monad (MantraM m)
MonadFail, Monad (MantraM m)
Monad (MantraM m)
-> (forall a. IO a -> MantraM m a) -> MonadIO (MantraM m)
IO a -> MantraM m a
forall a. IO a -> MantraM m a
forall (m :: * -> *).
Monad m -> (forall a. IO a -> m a) -> MonadIO m
forall (m :: * -> *). MonadIO m => Monad (MantraM m)
forall (m :: * -> *) a. MonadIO m => IO a -> MantraM m a
liftIO :: IO a -> MantraM m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> MantraM m a
$cp1MonadIO :: forall (m :: * -> *). MonadIO m => Monad (MantraM m)
MonadIO)


-- | Lift in the Mantra monad.
mantraM :: Monad m
        => MonadTrans t
        => MantraM m a
        -> t (MantraM m) a
mantraM :: MantraM m a -> t (MantraM m) a
mantraM = MantraM m a -> t (MantraM m) a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift


-- | Run the Mantra monad to IO.
runMantraToIO :: MantraM IO a
              -> IO (Either String a)
runMantraToIO :: MantraM IO a -> IO (Either String a)
runMantraToIO = ExceptT String IO a -> IO (Either String a)
forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a)
runExceptT (ExceptT String IO a -> IO (Either String a))
-> (MantraM IO a -> ExceptT String IO a)
-> MantraM IO a
-> IO (Either String a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MantraM IO a -> ExceptT String IO a
forall (m :: * -> *) a. MantraM m a -> ExceptT String m a
runMantraM


-- | Pull a value into the Mantra monad.
foistMantra :: Monad m
            => a           -- ^ The value.
            -> MantraM m a -- ^ Action for the value.
foistMantra :: a -> MantraM m a
foistMantra = ExceptT String m a -> MantraM m a
forall (m :: * -> *) a. ExceptT String m a -> MantraM m a
MantraM (ExceptT String m a -> MantraM m a)
-> (a -> ExceptT String m a) -> a -> MantraM m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (Either String a) -> ExceptT String m a
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT (m (Either String a) -> ExceptT String m a)
-> (a -> m (Either String a)) -> a -> ExceptT String m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either String a -> m (Either String a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Either String a -> m (Either String a))
-> (a -> Either String a) -> a -> m (Either String a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Either String a
forall a b. b -> Either a b
Right


-- | Pull a value into the Mantra monad.
foistMantraEither :: Monad m
                  => Show e
                  => Either e a  -- ^ The value.
                  -> MantraM m a -- ^ Action for the value.
foistMantraEither :: Either e a -> MantraM m a
foistMantraEither = ExceptT String m a -> MantraM m a
forall (m :: * -> *) a. ExceptT String m a -> MantraM m a
MantraM (ExceptT String m a -> MantraM m a)
-> (Either e a -> ExceptT String m a) -> Either e a -> MantraM m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> String) -> ExceptT e m a -> ExceptT String m a
forall (m :: * -> *) e e' a.
Functor m =>
(e -> e') -> ExceptT e m a -> ExceptT e' m a
withExceptT e -> String
forall a. Show a => a -> String
show (ExceptT e m a -> ExceptT String m a)
-> (Either e a -> ExceptT e m a)
-> Either e a
-> ExceptT String m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (Either e a) -> ExceptT e m a
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT (m (Either e a) -> ExceptT e m a)
-> (Either e a -> m (Either e a)) -> Either e a -> ExceptT e m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either e a -> m (Either e a)
forall (m :: * -> *) a. Monad m => a -> m a
return


-- | Pull a value into the Mantra monad.
foistMantraEitherIO :: MonadIO m
                    => Show e
                    => IO (Either e a) -- ^ The value.
                    -> MantraM m a     -- ^ Action for the value.
foistMantraEitherIO :: IO (Either e a) -> MantraM m a
foistMantraEitherIO = ExceptT String m a -> MantraM m a
forall (m :: * -> *) a. ExceptT String m a -> MantraM m a
MantraM (ExceptT String m a -> MantraM m a)
-> (IO (Either e a) -> ExceptT String m a)
-> IO (Either e a)
-> MantraM m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall b. IO b -> m b)
-> ExceptT String IO a -> ExceptT String m a
forall (m :: * -> *) (n :: * -> *) x a.
(forall b. m b -> n b) -> ExceptT x m a -> ExceptT x n a
hoistExceptT forall b. IO b -> m b
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ExceptT String IO a -> ExceptT String m a)
-> (IO (Either e a) -> ExceptT String IO a)
-> IO (Either e a)
-> ExceptT String m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> String) -> ExceptT e IO a -> ExceptT String IO a
forall (m :: * -> *) e e' a.
Functor m =>
(e -> e') -> ExceptT e m a -> ExceptT e' m a
withExceptT e -> String
forall a. Show a => a -> String
show (ExceptT e IO a -> ExceptT String IO a)
-> (IO (Either e a) -> ExceptT e IO a)
-> IO (Either e a)
-> ExceptT String IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO (Either e a) -> ExceptT e IO a
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT


-- | Pull a value into the Mantra monad.
foistMantraExcept :: Monad m
                  => Show e
                  => ExceptT e m a -- ^ The value.
                  -> MantraM m a   -- ^ Action for the value.
foistMantraExcept :: ExceptT e m a -> MantraM m a
foistMantraExcept = ExceptT String m a -> MantraM m a
forall (m :: * -> *) a. ExceptT String m a -> MantraM m a
MantraM (ExceptT String m a -> MantraM m a)
-> (ExceptT e m a -> ExceptT String m a)
-> ExceptT e m a
-> MantraM m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> String) -> ExceptT e m a -> ExceptT String m a
forall (m :: * -> *) e e' a.
Functor m =>
(e -> e') -> ExceptT e m a -> ExceptT e' m a
withExceptT e -> String
forall a. Show a => a -> String
show


-- | Pull a value into the Mantra monad.
foistMantraExceptIO :: MonadIO m
                    => Show e
                    => ExceptT e IO a -- ^ The value.
                    -> MantraM m a    -- ^ Action for the value.
foistMantraExceptIO :: ExceptT e IO a -> MantraM m a
foistMantraExceptIO = ExceptT String m a -> MantraM m a
forall (m :: * -> *) a. ExceptT String m a -> MantraM m a
MantraM (ExceptT String m a -> MantraM m a)
-> (ExceptT e IO a -> ExceptT String m a)
-> ExceptT e IO a
-> MantraM m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall b. IO b -> m b)
-> ExceptT String IO a -> ExceptT String m a
forall (m :: * -> *) (n :: * -> *) x a.
(forall b. m b -> n b) -> ExceptT x m a -> ExceptT x n a
hoistExceptT forall b. IO b -> m b
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ExceptT String IO a -> ExceptT String m a)
-> (ExceptT e IO a -> ExceptT String IO a)
-> ExceptT e IO a
-> ExceptT String m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (e -> String) -> ExceptT e IO a -> ExceptT String IO a
forall (m :: * -> *) e e' a.
Functor m =>
(e -> e') -> ExceptT e m a -> ExceptT e' m a
withExceptT e -> String
forall a. Show a => a -> String
show


-- | Pull a value into the Mantra monad.
foistMantraMaybe :: Monad m
                 => String      -- ^ The error message.
                 -> Maybe a     -- ^ The value.
                 -> MantraM m a -- ^ Action for the value.
foistMantraMaybe :: String -> Maybe a -> MantraM m a
foistMantraMaybe String
message = ExceptT String m a -> MantraM m a
forall (m :: * -> *) a. ExceptT String m a -> MantraM m a
MantraM (ExceptT String m a -> MantraM m a)
-> (Maybe a -> ExceptT String m a) -> Maybe a -> MantraM m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (Either String a) -> ExceptT String m a
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT (m (Either String a) -> ExceptT String m a)
-> (Maybe a -> m (Either String a))
-> Maybe a
-> ExceptT String m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either String a -> m (Either String a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Either String a -> m (Either String a))
-> (Maybe a -> Either String a) -> Maybe a -> m (Either String a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Either String a
-> (a -> Either String a) -> Maybe a -> Either String a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Either String a
forall a b. a -> Either a b
Left String
message) a -> Either String a
forall a b. b -> Either a b
Right


-- | Pull a value into the Mantra monad.
foistMantraMaybeIO :: MonadIO m
                   => String       -- ^ The error message.
                   -> IO (Maybe a) -- ^ The value.
                   -> MantraM m a  -- ^ Action for the value.
foistMantraMaybeIO :: String -> IO (Maybe a) -> MantraM m a
foistMantraMaybeIO String
message = ExceptT String m a -> MantraM m a
forall (m :: * -> *) a. ExceptT String m a -> MantraM m a
MantraM (ExceptT String m a -> MantraM m a)
-> (IO (Maybe a) -> ExceptT String m a)
-> IO (Maybe a)
-> MantraM m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall b. IO b -> m b)
-> ExceptT String IO a -> ExceptT String m a
forall (m :: * -> *) (n :: * -> *) x a.
(forall b. m b -> n b) -> ExceptT x m a -> ExceptT x n a
hoistExceptT forall b. IO b -> m b
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ExceptT String IO a -> ExceptT String m a)
-> (IO (Maybe a) -> ExceptT String IO a)
-> IO (Maybe a)
-> ExceptT String m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO (Either String a) -> ExceptT String IO a
forall e (m :: * -> *) a. m (Either e a) -> ExceptT e m a
ExceptT (IO (Either String a) -> ExceptT String IO a)
-> (IO (Maybe a) -> IO (Either String a))
-> IO (Maybe a)
-> ExceptT String IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe a -> Either String a)
-> IO (Maybe a) -> IO (Either String a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Either String a
-> (a -> Either String a) -> Maybe a -> Either String a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Either String a
forall a b. a -> Either a b
Left String
message) a -> Either String a
forall a b. b -> Either a b
Right)


-- | Throw an error.
throwMantra :: Monad m
            => String      -- ^ The error message.
            -> MantraM m a -- ^ Action for throwing the error.
throwMantra :: String -> MantraM m a
throwMantra = ExceptT String m a -> MantraM m a
forall (m :: * -> *) a. ExceptT String m a -> MantraM m a
MantraM (ExceptT String m a -> MantraM m a)
-> (String -> ExceptT String m a) -> String -> MantraM m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ExceptT String m a
forall (m :: * -> *) e a. Monad m => e -> ExceptT e m a
throwE


-- | Log a message.
logMantra :: MonadIO m
          => Bool         -- ^ Whether to log to standard output.
          -> String       -- ^ The message.
          -> MantraM m () -- ^ Action to log the message.
logMantra :: Bool -> String -> MantraM m ()
logMantra Bool
out =
  IO () -> MantraM m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
    (IO () -> MantraM m ())
-> (String -> IO ()) -> String -> MantraM m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. if Bool
out
        then String -> IO ()
putStrLn
        else Handle -> String -> IO ()
hPutStrLn Handle
stderr


-- | Print a message to standard output.
printMantra :: MonadIO m
            => String       -- ^ The message.
            -> MantraM m () -- ^ Action to print the message.
printMantra :: String -> MantraM m ()
printMantra = Bool -> String -> MantraM m ()
forall (m :: * -> *). MonadIO m => Bool -> String -> MantraM m ()
logMantra Bool
True


-- | Print a message to standard error.
debugMantra :: MonadIO m
            => String       -- ^ The message.
            -> MantraM m () -- ^ Action to print the message.
debugMantra :: String -> MantraM m ()
debugMantra = Bool -> String -> MantraM m ()
forall (m :: * -> *). MonadIO m => Bool -> String -> MantraM m ()
logMantra Bool
False


-- | A reference to a slot.
data SlotRef =
    AbsoluteSlot Integer -- ^ The absolute slot number.
  | RelativeSlot Integer -- ^ The number of slots relative to the current tip.
    deriving (SlotRef -> SlotRef -> Bool
(SlotRef -> SlotRef -> Bool)
-> (SlotRef -> SlotRef -> Bool) -> Eq SlotRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SlotRef -> SlotRef -> Bool
$c/= :: SlotRef -> SlotRef -> Bool
== :: SlotRef -> SlotRef -> Bool
$c== :: SlotRef -> SlotRef -> Bool
Eq, Eq SlotRef
Eq SlotRef
-> (SlotRef -> SlotRef -> Ordering)
-> (SlotRef -> SlotRef -> Bool)
-> (SlotRef -> SlotRef -> Bool)
-> (SlotRef -> SlotRef -> Bool)
-> (SlotRef -> SlotRef -> Bool)
-> (SlotRef -> SlotRef -> SlotRef)
-> (SlotRef -> SlotRef -> SlotRef)
-> Ord SlotRef
SlotRef -> SlotRef -> Bool
SlotRef -> SlotRef -> Ordering
SlotRef -> SlotRef -> SlotRef
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: SlotRef -> SlotRef -> SlotRef
$cmin :: SlotRef -> SlotRef -> SlotRef
max :: SlotRef -> SlotRef -> SlotRef
$cmax :: SlotRef -> SlotRef -> SlotRef
>= :: SlotRef -> SlotRef -> Bool
$c>= :: SlotRef -> SlotRef -> Bool
> :: SlotRef -> SlotRef -> Bool
$c> :: SlotRef -> SlotRef -> Bool
<= :: SlotRef -> SlotRef -> Bool
$c<= :: SlotRef -> SlotRef -> Bool
< :: SlotRef -> SlotRef -> Bool
$c< :: SlotRef -> SlotRef -> Bool
compare :: SlotRef -> SlotRef -> Ordering
$ccompare :: SlotRef -> SlotRef -> Ordering
$cp1Ord :: Eq SlotRef
Ord, Int -> SlotRef -> ShowS
[SlotRef] -> ShowS
SlotRef -> String
(Int -> SlotRef -> ShowS)
-> (SlotRef -> String) -> ([SlotRef] -> ShowS) -> Show SlotRef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SlotRef] -> ShowS
$cshowList :: [SlotRef] -> ShowS
show :: SlotRef -> String
$cshow :: SlotRef -> String
showsPrec :: Int -> SlotRef -> ShowS
$cshowsPrec :: Int -> SlotRef -> ShowS
Show)

instance Read SlotRef where
  readsPrec :: Int -> ReadS SlotRef
readsPrec Int
p (Char
'+' : String
remainder) = (Integer -> SlotRef) -> (Integer, String) -> (SlotRef, String)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first Integer -> SlotRef
RelativeSlot ((Integer, String) -> (SlotRef, String))
-> [(Integer, String)] -> [(SlotRef, String)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> ReadS Integer
forall a. Read a => Int -> ReadS a
readsPrec Int
p String
remainder
  readsPrec Int
p        String
remainder  = (Integer -> SlotRef) -> (Integer, String) -> (SlotRef, String)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first Integer -> SlotRef
AbsoluteSlot ((Integer, String) -> (SlotRef, String))
-> [(Integer, String)] -> [(SlotRef, String)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> ReadS Integer
forall a. Read a => Int -> ReadS a
readsPrec Int
p String
remainder