-- SPDX-FileCopyrightText: 2021 Oxhead Alpha
-- SPDX-License-Identifier: LicenseRef-MIT-OA

-- | Morley extensions to the Michelson language
module Morley.Michelson.Untyped.Ext
  ( ExtInstrAbstract (..)
  , StackRef (..)
  , PrintComment (..)
  , TestAssert (..)
  , Var (..)
  , TyVar (..)
  , StackTypePattern (..)
  , varSet
  , stackTypePatternToList
  ) where

import Data.Aeson.TH (deriveJSON)
import Data.Aeson.Types
  (FromJSON(..), ToJSON(..), genericParseJSON, genericToEncoding, genericToJSON)
import Data.Data (Data(..))
import Data.Set qualified as Set
import Data.Text qualified as T
import Fmt (Buildable(build), Doc, blockListF, blockMapF, listF, nameF)
import Prettyprinter (align, enclose)

import Morley.Michelson.Printer.Util (RenderDoc(..))
import Morley.Michelson.Untyped.HoistInstr
import Morley.Michelson.Untyped.Type
import Morley.Util.Aeson

-- | Implementation-specific instructions embedded in a @NOP@ primitive, which
-- mark a specific point during a contract's typechecking or execution.
--
-- These instructions are not allowed to modify the contract's stack, but may
-- impose additional constraints that can cause a contract to report errors in
-- type-checking or testing.
--
-- Additionaly, some implementation-specific language features such as
-- type-checking of @LetMacro@s are implemented using this mechanism
-- (specifically @FN@ and @FN_END@).
data ExtInstrAbstract f op =
    STACKTYPE StackTypePattern -- ^ Matches current stack against a type-pattern
  | UTEST_ASSERT (TestAssert f op)   -- ^ Copy the current stack and run an inline assertion on it
  | UPRINT PrintComment         -- ^ Print a comment with optional embedded @StackRef@s
  | UCOMMENT Text        -- ^ A comment in Michelson code
  deriving stock (ExtInstrAbstract f op -> ExtInstrAbstract f op -> Bool
(ExtInstrAbstract f op -> ExtInstrAbstract f op -> Bool)
-> (ExtInstrAbstract f op -> ExtInstrAbstract f op -> Bool)
-> Eq (ExtInstrAbstract f op)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: * -> *) op.
Eq (f op) =>
ExtInstrAbstract f op -> ExtInstrAbstract f op -> Bool
$c== :: forall (f :: * -> *) op.
Eq (f op) =>
ExtInstrAbstract f op -> ExtInstrAbstract f op -> Bool
== :: ExtInstrAbstract f op -> ExtInstrAbstract f op -> Bool
$c/= :: forall (f :: * -> *) op.
Eq (f op) =>
ExtInstrAbstract f op -> ExtInstrAbstract f op -> Bool
/= :: ExtInstrAbstract f op -> ExtInstrAbstract f op -> Bool
Eq, Int -> ExtInstrAbstract f op -> ShowS
[ExtInstrAbstract f op] -> ShowS
ExtInstrAbstract f op -> String
(Int -> ExtInstrAbstract f op -> ShowS)
-> (ExtInstrAbstract f op -> String)
-> ([ExtInstrAbstract f op] -> ShowS)
-> Show (ExtInstrAbstract f op)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: * -> *) op.
Show (f op) =>
Int -> ExtInstrAbstract f op -> ShowS
forall (f :: * -> *) op.
Show (f op) =>
[ExtInstrAbstract f op] -> ShowS
forall (f :: * -> *) op.
Show (f op) =>
ExtInstrAbstract f op -> String
$cshowsPrec :: forall (f :: * -> *) op.
Show (f op) =>
Int -> ExtInstrAbstract f op -> ShowS
showsPrec :: Int -> ExtInstrAbstract f op -> ShowS
$cshow :: forall (f :: * -> *) op.
Show (f op) =>
ExtInstrAbstract f op -> String
show :: ExtInstrAbstract f op -> String
$cshowList :: forall (f :: * -> *) op.
Show (f op) =>
[ExtInstrAbstract f op] -> ShowS
showList :: [ExtInstrAbstract f op] -> ShowS
Show, Typeable (ExtInstrAbstract f op)
Typeable (ExtInstrAbstract f op)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g)
    -> ExtInstrAbstract f op
    -> c (ExtInstrAbstract f op))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ExtInstrAbstract f op))
