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

-- 'newtype Container' deriving produced some fake warnings
{-# OPTIONS_GHC -Wno-redundant-constraints #-}

-- | Module, containing on-chain views declarations.
module Morley.Michelson.Typed.View
  ( -- * View
    ViewName (ViewName, ..)
  , BadViewNameError (..)
  , mkViewName
  , viewNameToMText

  , ViewCode'
  , View' (..)
  , SomeView' (..)
  , someViewName

    -- * Views set
  , ViewsSet' (.., ViewsList)
  , VS.ViewsSetError (..)
  , mkViewsSet
  , emptyViewsSet
  , addViewToSet
  , lookupView
  , viewsSetNames
  , SomeViewsSet' (..)
  ) where

import Data.Coerce (coerce)
import Data.Default (Default(..))

import Morley.Michelson.Internal.ViewName
import Morley.Michelson.Internal.ViewsSet qualified as VS
import Morley.Michelson.Typed.Annotation
import Morley.Michelson.Typed.Scope
import Morley.Michelson.Typed.T (T(..))
import Morley.Util.Sing

type ViewCode' instr arg st ret = instr '[ 'TPair arg st] '[ret]

-- | Contract view.
data View' instr arg st ret = (ViewableScope arg, SingI st, ViewableScope ret) => View
  { forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret -> ViewName
vName :: ViewName
    -- ^ Name of the view.
  , forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret -> Notes arg
vArgument :: Notes arg
    -- ^ Argument type annotations.
  , forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret -> Notes ret
vReturn :: Notes ret
    -- ^ Return type annotations.
  , forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret -> ViewCode' instr arg st ret
vCode :: ViewCode' instr arg st ret
    -- ^ View code.
  }

deriving stock instance Show (ViewCode' instr arg st ret) => Show (View' instr arg st ret)
deriving stock instance Eq (ViewCode' instr arg st ret) => Eq (View' instr arg st ret)
instance NFData (ViewCode' instr arg st ret) => NFData (View' instr arg st ret) where
  rnf :: View' instr arg st ret -> ()
rnf (View ViewName
a Notes arg
b Notes ret
c ViewCode' instr arg st ret
d) = (ViewName, Notes arg, Notes ret, ViewCode' instr arg st ret) -> ()
forall a. NFData a => a -> ()
rnf (ViewName
a, Notes arg
b, Notes ret
c, ViewCode' instr arg st ret
d)

data SomeView' instr st where
  SomeView :: View' instr arg st ret -> SomeView' instr st

deriving stock instance
  (forall arg ret. Show (ViewCode' instr arg st ret)) =>
  Show (SomeView' instr st)
instance
  (forall arg ret. Eq (ViewCode' instr arg st ret)) =>
  Eq (SomeView' instr st) where
    SomeView v1 :: View' instr arg st ret
v1@View{} == :: SomeView' instr st -> SomeView' instr st -> Bool
== SomeView v2 :: View' instr arg st ret
v2@View{} = View' instr arg st ret
v1 View' instr arg st ret -> View' instr arg st ret -> Bool
forall {k1} {k2} {k3} (a1 :: k1) (a2 :: k1) (b1 :: k2) (b2 :: k2)
       (c1 :: k3) (c2 :: k3) (t :: k1 -> k2 -> k3 -> *).
(SingI a1, SingI a2, SingI b1, SingI b2, SingI c1, SingI c2,
 SDecide k1, SDecide k2, SDecide k3, Eq (t a1 b1 c1)) =>
t a1 b1 c1 -> t a2 b2 c2 -> Bool
`eqParamSing3` View' instr arg st ret
v2
instance
  (forall arg ret. NFData (ViewCode' instr arg st ret)) =>
  NFData (SomeView' instr st) where
    rnf :: SomeView' instr st -> ()
rnf (SomeView View' instr arg st ret
v) = View' instr arg st ret -> ()
forall a. NFData a => a -> ()
rnf View' instr arg st ret
v

-- | Obtain the name of the view.
someViewName :: SomeView' instr st -> ViewName
someViewName :: forall (instr :: [T] -> [T] -> *) (st :: T).
SomeView' instr st -> ViewName
someViewName (SomeView View' instr arg st ret
v) = View' instr arg st ret -> ViewName
forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret -> ViewName
vName View' instr arg st ret
v

-- View sets
----------------------------------------------------------------------------

-- | Views that belong to one contract.
newtype ViewsSet' instr st = ViewsSet { forall (instr :: [T] -> [T] -> *) (st :: T).
ViewsSet' instr st -> Map ViewName (SomeView' instr st)
unViewsSet :: Map ViewName (SomeView' instr st) }
  deriving newtype (ViewsSet' instr st
ViewsSet' instr st -> Default (ViewsSet' instr st)
forall a. a -> Default a
forall (instr :: [T] -> [T] -> *) (st :: T). ViewsSet' instr st
$cdef :: forall (instr :: [T] -> [T] -> *) (st :: T). ViewsSet' instr st
def :: ViewsSet' instr st
Default, Eq (Element (ViewsSet' instr st)) =>
Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool
Ord (Element (ViewsSet' instr st)) =>
ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
Monoid (Element (ViewsSet' instr st)) =>
ViewsSet' instr st -> Element (ViewsSet' instr st)
(Element (ViewsSet' instr st) ~ Bool) => ViewsSet' instr st -> Bool
ViewsSet' instr st -> Bool
ViewsSet' instr st -> Int
ViewsSet' instr st -> [Element (ViewsSet' instr st)]
ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
(Element (ViewsSet' instr st) -> Bool)
-> ViewsSet' instr st -> Bool
(Element (ViewsSet' instr st) -> Bool)
-> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
(Element (ViewsSet' instr st)
 -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st))
-> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
(ViewsSet' instr st -> [Element (ViewsSet' instr st)])
-> (ViewsSet' instr st -> Bool)
-> (forall b.
    (Element (ViewsSet' instr st) -> b -> b)
    -> b -> ViewsSet' instr st -> b)
-> (forall b.
    (b -> Element (ViewsSet' instr st) -> b)
    -> b -> ViewsSet' instr st -> b)
-> (forall b.
    (b -> Element (ViewsSet' instr st) -> b)
    -> b -> ViewsSet' instr st -> b)
-> (ViewsSet' instr st -> Int)
-> (Eq (Element (ViewsSet' instr st)) =>
    Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool)
-> (forall m.
    Monoid m =>
    (Element (ViewsSet' instr st) -> m) -> ViewsSet' instr st -> m)
-> (Monoid (Element (ViewsSet' instr st)) =>
    ViewsSet' instr st -> Element (ViewsSet' instr st))
-> (forall b.
    (Element (ViewsSet' instr st) -> b -> b)
    -> b -> ViewsSet' instr st -> b)
-> (Eq (Element (ViewsSet' instr st)) =>
    Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool)
-> ((Element (ViewsSet' instr st) -> Bool)
    -> ViewsSet' instr st -> Bool)
-> ((Element (ViewsSet' instr st) -> Bool)
    -> ViewsSet' instr st -> Bool)
-> ((Element (ViewsSet' instr st) ~ Bool) =>
    ViewsSet' instr st -> Bool)
-> ((Element (ViewsSet' instr st) ~ Bool) =>
    ViewsSet' instr st -> Bool)
-> ((Element (ViewsSet' instr st) -> Bool)
    -> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)))
-> (ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)))
-> (Ord (Element (ViewsSet' instr st)) =>
    ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)))
-> (Ord (Element (ViewsSet' instr st)) =>
    ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)))
-> ((Element (ViewsSet' instr st)
     -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st))
    -> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)))
-> ((Element (ViewsSet' instr st)
     -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st))
    -> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st)))
-> Container (ViewsSet' instr st)
forall m.
Monoid m =>
(Element (ViewsSet' instr st) -> m) -> ViewsSet' instr st -> m
forall t.
(t -> [Element t])
-> (t -> Bool)
-> (forall b. (Element t -> b -> b) -> b -> t -> b)
-> (forall b. (b -> Element t -> b) -> b -> t -> b)
-> (forall b. (b -> Element t -> b) -> b -> t -> b)
-> (t -> Int)
-> (Eq (Element t) => Element t -> t -> Bool)
-> (forall m. Monoid m => (Element t -> m) -> t -> m)
-> (Monoid (Element t) => t -> Element t)
-> (forall b. (Element t -> b -> b) -> b -> t -> b)
-> (Eq (Element t) => Element t -> t -> Bool)
-> ((Element t -> Bool) -> t -> Bool)
-> ((Element t -> Bool) -> t -> Bool)
-> ((Element t ~ Bool) => t -> Bool)
-> ((Element t ~ Bool) => t -> Bool)
-> ((Element t -> Bool) -> t -> Maybe (Element t))
-> (t -> Maybe (Element t))
-> (Ord (Element t) => t -> Maybe (Element t))
-> (Ord (Element t) => t -> Maybe (Element t))
-> ((Element t -> Element t -> Element t)
    -> t -> Maybe (Element t))
-> ((Element t -> Element t -> Element t)
    -> t -> Maybe (Element t))
-> Container t
forall b.
(b -> Element (ViewsSet' instr st) -> b)
-> b -> ViewsSet' instr st -> b
forall b.
(Element (ViewsSet' instr st) -> b -> b)
-> b -> ViewsSet' instr st -> b
forall (instr :: [T] -> [T] -> *) (st :: T).
Eq (Element (ViewsSet' instr st)) =>
Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool
forall (instr :: [T] -> [T] -> *) (st :: T).
Ord (Element (ViewsSet' instr st)) =>
ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
forall (instr :: [T] -> [T] -> *) (st :: T).
Monoid (Element (ViewsSet' instr st)) =>
ViewsSet' instr st -> Element (ViewsSet' instr st)
forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st) ~ Bool) =>
ViewsSet' instr st -> Bool
forall (instr :: [T] -> [T] -> *) (st :: T).
ViewsSet' instr st -> Bool
forall (instr :: [T] -> [T] -> *) (st :: T).
ViewsSet' instr st -> Int
forall (instr :: [T] -> [T] -> *) (st :: T).
ViewsSet' instr st -> [Element (ViewsSet' instr st)]
forall (instr :: [T] -> [T] -> *) (st :: T).
ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st) -> Bool)
-> ViewsSet' instr st -> Bool
forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st) -> Bool)
-> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st)
 -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st))
-> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
forall (instr :: [T] -> [T] -> *) (st :: T) m.
Monoid m =>
(Element (ViewsSet' instr st) -> m) -> ViewsSet' instr st -> m
forall (instr :: [T] -> [T] -> *) (st :: T) b.
(b -> Element (ViewsSet' instr st) -> b)
-> b -> ViewsSet' instr st -> b
forall (instr :: [T] -> [T] -> *) (st :: T) b.
(Element (ViewsSet' instr st) -> b -> b)
-> b -> ViewsSet' instr st -> b
$ctoList :: forall (instr :: [T] -> [T] -> *) (st :: T).
ViewsSet' instr st -> [Element (ViewsSet' instr st)]
toList :: ViewsSet' instr st -> [Element (ViewsSet' instr st)]
$cnull :: forall (instr :: [T] -> [T] -> *) (st :: T).
ViewsSet' instr st -> Bool
null :: ViewsSet' instr st -> Bool
$cfoldr :: forall (instr :: [T] -> [T] -> *) (st :: T) b.
(Element (ViewsSet' instr st) -> b -> b)
-> b -> ViewsSet' instr st -> b
foldr :: forall b.
(Element (ViewsSet' instr st) -> b -> b)
-> b -> ViewsSet' instr st -> b
$cfoldl :: forall (instr :: [T] -> [T] -> *) (st :: T) b.
(b -> Element (ViewsSet' instr st) -> b)
-> b -> ViewsSet' instr st -> b
foldl :: forall b.
(b -> Element (ViewsSet' instr st) -> b)
-> b -> ViewsSet' instr st -> b
$cfoldl' :: forall (instr :: [T] -> [T] -> *) (st :: T) b.
(b -> Element (ViewsSet' instr st) -> b)
-> b -> ViewsSet' instr st -> b
foldl' :: forall b.
(b -> Element (ViewsSet' instr st) -> b)
-> b -> ViewsSet' instr st -> b
$clength :: forall (instr :: [T] -> [T] -> *) (st :: T).
ViewsSet' instr st -> Int
length :: ViewsSet' instr st -> Int
$celem :: forall (instr :: [T] -> [T] -> *) (st :: T).
Eq (Element (ViewsSet' instr st)) =>
Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool
elem :: Eq (Element (ViewsSet' instr st)) =>
Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool
$cfoldMap :: forall (instr :: [T] -> [T] -> *) (st :: T) m.
Monoid m =>
(Element (ViewsSet' instr st) -> m) -> ViewsSet' instr st -> m
foldMap :: forall m.
Monoid m =>
(Element (ViewsSet' instr st) -> m) -> ViewsSet' instr st -> m
$cfold :: forall (instr :: [T] -> [T] -> *) (st :: T).
Monoid (Element (ViewsSet' instr st)) =>
ViewsSet' instr st -> Element (ViewsSet' instr st)
fold :: Monoid (Element (ViewsSet' instr st)) =>
ViewsSet' instr st -> Element (ViewsSet' instr st)
$cfoldr' :: forall (instr :: [T] -> [T] -> *) (st :: T) b.
(Element (ViewsSet' instr st) -> b -> b)
-> b -> ViewsSet' instr st -> b
foldr' :: forall b.
(Element (ViewsSet' instr st) -> b -> b)
-> b -> ViewsSet' instr st -> b
$cnotElem :: forall (instr :: [T] -> [T] -> *) (st :: T).
Eq (Element (ViewsSet' instr st)) =>
Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool
notElem :: Eq (Element (ViewsSet' instr st)) =>
Element (ViewsSet' instr st) -> ViewsSet' instr st -> Bool
$call :: forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st) -> Bool)
-> ViewsSet' instr st -> Bool
all :: (Element (ViewsSet' instr st) -> Bool)
-> ViewsSet' instr st -> Bool
$cany :: forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st) -> Bool)
-> ViewsSet' instr st -> Bool
any :: (Element (ViewsSet' instr st) -> Bool)
-> ViewsSet' instr st -> Bool
$cand :: forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st) ~ Bool) =>
ViewsSet' instr st -> Bool
and :: (Element (ViewsSet' instr st) ~ Bool) => ViewsSet' instr st -> Bool
$cor :: forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st) ~ Bool) =>
ViewsSet' instr st -> Bool
or :: (Element (ViewsSet' instr st) ~ Bool) => ViewsSet' instr st -> Bool
$cfind :: forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st) -> Bool)
-> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
find :: (Element (ViewsSet' instr st) -> Bool)
-> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
$csafeHead :: forall (instr :: [T] -> [T] -> *) (st :: T).
ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
safeHead :: ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
$csafeMaximum :: forall (instr :: [T] -> [T] -> *) (st :: T).
Ord (Element (ViewsSet' instr st)) =>
ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
safeMaximum :: Ord (Element (ViewsSet' instr st)) =>
ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
$csafeMinimum :: forall (instr :: [T] -> [T] -> *) (st :: T).
Ord (Element (ViewsSet' instr st)) =>
ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
safeMinimum :: Ord (Element (ViewsSet' instr st)) =>
ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
$csafeFoldr1 :: forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st)
 -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st))
-> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
safeFoldr1 :: (Element (ViewsSet' instr st)
 -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st))
-> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
$csafeFoldl1 :: forall (instr :: [T] -> [T] -> *) (st :: T).
(Element (ViewsSet' instr st)
 -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st))
-> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
safeFoldl1 :: (Element (ViewsSet' instr st)
 -> Element (ViewsSet' instr st) -> Element (ViewsSet' instr st))
-> ViewsSet' instr st -> Maybe (Element (ViewsSet' instr st))
Container)

deriving stock instance
  (forall i o. Show (instr i o)) =>
  Show (ViewsSet' instr st)
deriving stock instance
  (forall i o. Eq (instr i o)) =>
  Eq (ViewsSet' instr st)
instance
  (forall i o. NFData (instr i o)) =>
  NFData (ViewsSet' instr st) where
    rnf :: ViewsSet' instr st -> ()
rnf (ViewsSet Map ViewName (SomeView' instr st)
vs) = Map ViewName (SomeView' instr st) -> ()
forall a. NFData a => a -> ()
rnf Map ViewName (SomeView' instr st)
vs

pattern ViewsList :: [SomeView' instr st] -> ViewsSet' instr st
pattern $mViewsList :: forall {r} {instr :: [T] -> [T] -> *} {st :: T}.
ViewsSet' instr st
-> ([SomeView' instr st] -> r) -> ((# #) -> r) -> r
ViewsList views <- ViewsSet (toList -> views)
{-# COMPLETE ViewsList #-}

-- | Construct views set.
mkViewsSet :: [SomeView' instr st] -> Either VS.ViewsSetError (ViewsSet' instr st)
mkViewsSet :: forall (instr :: [T] -> [T] -> *) (st :: T).
[SomeView' instr st] -> Either ViewsSetError (ViewsSet' instr st)
mkViewsSet = Either ViewsSetError (ViewsSetF (SomeView' instr st))
-> Either ViewsSetError (ViewsSet' instr st)
forall a b. Coercible a b => a -> b
coerce (Either ViewsSetError (ViewsSetF (SomeView' instr st))
 -> Either ViewsSetError (ViewsSet' instr st))
-> ([SomeView' instr st]
    -> Either ViewsSetError (ViewsSetF (SomeView' instr st)))
-> [SomeView' instr st]
-> Either ViewsSetError (ViewsSet' instr st)
forall a b c. SuperComposition a b c => a -> b -> c
... (SomeView' instr st -> ViewName)
-> [SomeView' instr st]
-> Either ViewsSetError (ViewsSetF (SomeView' instr st))
forall a.
(a -> ViewName) -> [a] -> Either ViewsSetError (ViewsSetF a)
VS.mkViewsSet SomeView' instr st -> ViewName
forall (instr :: [T] -> [T] -> *) (st :: T).
SomeView' instr st -> ViewName
someViewName

-- | No views.
emptyViewsSet :: forall instr st. ViewsSet' instr st
emptyViewsSet :: forall (instr :: [T] -> [T] -> *) (st :: T). ViewsSet' instr st
emptyViewsSet = ViewsSetF (SomeView' instr st) -> ViewsSet' instr st
forall a b. Coercible a b => a -> b
coerce (ViewsSetF (SomeView' instr st) -> ViewsSet' instr st)
-> ViewsSetF (SomeView' instr st) -> ViewsSet' instr st
forall a b. (a -> b) -> a -> b
$ forall a. ViewsSetF a
VS.emptyViewsSet @(SomeView' instr st)

-- | Add a view to set.
addViewToSet
  :: View' instr arg st ret
  -> ViewsSet' instr st
  -> Either VS.ViewsSetError (ViewsSet' instr st)
addViewToSet :: forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret
-> ViewsSet' instr st -> Either ViewsSetError (ViewsSet' instr st)
addViewToSet = (ViewsSetF (SomeView' instr st)
 -> Either ViewsSetError (ViewsSetF (SomeView' instr st)))
-> ViewsSet' instr st -> Either ViewsSetError (ViewsSet' instr st)
forall a b. Coercible a b => a -> b
coerce ((ViewsSetF (SomeView' instr st)
  -> Either ViewsSetError (ViewsSetF (SomeView' instr st)))
 -> ViewsSet' instr st -> Either ViewsSetError (ViewsSet' instr st))
-> (View' instr arg st ret
    -> ViewsSetF (SomeView' instr st)
    -> Either ViewsSetError (ViewsSetF (SomeView' instr st)))
-> View' instr arg st ret
-> ViewsSet' instr st
-> Either ViewsSetError (ViewsSet' instr st)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SomeView' instr st -> ViewName)
-> SomeView' instr st
-> ViewsSetF (SomeView' instr st)
-> Either ViewsSetError (ViewsSetF (SomeView' instr st))
forall a.
(a -> ViewName)
-> a -> ViewsSetF a -> Either ViewsSetError (ViewsSetF a)
VS.addViewToSet SomeView' instr st -> ViewName
forall (instr :: [T] -> [T] -> *) (st :: T).
SomeView' instr st -> ViewName
someViewName (SomeView' instr st
 -> ViewsSetF (SomeView' instr st)
 -> Either ViewsSetError (ViewsSetF (SomeView' instr st)))
-> (View' instr arg st ret -> SomeView' instr st)
-> View' instr arg st ret
-> ViewsSetF (SomeView' instr st)
-> Either ViewsSetError (ViewsSetF (SomeView' instr st))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. View' instr arg st ret -> SomeView' instr st
forall (instr :: [T] -> [T] -> *) (arg :: T) (st :: T) (ret :: T).
View' instr arg st ret -> SomeView' instr st
SomeView

-- | Find a view in the set.
lookupView :: forall instr st. ViewName -> ViewsSet' instr st -> Maybe (SomeView' instr st)
lookupView :: forall (instr :: [T] -> [T] -> *) (st :: T).
ViewName -> ViewsSet' instr st -> Maybe (SomeView' instr st)
lookupView = (ViewsSetF (SomeView' instr st) -> Maybe (SomeView' instr st))
-> ViewsSet' instr st -> Maybe (SomeView' instr st)
forall a b. Coercible a b => a -> b
coerce ((ViewsSetF (SomeView' instr st) -> Maybe (SomeView' instr st))
 -> ViewsSet' instr st -> Maybe (SomeView' instr st))
-> (ViewName
    -> ViewsSetF (SomeView' instr st) -> Maybe (SomeView' instr st))
-> ViewName
-> ViewsSet' instr st
-> Maybe (SomeView' instr st)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. ViewName -> ViewsSetF a -> Maybe a
VS.lookupView @(SomeView' instr st)

-- | Get all taken names in views set.
viewsSetNames :: forall instr st. ViewsSet' instr st -> Set ViewName
viewsSetNames :: forall (instr :: [T] -> [T] -> *) (st :: T).
ViewsSet' instr st -> Set ViewName
viewsSetNames = forall a. ViewsSetF a -> Set ViewName
VS.viewsSetNames @(SomeView' instr st) (ViewsSetF (SomeView' instr st) -> Set ViewName)
-> (ViewsSet' instr st -> ViewsSetF (SomeView' instr st))
-> ViewsSet' instr st
-> Set ViewName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ViewsSet' instr st -> ViewsSetF (SomeView' instr st)
forall a b. Coercible a b => a -> b
coerce

data SomeViewsSet' instr where
  SomeViewsSet :: SingI st => ViewsSet' instr st -> SomeViewsSet' instr

deriving stock instance
  (forall i o. Show (instr i o)) =>
  Show (SomeViewsSet' instr)
instance
  (forall i o. Eq (instr i o)) =>
  Eq (SomeViewsSet' instr) where
    SomeViewsSet ViewsSet' instr st
vs1 == :: SomeViewsSet' instr -> SomeViewsSet' instr -> Bool
== SomeViewsSet ViewsSet' instr st
vs2 = ViewsSet' instr st -> ViewsSet' instr st -> Bool
forall {k} (a1 :: k) (a2 :: k) (t :: k -> *).
(SingI a1, SingI a2, SDecide k, Eq (t a1)) =>
t a1 -> t a2 -> Bool
eqParamSing ViewsSet' instr st
vs1 ViewsSet' instr st
vs2
instance
  (forall i o. NFData (instr i o)) =>
  NFData (SomeViewsSet' instr) where
    rnf :: SomeViewsSet' instr -> ()
rnf (SomeViewsSet ViewsSet' instr st
vs) = ViewsSet' instr st -> ()
forall a. NFData a => a -> ()
rnf ViewsSet' instr st
vs