-> (ExtInstrAbstract f op -> Constr)
-> (ExtInstrAbstract f op -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ExtInstrAbstract f op)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ExtInstrAbstract f op)))
-> ((forall b. Data b => b -> b)
    -> ExtInstrAbstract f op -> ExtInstrAbstract f op)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ExtInstrAbstract f op
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ExtInstrAbstract f op
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ExtInstrAbstract f op -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ExtInstrAbstract f op -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ExtInstrAbstract f op -> m (ExtInstrAbstract f op))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ExtInstrAbstract f op -> m (ExtInstrAbstract f op))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ExtInstrAbstract f op -> m (ExtInstrAbstract f op))
-> Data (ExtInstrAbstract f op)
ExtInstrAbstract f op -> Constr
ExtInstrAbstract f op -> DataType
(forall b. Data b => b -> b)
-> ExtInstrAbstract f op -> ExtInstrAbstract f op
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> ExtInstrAbstract f op -> u
forall u.
(forall d. Data d => d -> u) -> ExtInstrAbstract f op -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtInstrAbstract f op -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtInstrAbstract f op -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ExtInstrAbstract f op -> m (ExtInstrAbstract f op)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ExtInstrAbstract f op -> m (ExtInstrAbstract f op)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExtInstrAbstract f op)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ExtInstrAbstract f op
-> c (ExtInstrAbstract f op)
forall {f :: * -> *} {op}.
(Typeable f, Typeable op, Data (f op)) =>
Typeable (ExtInstrAbstract f op)
forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
ExtInstrAbstract f op -> Constr
forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
ExtInstrAbstract f op -> DataType
forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
(forall b. Data b => b -> b)
-> ExtInstrAbstract f op -> ExtInstrAbstract f op
forall (f :: * -> *) op u.
(Typeable f, Typeable op, Data (f op)) =>
Int -> (forall d. Data d => d -> u) -> ExtInstrAbstract f op -> u
forall (f :: * -> *) op u.
(Typeable f, Typeable op, Data (f op)) =>
(forall d. Data d => d -> u) -> ExtInstrAbstract f op -> [u]
forall (f :: * -> *) op r r'.
(Typeable f, Typeable op, Data (f op)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtInstrAbstract f op -> r
forall (f :: * -> *) op r r'.
(Typeable f, Typeable op, Data (f op)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtInstrAbstract f op -> r
forall (f :: * -> *) op (m :: * -> *).
(Typeable f, Typeable op, Data (f op), Monad m) =>
(forall d. Data d => d -> m d)
-> ExtInstrAbstract f op -> m (ExtInstrAbstract f op)
forall (f :: * -> *) op (m :: * -> *).
(Typeable f, Typeable op, Data (f op), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ExtInstrAbstract f op -> m (ExtInstrAbstract f op)
forall (f :: * -> *) op (c :: * -> *).
(Typeable f, Typeable op, Data (f op)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExtInstrAbstract f op)
forall (f :: * -> *) op (c :: * -> *).
(Typeable f, Typeable op, Data (f op)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ExtInstrAbstract f op
-> c (ExtInstrAbstract f op)
forall (f :: * -> *) op (t :: * -> *) (c :: * -> *).
(Typeable f, Typeable op, Data (f op), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ExtInstrAbstract f op))
forall (f :: * -> *) op (t :: * -> * -> *) (c :: * -> *).
(Typeable f, Typeable op, Data (f op), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExtInstrAbstract f op))
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ExtInstrAbstract f op))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExtInstrAbstract f op))
$cgfoldl :: forall (f :: * -> *) op (c :: * -> *).
(Typeable f, Typeable op, Data (f op)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ExtInstrAbstract f op
-> c (ExtInstrAbstract f op)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ExtInstrAbstract f op
-> c (ExtInstrAbstract f op)
$cgunfold :: forall (f :: * -> *) op (c :: * -> *).
(Typeable f, Typeable op, Data (f op)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExtInstrAbstract f op)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ExtInstrAbstract f op)
$ctoConstr :: forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
ExtInstrAbstract f op -> Constr
toConstr :: ExtInstrAbstract f op -> Constr
$cdataTypeOf :: forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
ExtInstrAbstract f op -> DataType
dataTypeOf :: ExtInstrAbstract f op -> DataType
$cdataCast1 :: forall (f :: * -> *) op (t :: * -> *) (c :: * -> *).
(Typeable f, Typeable op, Data (f op), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ExtInstrAbstract f op))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ExtInstrAbstract f op))
$cdataCast2 :: forall (f :: * -> *) op (t :: * -> * -> *) (c :: * -> *).
(Typeable f, Typeable op, Data (f op), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExtInstrAbstract f op))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ExtInstrAbstract f op))
$cgmapT :: forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
(forall b. Data b => b -> b)
-> ExtInstrAbstract f op -> ExtInstrAbstract f op
gmapT :: (forall b. Data b => b -> b)
-> ExtInstrAbstract f op -> ExtInstrAbstract f op
$cgmapQl :: forall (f :: * -> *) op r r'.
(Typeable f, Typeable op, Data (f op)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtInstrAbstract f op -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtInstrAbstract f op -> r
$cgmapQr :: forall (f :: * -> *) op r r'.
(Typeable f, Typeable op, Data (f op)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtInstrAbstract f op -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtInstrAbstract f op -> r
$cgmapQ :: forall (f :: * -> *) op u.
(Typeable f, Typeable op, Data (f op)) =>
(forall d. Data d => d -> u) -> ExtInstrAbstract f op -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> ExtInstrAbstract f op -> [u]
$cgmapQi :: forall (f :: * -> *) op u.
(Typeable f, Typeable op, Data (f op)) =>
Int -> (forall d. Data d => d -> u) -> ExtInstrAbstract f op -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ExtInstrAbstract f op -> u
$cgmapM :: forall (f :: * -> *) op (m :: * -> *).
(Typeable f, Typeable op, Data (f op), Monad m) =>
(forall d. Data d => d -> m d)
-> ExtInstrAbstract f op -> m (ExtInstrAbstract f op)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ExtInstrAbstract f op -> m (ExtInstrAbstract f op)
$cgmapMp :: forall (f :: * -> *) op (m :: * -> *).
(Typeable f, Typeable op, Data (f op), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ExtInstrAbstract f op -> m (ExtInstrAbstract f op)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ExtInstrAbstract f op -> m (ExtInstrAbstract f op)
$cgmapMo :: forall (f :: * -> *) op (m :: * -> *).
(Typeable f, Typeable op, Data (f op), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> ExtInstrAbstract f op -> m (ExtInstrAbstract f op)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ExtInstrAbstract f op -> m (ExtInstrAbstract f op)
Data, (forall x. ExtInstrAbstract f op -> Rep (ExtInstrAbstract f op) x)
-> (forall x.
    Rep (ExtInstrAbstract f op) x -> ExtInstrAbstract f op)
-> Generic (ExtInstrAbstract f op)
forall x. Rep (ExtInstrAbstract f op) x -> ExtInstrAbstract f op
forall x. ExtInstrAbstract f op -> Rep (ExtInstrAbstract f op) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) op x.
Rep (ExtInstrAbstract f op) x -> ExtInstrAbstract f op
forall (f :: * -> *) op x.
ExtInstrAbstract f op -> Rep (ExtInstrAbstract f op) x
$cfrom :: forall (f :: * -> *) op x.
ExtInstrAbstract f op -> Rep (ExtInstrAbstract f op) x
from :: forall x. ExtInstrAbstract f op -> Rep (ExtInstrAbstract f op) x
$cto :: forall (f :: * -> *) op x.
Rep (ExtInstrAbstract f op) x -> ExtInstrAbstract f op
to :: forall x. Rep (ExtInstrAbstract f op) x -> ExtInstrAbstract f op
Generic, (forall a b.
 (a -> b) -> ExtInstrAbstract f a -> ExtInstrAbstract f b)
-> (forall a b. a -> ExtInstrAbstract f b -> ExtInstrAbstract f a)
-> Functor (ExtInstrAbstract f)
forall a b. a -> ExtInstrAbstract f b -> ExtInstrAbstract f a
forall a b.
(a -> b) -> ExtInstrAbstract f a -> ExtInstrAbstract f b
forall (f :: * -> *) a b.
Functor f =>
a -> ExtInstrAbstract f b -> ExtInstrAbstract f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> ExtInstrAbstract f a -> ExtInstrAbstract f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> ExtInstrAbstract f a -> ExtInstrAbstract f b
fmap :: forall a b.
(a -> b) -> ExtInstrAbstract f a -> ExtInstrAbstract f b
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> ExtInstrAbstract f b -> ExtInstrAbstract f a
<$ :: forall a b. a -> ExtInstrAbstract f b -> ExtInstrAbstract f a
Functor)

instance HoistInstr ExtInstrAbstract where
  hoistInstr :: forall (f :: * -> *) a (g :: * -> *).
(f a -> g a) -> ExtInstrAbstract f a -> ExtInstrAbstract g a
hoistInstr f a -> g a
f = \case
    STACKTYPE StackTypePattern
x -> StackTypePattern -> ExtInstrAbstract g a
forall (f :: * -> *) op. StackTypePattern -> ExtInstrAbstract f op
STACKTYPE StackTypePattern
x
    UTEST_ASSERT TestAssert f a
x -> TestAssert g a -> ExtInstrAbstract g a
forall (f :: * -> *) op. TestAssert f op -> ExtInstrAbstract f op
UTEST_ASSERT (TestAssert g a -> ExtInstrAbstract g a)
-> TestAssert g a -> ExtInstrAbstract g a
forall a b. (a -> b) -> a -> b
$ (f a -> g a) -> TestAssert f a -> TestAssert g a
forall {k} (n :: (k -> *) -> k -> *) (f :: k -> *) (a :: k)
       (g :: k -> *).
HoistInstr n =>
(f a -> g a) -> n f a -> n g a
forall (f :: * -> *) a (g :: * -> *).
(f a -> g a) -> TestAssert f a -> TestAssert g a
hoistInstr f a -> g a
f TestAssert f a
x
    UPRINT PrintComment
x -> PrintComment -> ExtInstrAbstract g a
forall (f :: * -> *) op. PrintComment -> ExtInstrAbstract f op
UPRINT PrintComment
x
    UCOMMENT Text
x -> Text -> ExtInstrAbstract g a
forall (f :: * -> *) op. Text -> ExtInstrAbstract f op
UCOMMENT Text
x

instance (Foldable f, Buildable op) => Buildable (ExtInstrAbstract f op)

instance NFData (f op) => NFData (ExtInstrAbstract f op)

instance RenderDoc (ExtInstrAbstract f op) where
  renderDoc :: RenderContext -> ExtInstrAbstract f op -> Doc
renderDoc RenderContext
_ =
    \case
      UCOMMENT Text
t -> Doc -> Doc -> Doc -> Doc
forall ann. Doc ann -> Doc ann -> Doc ann -> Doc ann
enclose Doc
"/* " Doc
" */" (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ Doc -> Doc
forall ann. Doc ann -> Doc ann
align (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ Text -> Doc
forall a. Buildable a => a -> Doc
build Text
t
      ExtInstrAbstract f op
_ -> Doc
forall a. Monoid a => a
mempty
  isRenderable :: ExtInstrAbstract f op -> Bool
isRenderable =
    \case
      UCOMMENT{} -> Bool
True
      ExtInstrAbstract f op
_ -> Bool
False

-- | A reference into the stack.
newtype StackRef = StackRef Natural
  deriving stock (StackRef -> StackRef -> Bool
(StackRef -> StackRef -> Bool)
-> (StackRef -> StackRef -> Bool) -> Eq StackRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StackRef -> StackRef -> Bool
== :: StackRef -> StackRef -> Bool
$c/= :: StackRef -> StackRef -> Bool
/= :: StackRef -> StackRef -> Bool
Eq, Int -> StackRef -> ShowS
[StackRef] -> ShowS
StackRef -> String
(Int -> StackRef -> ShowS)
-> (StackRef -> String) -> ([StackRef] -> ShowS) -> Show StackRef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StackRef -> ShowS
showsPrec :: Int -> StackRef -> ShowS
$cshow :: StackRef -> String
show :: StackRef -> String
$cshowList :: [StackRef] -> ShowS
showList :: [StackRef] -> ShowS
Show, Typeable StackRef
Typeable StackRef
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> StackRef -> c StackRef)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StackRef)
-> (StackRef -> Constr)
-> (StackRef -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StackRef))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StackRef))
-> ((forall b. Data b => b -> b) -> StackRef -> StackRef)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StackRef -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StackRef -> r)
-> (forall u. (forall d. Data d => d -> u) -> StackRef -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> StackRef -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> StackRef -> m StackRef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StackRef -> m StackRef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> StackRef -> m StackRef)
-> Data StackRef
StackRef -> Constr
StackRef -> DataType
(forall b. Data b => b -> b) -> StackRef -> StackRef
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> StackRef -> u
forall u. (forall d. Data d => d -> u) -> StackRef -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StackRef -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StackRef -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StackRef -> m StackRef
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StackRef -> m StackRef
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StackRef
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StackRef -> c StackRef
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StackRef)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StackRef)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StackRef -> c StackRef
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StackRef -> c StackRef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StackRef
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StackRef
$ctoConstr :: StackRef -> Constr
toConstr :: StackRef -> Constr
$cdataTypeOf :: StackRef -> DataType
dataTypeOf :: StackRef -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StackRef)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StackRef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StackRef)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c StackRef)
$cgmapT :: (forall b. Data b => b -> b) -> StackRef -> StackRef
gmapT :: (forall b. Data b => b -> b) -> StackRef -> StackRef
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StackRef -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StackRef -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StackRef -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StackRef -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> StackRef -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> StackRef -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StackRef -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> StackRef -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StackRef -> m StackRef
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> StackRef -> m StackRef
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StackRef -> m StackRef
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StackRef -> m StackRef
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StackRef -> m StackRef
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> StackRef -> m StackRef
Data, (forall x. StackRef -> Rep StackRef x)
-> (forall x. Rep StackRef x -> StackRef) -> Generic StackRef
forall x. Rep StackRef x -> StackRef
forall x. StackRef -> Rep StackRef x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. StackRef -> Rep StackRef x
from :: forall x. StackRef -> Rep StackRef x
$cto :: forall x. Rep StackRef x -> StackRef
to :: forall x. Rep StackRef x -> StackRef
Generic)

instance NFData StackRef

instance Buildable StackRef where
  build :: StackRef -> Doc
build (StackRef Natural
i) = Doc
"%[" Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> Natural -> Doc
forall b a. (PrettyShow a, Show a, IsString b) => a -> b
show Natural
i Doc -> Doc -> Doc
forall a. Semigroup a => a -> a -> a
<> Doc
"]"

-- | A (named) type variable
newtype Var = Var T.Text
  deriving stock (Var -> Var -> Bool
(Var -> Var -> Bool) -> (Var -> Var -> Bool) -> Eq Var
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Var -> Var -> Bool
== :: Var -> Var -> Bool
$c/= :: Var -> Var -> Bool
/= :: Var -> Var -> Bool
Eq, Int -> Var -> ShowS
[Var] -> ShowS
Var -> String
(Int -> Var -> ShowS)
-> (Var -> String) -> ([Var] -> ShowS) -> Show Var
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Var -> ShowS
showsPrec :: Int -> Var -> ShowS
$cshow :: Var -> String
show :: Var -> String
$cshowList :: [Var] -> ShowS
showList :: [Var] -> ShowS
Show, Eq Var
Eq Var
-> (Var -> Var -> Ordering)
-> (Var -> Var -> Bool)
-> (Var -> Var -> Bool)
-> (Var -> Var -> Bool)
-> (Var -> Var -> Bool)
-> (Var -> Var -> Var)
-> (Var -> Var -> Var)
-> Ord Var
Var -> Var -> Bool
Var -> Var -> Ordering
Var -> Var -> Var
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
$ccompare :: Var -> Var -> Ordering
compare :: Var -> Var -> Ordering
$c< :: Var -> Var -> Bool
< :: Var -> Var -> Bool
$c<= :: Var -> Var -> Bool
<= :: Var -> Var -> Bool
$c> :: Var -> Var -> Bool
> :: Var -> Var -> Bool
$c>= :: Var -> Var -> Bool
>= :: Var -> Var -> Bool
$cmax :: Var -> Var -> Var
max :: Var -> Var -> Var
$cmin :: Var -> Var -> Var
min :: Var -> Var -> Var
Ord, Typeable Var
Typeable Var
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> Var -> c Var)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Var)
-> (Var -> Constr)
-> (Var -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Var))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var))
-> ((forall b. Data b => b -> b) -> Var -> Var)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r)
-> (forall u. (forall d. Data d => d -> u) -> Var -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Var -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Var -> m Var)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Var -> m Var)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Var -> m Var)
-> Data Var
Var -> Constr
Var -> DataType
(forall b. Data b => b -> b) -> Var -> Var
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Var -> u
forall u. (forall d. Data d => d -> u) -> Var -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Var -> m Var
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Var)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Var -> c Var
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Var
$ctoConstr :: Var -> Constr
toConstr :: Var -> Constr
$cdataTypeOf :: Var -> DataType
dataTypeOf :: Var -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Var)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Var)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Var)
$cgmapT :: (forall b. Data b => b -> b) -> Var -> Var
gmapT :: (forall b. Data b => b -> b) -> Var -> Var
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Var -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Var -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Var -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Var -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Var -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Var -> m Var
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Var -> m Var
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Var -> m Var
Data, (forall x. Var -> Rep Var x)
-> (forall x. Rep Var x -> Var) -> Generic Var
forall x. Rep Var x -> Var
forall x. Var -> Rep Var x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Var -> Rep Var x
from :: forall x. Var -> Rep Var x
$cto :: forall x. Rep Var x -> Var
to :: forall x. Rep Var x -> Var
Generic)
  deriving anyclass [Var] -> Doc
Var -> Doc
(Var -> Doc) -> ([Var] -> Doc) -> Buildable Var
forall a. (a -> Doc) -> ([a] -> Doc) -> Buildable a
$cbuild :: Var -> Doc
build :: Var -> Doc
$cbuildList :: [Var] -> Doc
buildList :: [Var] -> Doc
Buildable

instance NFData Var

-- | A type-variable or a type-constant
data TyVar =
    VarID Var
  | TyCon Ty
  deriving stock (TyVar -> TyVar -> Bool
(TyVar -> TyVar -> Bool) -> (TyVar -> TyVar -> Bool) -> Eq TyVar
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TyVar -> TyVar -> Bool
== :: TyVar -> TyVar -> Bool
$c/= :: TyVar -> TyVar -> Bool
/= :: TyVar -> TyVar -> Bool
Eq, Int -> TyVar -> ShowS
[TyVar] -> ShowS
TyVar -> String
(Int -> TyVar -> ShowS)
-> (TyVar -> String) -> ([TyVar] -> ShowS) -> Show TyVar
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TyVar -> ShowS
showsPrec :: Int -> TyVar -> ShowS
$cshow :: TyVar -> String
show :: TyVar -> String
$cshowList :: [TyVar] -> ShowS
showList :: [TyVar] -> ShowS
Show, Typeable TyVar
Typeable TyVar
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TyVar -> c TyVar)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TyVar)
-> (TyVar -> Constr)
-> (TyVar -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TyVar))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVar))
-> ((forall b. Data b => b -> b) -> TyVar -> TyVar)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVar -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVar -> r)
-> (forall u. (forall d. Data d => d -> u) -> TyVar -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TyVar -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TyVar -> m TyVar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyVar -> m TyVar)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TyVar -> m TyVar)
-> Data TyVar
TyVar -> Constr
TyVar -> DataType
(forall b. Data b => b -> b) -> TyVar -> TyVar
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TyVar -> u
forall u. (forall d. Data d => d -> u) -> TyVar -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVar -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVar -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVar -> m TyVar
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVar -> m TyVar
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVar
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVar -> c TyVar
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyVar)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVar)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVar -> c TyVar
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TyVar -> c TyVar
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVar
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TyVar
$ctoConstr :: TyVar -> Constr
toConstr :: TyVar -> Constr
$cdataTypeOf :: TyVar -> DataType
dataTypeOf :: TyVar -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyVar)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TyVar)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVar)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyVar)
$cgmapT :: (forall b. Data b => b -> b) -> TyVar -> TyVar
gmapT :: (forall b. Data b => b -> b) -> TyVar -> TyVar
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVar -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyVar -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVar -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyVar -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TyVar -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TyVar -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyVar -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TyVar -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVar -> m TyVar
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TyVar -> m TyVar
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVar -> m TyVar
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVar -> m TyVar
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVar -> m TyVar
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TyVar -> m TyVar
Data, (forall x. TyVar -> Rep TyVar x)
-> (forall x. Rep TyVar x -> TyVar) -> Generic TyVar
forall x. Rep TyVar x -> TyVar
forall x. TyVar -> Rep TyVar x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TyVar -> Rep TyVar x
from :: forall x. TyVar -> Rep TyVar x
$cto :: forall x. Rep TyVar x -> TyVar
to :: forall x. Rep TyVar x -> TyVar
Generic)
  deriving anyclass [TyVar] -> Doc
TyVar -> Doc
(TyVar -> Doc) -> ([TyVar] -> Doc) -> Buildable TyVar
forall a. (a -> Doc) -> ([a] -> Doc) -> Buildable a
$cbuild :: TyVar -> Doc
build :: TyVar -> Doc
$cbuildList :: [TyVar] -> Doc
buildList :: [TyVar] -> Doc
Buildable

instance NFData TyVar

-- | A stack pattern-match
data StackTypePattern
 = StkEmpty
 | StkRest
 | StkCons TyVar StackTypePattern
  deriving stock (StackTypePattern -> StackTypePattern -> Bool
(StackTypePattern -> StackTypePattern -> Bool)
-> (StackTypePattern -> StackTypePattern -> Bool)
-> Eq StackTypePattern
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: StackTypePattern -> StackTypePattern -> Bool
== :: StackTypePattern -> StackTypePattern -> Bool
$c/= :: StackTypePattern -> StackTypePattern -> Bool
/= :: StackTypePattern -> StackTypePattern -> Bool
Eq, Int -> StackTypePattern -> ShowS
[StackTypePattern] -> ShowS
StackTypePattern -> String
(Int -> StackTypePattern -> ShowS)
-> (StackTypePattern -> String)
-> ([StackTypePattern] -> ShowS)
-> Show StackTypePattern
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> StackTypePattern -> ShowS
showsPrec :: Int -> StackTypePattern -> ShowS
$cshow :: StackTypePattern -> String
show :: StackTypePattern -> String
$cshowList :: [StackTypePattern] -> ShowS
showList :: [StackTypePattern] -> ShowS
Show, Typeable StackTypePattern
Typeable StackTypePattern
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> StackTypePattern -> c StackTypePattern)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c StackTypePattern)
-> (StackTypePattern -> Constr)
-> (StackTypePattern -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c StackTypePattern))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c StackTypePattern))
-> ((forall b. Data b => b -> b)
    -> StackTypePattern -> StackTypePattern)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> StackTypePattern -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> StackTypePattern -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> StackTypePattern -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> StackTypePattern -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> StackTypePattern -> m StackTypePattern)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StackTypePattern -> m StackTypePattern)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> StackTypePattern -> m StackTypePattern)
-> Data StackTypePattern
StackTypePattern -> Constr
StackTypePattern -> DataType
(forall b. Data b => b -> b)
-> StackTypePattern -> StackTypePattern
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> StackTypePattern -> u
forall u. (forall d. Data d => d -> u) -> StackTypePattern -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StackTypePattern -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StackTypePattern -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StackTypePattern -> m StackTypePattern
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StackTypePattern -> m StackTypePattern
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StackTypePattern
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StackTypePattern -> c StackTypePattern
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StackTypePattern)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StackTypePattern)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StackTypePattern -> c StackTypePattern
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> StackTypePattern -> c StackTypePattern
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StackTypePattern
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c StackTypePattern
$ctoConstr :: StackTypePattern -> Constr
toConstr :: StackTypePattern -> Constr
$cdataTypeOf :: StackTypePattern -> DataType
dataTypeOf :: StackTypePattern -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StackTypePattern)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c StackTypePattern)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StackTypePattern)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c StackTypePattern)
$cgmapT :: (forall b. Data b => b -> b)
-> StackTypePattern -> StackTypePattern
gmapT :: (forall b. Data b => b -> b)
-> StackTypePattern -> StackTypePattern
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StackTypePattern -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> StackTypePattern -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StackTypePattern -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> StackTypePattern -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> StackTypePattern -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> StackTypePattern -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StackTypePattern -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> StackTypePattern -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StackTypePattern -> m StackTypePattern
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> StackTypePattern -> m StackTypePattern
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StackTypePattern -> m StackTypePattern
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StackTypePattern -> m StackTypePattern
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StackTypePattern -> m StackTypePattern
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> StackTypePattern -> m StackTypePattern
Data, (forall x. StackTypePattern -> Rep StackTypePattern x)
-> (forall x. Rep StackTypePattern x -> StackTypePattern)
-> Generic StackTypePattern
forall x. Rep StackTypePattern x -> StackTypePattern
forall x. StackTypePattern -> Rep StackTypePattern x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. StackTypePattern -> Rep StackTypePattern x
from :: forall x. StackTypePattern -> Rep StackTypePattern x
$cto :: forall x. Rep StackTypePattern x -> StackTypePattern
to :: forall x. Rep StackTypePattern x -> StackTypePattern
Generic)

instance NFData StackTypePattern

-- | Convert 'StackTypePattern' to a list of types. Also returns
-- 'Bool' which is 'True' if the pattern is a fixed list of types and
-- 'False' if it's a pattern match on the head of the stack.
stackTypePatternToList :: StackTypePattern -> ([TyVar], Bool)
stackTypePatternToList :: StackTypePattern -> ([TyVar], Bool)
stackTypePatternToList StackTypePattern
StkEmpty = ([], Bool
True)
stackTypePatternToList StackTypePattern
StkRest = ([], Bool
False)
stackTypePatternToList (StkCons TyVar
t StackTypePattern
pat) =
  ([TyVar] -> [TyVar]) -> ([TyVar], Bool) -> ([TyVar], Bool)
forall a b c. (a -> b) -> (a, c) -> (b, c)
forall (p :: * -> * -> *) a b c.
Bifunctor p =>
(a -> b) -> p a c -> p b c
first (TyVar
t TyVar -> [TyVar] -> [TyVar]
forall a. a -> [a] -> [a]
:) (([TyVar], Bool) -> ([TyVar], Bool))
-> ([TyVar], Bool) -> ([TyVar], Bool)
forall a b. (a -> b) -> a -> b
$ StackTypePattern -> ([TyVar], Bool)
stackTypePatternToList StackTypePattern
pat

instance Buildable StackTypePattern where
  build :: StackTypePattern -> Doc
build = [Doc] -> Doc
forall a (f :: * -> *). (Buildable a, Foldable f) => f a -> Doc
listF ([Doc] -> Doc)
-> (StackTypePattern -> [Doc]) -> StackTypePattern -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([TyVar], Bool) -> [Doc]
pairToList (([TyVar], Bool) -> [Doc])
-> (StackTypePattern -> ([TyVar], Bool))
-> StackTypePattern
-> [Doc]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. StackTypePattern -> ([TyVar], Bool)
stackTypePatternToList
    where
      pairToList :: ([TyVar], Bool) -> [Doc]
      pairToList :: ([TyVar], Bool) -> [Doc]
pairToList ([TyVar]
types, Bool
fixed)
        | Bool
fixed = (TyVar -> Doc) -> [TyVar] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map TyVar -> Doc
forall a. Buildable a => a -> Doc
build [TyVar]
types
        | Bool
otherwise = (TyVar -> Doc) -> [TyVar] -> [Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
map TyVar -> Doc
forall a. Buildable a => a -> Doc
build [TyVar]
types [Doc] -> [Doc] -> [Doc]
forall a. [a] -> [a] -> [a]
++ [Doc
"..."]

-- | Get the set of variables in a stack pattern
varSet :: StackTypePattern -> Set Var
varSet :: StackTypePattern -> Set Var
varSet = \case
  StackTypePattern
StkEmpty -> Set Var
forall a. Set a
Set.empty
  StackTypePattern
StkRest -> Set Var
forall a. Set a
Set.empty
  (StkCons (VarID Var
v) StackTypePattern
stk) -> Var
v Var -> Set Var -> Set Var
forall a. Ord a => a -> Set a -> Set a
`Set.insert` (StackTypePattern -> Set Var
varSet StackTypePattern
stk)
  (StkCons TyVar
_ StackTypePattern
stk) -> StackTypePattern -> Set Var
varSet StackTypePattern
stk

-- | A comment with optional embedded 'StackRef's. Used with @PRINT@ extended instruction.
newtype PrintComment = PrintComment
  { PrintComment -> [Either Text StackRef]
unUPrintComment :: [Either T.Text StackRef]
  } deriving stock (PrintComment -> PrintComment -> Bool
(PrintComment -> PrintComment -> Bool)
-> (PrintComment -> PrintComment -> Bool) -> Eq PrintComment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PrintComment -> PrintComment -> Bool
== :: PrintComment -> PrintComment -> Bool
$c/= :: PrintComment -> PrintComment -> Bool
/= :: PrintComment -> PrintComment -> Bool
Eq, Int -> PrintComment -> ShowS
[PrintComment] -> ShowS
PrintComment -> String
(Int -> PrintComment -> ShowS)
-> (PrintComment -> String)
-> ([PrintComment] -> ShowS)
-> Show PrintComment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PrintComment -> ShowS
showsPrec :: Int -> PrintComment -> ShowS
$cshow :: PrintComment -> String
show :: PrintComment -> String
$cshowList :: [PrintComment] -> ShowS
showList :: [PrintComment] -> ShowS
Show, Typeable PrintComment
Typeable PrintComment
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PrintComment -> c PrintComment)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PrintComment)
-> (PrintComment -> Constr)
-> (PrintComment -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PrintComment))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PrintComment))
-> ((forall b. Data b => b -> b) -> PrintComment -> PrintComment)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PrintComment -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PrintComment -> r)
-> (forall u. (forall d. Data d => d -> u) -> PrintComment -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PrintComment -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PrintComment -> m PrintComment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrintComment -> m PrintComment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PrintComment -> m PrintComment)
-> Data PrintComment
PrintComment -> Constr
PrintComment -> DataType
(forall b. Data b => b -> b) -> PrintComment -> PrintComment
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PrintComment -> u
forall u. (forall d. Data d => d -> u) -> PrintComment -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrintComment -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrintComment -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrintComment -> m PrintComment
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrintComment -> m PrintComment
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrintComment
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrintComment -> c PrintComment
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrintComment)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrintComment)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrintComment -> c PrintComment
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PrintComment -> c PrintComment
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrintComment
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PrintComment
$ctoConstr :: PrintComment -> Constr
toConstr :: PrintComment -> Constr
$cdataTypeOf :: PrintComment -> DataType
dataTypeOf :: PrintComment -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrintComment)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PrintComment)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrintComment)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PrintComment)
$cgmapT :: (forall b. Data b => b -> b) -> PrintComment -> PrintComment
gmapT :: (forall b. Data b => b -> b) -> PrintComment -> PrintComment
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrintComment -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PrintComment -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrintComment -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PrintComment -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PrintComment -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PrintComment -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrintComment -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PrintComment -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrintComment -> m PrintComment
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PrintComment -> m PrintComment
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrintComment -> m PrintComment
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrintComment -> m PrintComment
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrintComment -> m PrintComment
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PrintComment -> m PrintComment
Data, (forall x. PrintComment -> Rep PrintComment x)
-> (forall x. Rep PrintComment x -> PrintComment)
-> Generic PrintComment
forall x. Rep PrintComment x -> PrintComment
forall x. PrintComment -> Rep PrintComment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PrintComment -> Rep PrintComment x
from :: forall x. PrintComment -> Rep PrintComment x
$cto :: forall x. Rep PrintComment x -> PrintComment
to :: forall x. Rep PrintComment x -> PrintComment
Generic)

instance NFData PrintComment

instance Buildable PrintComment where
  build :: PrintComment -> Doc
build = (Element [Either Text StackRef] -> Doc)
-> [Either Text StackRef] -> Doc
forall m.
Monoid m =>
(Element [Either Text StackRef] -> m)
-> [Either Text StackRef] -> m
forall t m. (Container t, Monoid m) => (Element t -> m) -> t -> m
foldMap ((Text -> Doc) -> (StackRef -> Doc) -> Either Text StackRef -> Doc
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either Text -> Doc
forall a. Buildable a => a -> Doc
build StackRef -> Doc
forall a. Buildable a => a -> Doc
build) ([Either Text StackRef] -> Doc)
-> (PrintComment -> [Either Text StackRef]) -> PrintComment -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PrintComment -> [Either Text StackRef]
unUPrintComment

-- | An inline test assertion
data TestAssert f (op :: Type) = TestAssert
  { forall (f :: * -> *) op. TestAssert f op -> Text
tassName :: T.Text
  , forall (f :: * -> *) op. TestAssert f op -> PrintComment
tassComment :: PrintComment
  , forall (f :: * -> *) op. TestAssert f op -> f op
tassInstrs :: f op
  } deriving stock (TestAssert f op -> TestAssert f op -> Bool
(TestAssert f op -> TestAssert f op -> Bool)
-> (TestAssert f op -> TestAssert f op -> Bool)
-> Eq (TestAssert f op)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: * -> *) op.
Eq (f op) =>
TestAssert f op -> TestAssert f op -> Bool
$c== :: forall (f :: * -> *) op.
Eq (f op) =>
TestAssert f op -> TestAssert f op -> Bool
== :: TestAssert f op -> TestAssert f op -> Bool
$c/= :: forall (f :: * -> *) op.
Eq (f op) =>
TestAssert f op -> TestAssert f op -> Bool
/= :: TestAssert f op -> TestAssert f op -> Bool
Eq, Int -> TestAssert f op -> ShowS
[TestAssert f op] -> ShowS
TestAssert f op -> String
(Int -> TestAssert f op -> ShowS)
-> (TestAssert f op -> String)
-> ([TestAssert f op] -> ShowS)
-> Show (TestAssert f op)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: * -> *) op.
Show (f op) =>
Int -> TestAssert f op -> ShowS
forall (f :: * -> *) op. Show (f op) => [TestAssert f op] -> ShowS
forall (f :: * -> *) op. Show (f op) => TestAssert f op -> String
$cshowsPrec :: forall (f :: * -> *) op.
Show (f op) =>
Int -> TestAssert f op -> ShowS
showsPrec :: Int -> TestAssert f op -> ShowS
$cshow :: forall (f :: * -> *) op. Show (f op) => TestAssert f op -> String
show :: TestAssert f op -> String
$cshowList :: forall (f :: * -> *) op. Show (f op) => [TestAssert f op] -> ShowS
showList :: [TestAssert f op] -> ShowS
Show, (forall a b. (a -> b) -> TestAssert f a -> TestAssert f b)
-> (forall a b. a -> TestAssert f b -> TestAssert f a)
-> Functor (TestAssert f)
forall a b. a -> TestAssert f b -> TestAssert f a
forall a b. (a -> b) -> TestAssert f a -> TestAssert f b
forall (f :: * -> *) a b.
Functor f =>
a -> TestAssert f b -> TestAssert f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> TestAssert f a -> TestAssert f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> TestAssert f a -> TestAssert f b
fmap :: forall a b. (a -> b) -> TestAssert f a -> TestAssert f b
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> TestAssert f b -> TestAssert f a
<$ :: forall a b. a -> TestAssert f b -> TestAssert f a
Functor, Typeable (TestAssert f op)
Typeable (TestAssert f op)
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TestAssert f op -> c (TestAssert f op))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (TestAssert f op))
-> (TestAssert f op -> Constr)
-> (TestAssert f op -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (TestAssert f op)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (TestAssert f op)))
-> ((forall b. Data b => b -> b)
    -> TestAssert f op -> TestAssert f op)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TestAssert f op -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TestAssert f op -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> TestAssert f op -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> TestAssert f op -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> TestAssert f op -> m (TestAssert f op))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TestAssert f op -> m (TestAssert f op))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> TestAssert f op -> m (TestAssert f op))
-> Data (TestAssert f op)
TestAssert f op -> Constr
TestAssert f op -> DataType
(forall b. Data b => b -> b) -> TestAssert f op -> TestAssert f op
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> TestAssert f op -> u
forall u. (forall d. Data d => d -> u) -> TestAssert f op -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TestAssert f op -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TestAssert f op -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TestAssert f op -> m (TestAssert f op)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TestAssert f op -> m (TestAssert f op)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TestAssert f op)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TestAssert f op -> c (TestAssert f op)
forall {f :: * -> *} {op}.
(Typeable f, Typeable op, Data (f op)) =>
Typeable (TestAssert f op)
forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
TestAssert f op -> Constr
forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
TestAssert f op -> DataType
forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
(forall b. Data b => b -> b) -> TestAssert f op -> TestAssert f op
forall (f :: * -> *) op u.
(Typeable f, Typeable op, Data (f op)) =>
Int -> (forall d. Data d => d -> u) -> TestAssert f op -> u
forall (f :: * -> *) op u.
(Typeable f, Typeable op, Data (f op)) =>
(forall d. Data d => d -> u) -> TestAssert f op -> [u]
forall (f :: * -> *) op r r'.
(Typeable f, Typeable op, Data (f op)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TestAssert f op -> r
forall (f :: * -> *) op r r'.
(Typeable f, Typeable op, Data (f op)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TestAssert f op -> r
forall (f :: * -> *) op (m :: * -> *).
(Typeable f, Typeable op, Data (f op), Monad m) =>
(forall d. Data d => d -> m d)
-> TestAssert f op -> m (TestAssert f op)
forall (f :: * -> *) op (m :: * -> *).
(Typeable f, Typeable op, Data (f op), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> TestAssert f op -> m (TestAssert f op)
forall (f :: * -> *) op (c :: * -> *).
(Typeable f, Typeable op, Data (f op)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TestAssert f op)
forall (f :: * -> *) op (c :: * -> *).
(Typeable f, Typeable op, Data (f op)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TestAssert f op -> c (TestAssert f op)
forall (f :: * -> *) op (t :: * -> *) (c :: * -> *).
(Typeable f, Typeable op, Data (f op), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TestAssert f op))
forall (f :: * -> *) op (t :: * -> * -> *) (c :: * -> *).
(Typeable f, Typeable op, Data (f op), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TestAssert f op))
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TestAssert f op))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TestAssert f op))
$cgfoldl :: forall (f :: * -> *) op (c :: * -> *).
(Typeable f, Typeable op, Data (f op)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TestAssert f op -> c (TestAssert f op)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TestAssert f op -> c (TestAssert f op)
$cgunfold :: forall (f :: * -> *) op (c :: * -> *).
(Typeable f, Typeable op, Data (f op)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TestAssert f op)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (TestAssert f op)
$ctoConstr :: forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
TestAssert f op -> Constr
toConstr :: TestAssert f op -> Constr
$cdataTypeOf :: forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
TestAssert f op -> DataType
dataTypeOf :: TestAssert f op -> DataType
$cdataCast1 :: forall (f :: * -> *) op (t :: * -> *) (c :: * -> *).
(Typeable f, Typeable op, Data (f op), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (TestAssert f op))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (TestAssert f op))
$cdataCast2 :: forall (f :: * -> *) op (t :: * -> * -> *) (c :: * -> *).
(Typeable f, Typeable op, Data (f op), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TestAssert f op))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (TestAssert f op))
$cgmapT :: forall (f :: * -> *) op.
(Typeable f, Typeable op, Data (f op)) =>
(forall b. Data b => b -> b) -> TestAssert f op -> TestAssert f op
gmapT :: (forall b. Data b => b -> b) -> TestAssert f op -> TestAssert f op
$cgmapQl :: forall (f :: * -> *) op r r'.
(Typeable f, Typeable op, Data (f op)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TestAssert f op -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> TestAssert f op -> r
$cgmapQr :: forall (f :: * -> *) op r r'.
(Typeable f, Typeable op, Data (f op)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TestAssert f op -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> TestAssert f op -> r
$cgmapQ :: forall (f :: * -> *) op u.
(Typeable f, Typeable op, Data (f op)) =>
(forall d. Data d => d -> u) -> TestAssert f op -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TestAssert f op -> [u]
$cgmapQi :: forall (f :: * -> *) op u.
(Typeable f, Typeable op, Data (f op)) =>
Int -> (forall d. Data d => d -> u) -> TestAssert f op -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> TestAssert f op -> u
$cgmapM :: forall (f :: * -> *) op (m :: * -> *).
(Typeable f, Typeable op, Data (f op), Monad m) =>
(forall d. Data d => d -> m d)
-> TestAssert f op -> m (TestAssert f op)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> TestAssert f op -> m (TestAssert f op)
$cgmapMp :: forall (f :: * -> *) op (m :: * -> *).
(Typeable f, Typeable op, Data (f op), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> TestAssert f op -> m (TestAssert f op)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TestAssert f op -> m (TestAssert f op)
$cgmapMo :: forall (f :: * -> *) op (m :: * -> *).
(Typeable f, Typeable op, Data (f op), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> TestAssert f op -> m (TestAssert f op)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> TestAssert f op -> m (TestAssert f op)
Data, (forall x. TestAssert f op -> Rep (TestAssert f op) x)
-> (forall x. Rep (TestAssert f op) x -> TestAssert f op)
-> Generic (TestAssert f op)
forall x. Rep (TestAssert f op) x -> TestAssert f op
forall x. TestAssert f op -> Rep (TestAssert f op) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) op x.
Rep (TestAssert f op) x -> TestAssert f op
forall (f :: * -> *) op x.
TestAssert f op -> Rep (TestAssert f op) x
$cfrom :: forall (f :: * -> *) op x.
TestAssert f op -> Rep (TestAssert f op) x
from :: forall x. TestAssert f op -> Rep (TestAssert f op) x
$cto :: forall (f :: * -> *) op x.
Rep (TestAssert f op) x -> TestAssert f op
to :: forall x. Rep (TestAssert f op) x -> TestAssert f op
Generic)

instance HoistInstr TestAssert where
  hoistInstr :: forall (f :: * -> *) a (g :: * -> *).
(f a -> g a) -> TestAssert f a -> TestAssert g a
hoistInstr f a -> g a
f TestAssert{f a
Text
PrintComment
tassName :: forall (f :: * -> *) op. TestAssert f op -> Text
tassComment :: forall (f :: * -> *) op. TestAssert f op -> PrintComment
tassInstrs :: forall (f :: * -> *) op. TestAssert f op -> f op
tassName :: Text
tassComment :: PrintComment
tassInstrs :: f a
..} = TestAssert{tassInstrs :: g a
tassInstrs = f a -> g a
f f a
tassInstrs, Text
PrintComment
tassName :: Text
tassComment :: PrintComment
tassName :: Text
tassComment :: PrintComment
..}

instance NFData (f op) => NFData (TestAssert f op)

instance (Foldable f, Buildable op) => Buildable (TestAssert f op) where
  build :: TestAssert f op -> Doc
build (TestAssert Text
name PrintComment
comment f op
instrs) =
    Doc -> Doc -> Doc
forall a. Buildable a => Doc -> a -> Doc
nameF Doc
"TestAssert" (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ [(Text, Doc)] -> Doc
forall k v f.
(Buildable k, Buildable v, IsList f, Item f ~ (k, v)) =>
f -> Doc
blockMapF
      [ (Text
"Name" :: Text, Text -> Doc
forall a. Buildable a => a -> Doc
build Text
name)
      , (Text
"Comment", PrintComment -> Doc
forall a. Buildable a => a -> Doc
build PrintComment
comment)
      , (Text
"Instrs", f op -> Doc
forall a (f :: * -> *). (Buildable a, Foldable f) => f a -> Doc
blockListF f op
instrs)
      ]


-------------------------------------
-- Aeson instances
-------------------------------------

deriveJSON morleyAesonOptions ''StackRef
deriveJSON morleyAesonOptions ''PrintComment

instance FromJSON (f op) => FromJSON (TestAssert f op) where
    parseJSON :: Value -> Parser (TestAssert f op)
parseJSON = Options -> Value -> Parser (TestAssert f op)
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON Options
morleyAesonOptions
instance ToJSON (f op) => ToJSON (TestAssert f op) where
    toJSON :: TestAssert f op -> Value
toJSON     = Options -> TestAssert f op -> Value
forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
genericToJSON Options
morleyAesonOptions
    toEncoding :: TestAssert f op -> Encoding
toEncoding = Options -> TestAssert f op -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
morleyAesonOptions

deriveJSON morleyAesonOptions ''Var
deriveJSON morleyAesonOptions ''TyVar
deriveJSON morleyAesonOptions ''StackTypePattern

instance FromJSON (f op) => FromJSON (ExtInstrAbstract f op) where
    parseJSON :: Value -> Parser (ExtInstrAbstract f op)
parseJSON = Options -> Value -> Parser (ExtInstrAbstract f op)
forall a.
(Generic a, GFromJSON Zero (Rep a)) =>
Options -> Value -> Parser a
genericParseJSON Options
morleyAesonOptions
instance ToJSON (f op) => ToJSON (ExtInstrAbstract f op) where
    toJSON :: ExtInstrAbstract f op -> Value
toJSON     = Options -> ExtInstrAbstract f op -> Value
forall a.
(Generic a, GToJSON' Value Zero (Rep a)) =>
Options -> a -> Value
genericToJSON Options
morleyAesonOptions
    toEncoding :: ExtInstrAbstract f op -> Encoding
toEncoding = Options -> ExtInstrAbstract f op -> Encoding
forall a.
(Generic a, GToJSON' Encoding Zero (Rep a)) =>
Options -> a -> Encoding
genericToEncoding Options
morleyAesonOptions