{-# OPTIONS_GHC -fno-warn-orphans #-}

module Agda.TypeChecking.Serialise.Instances.Abstract where

import qualified Data.Map as Map
import qualified Data.Set as Set

import Agda.Syntax.Common
import qualified Agda.Syntax.Abstract as A
import Agda.Syntax.Info
import Agda.Syntax.Scope.Base
import Agda.Syntax.Fixity

import Agda.TypeChecking.Serialise.Base
import Agda.TypeChecking.Serialise.Instances.Common () --instance only

import Agda.Utils.Functor
import Agda.Utils.Lens
import Agda.Utils.Impossible

-- Don't serialize the tactic.
instance EmbPrj A.BindName where
  icod_ :: BindName -> S Int32
icod_ (A.BindName a :: Name
a) = (Name -> BindName) -> Name -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' Name -> BindName
A.BindName Name
a
  value :: Int32 -> R BindName
value = (Name -> BindName) -> Int32 -> R (CoDomain (Name -> BindName))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Int32 -> R (CoDomain t)
valueN Name -> BindName
A.BindName

instance EmbPrj Scope where
  icod_ :: Scope -> S Int32
icod_ (Scope a :: ModuleName
a b :: [ModuleName]
b c :: ScopeNameSpaces
c d :: Map QName ModuleName
d e :: Maybe DataOrRecord
e) = (ModuleName
 -> [ModuleName]
 -> ScopeNameSpaces
 -> Map QName ModuleName
 -> Maybe DataOrRecord
 -> Scope)
-> ModuleName
-> [ModuleName]
-> ScopeNameSpaces
-> Map QName ModuleName
-> Maybe DataOrRecord
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' ModuleName
-> [ModuleName]
-> ScopeNameSpaces
-> Map QName ModuleName
-> Maybe DataOrRecord
-> Scope
Scope ModuleName
a [ModuleName]
b ScopeNameSpaces
c Map QName ModuleName
d Maybe DataOrRecord
e

  value :: Int32 -> R Scope
value = (ModuleName
 -> [ModuleName]
 -> ScopeNameSpaces
 -> Map QName ModuleName
 -> Maybe DataOrRecord
 -> Scope)
-> Int32
-> R (CoDomain
        (ModuleName
         -> [ModuleName]
         -> ScopeNameSpaces
         -> Map QName ModuleName
         -> Maybe DataOrRecord
         -> Scope))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Int32 -> R (CoDomain t)
valueN ModuleName
-> [ModuleName]
-> ScopeNameSpaces
-> Map QName ModuleName
-> Maybe DataOrRecord
-> Scope
Scope

instance EmbPrj NameSpaceId where
  icod_ :: NameSpaceId -> S Int32
icod_ PublicNS        = NameSpaceId -> Arrows (Domains NameSpaceId) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' NameSpaceId
PublicNS
  icod_ PrivateNS       = Int32 -> NameSpaceId -> Arrows (Domains NameSpaceId) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 1 NameSpaceId
PrivateNS
  icod_ ImportedNS      = Int32 -> NameSpaceId -> Arrows (Domains NameSpaceId) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 2 NameSpaceId
ImportedNS

  value :: Int32 -> R NameSpaceId
value = (Node -> R NameSpaceId) -> Int32 -> R NameSpaceId
forall a. EmbPrj a => (Node -> R a) -> Int32 -> R a
vcase Node -> R NameSpaceId
forall a. (Eq a, Num a) => [a] -> R NameSpaceId
valu where
    valu :: [a] -> R NameSpaceId
valu []  = NameSpaceId
-> Arrows
     (Constant Int32 (Domains NameSpaceId)) (R (CoDomain NameSpaceId))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN NameSpaceId
PublicNS
    valu [1] = NameSpaceId
-> Arrows
     (Constant Int32 (Domains NameSpaceId)) (R (CoDomain NameSpaceId))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN NameSpaceId
PrivateNS
    valu [2] = NameSpaceId
-> Arrows
     (Constant Int32 (Domains NameSpaceId)) (R (CoDomain NameSpaceId))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN NameSpaceId
ImportedNS
    valu _   = R NameSpaceId
forall a. R a
malformed

instance EmbPrj Access where
  icod_ :: Access -> S Int32
icod_ (PrivateAccess UserWritten) = Int32 -> () -> Arrows (Domains ()) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 0 ()
  icod_ PrivateAccess{}             = Int32 -> () -> Arrows (Domains ()) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 1 ()
  icod_ PublicAccess                = Access -> Arrows (Domains Access) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' Access
PublicAccess

  value :: Int32 -> R Access
value = (Node -> R Access) -> Int32 -> R Access
forall a. EmbPrj a => (Node -> R a) -> Int32 -> R a
vcase Node -> R Access
forall a. (Eq a, Num a) => [a] -> R Access
valu where
    valu :: [a] -> R Access
valu [0] = Access -> R Access
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (Access -> R Access) -> Access -> R Access
forall a b. (a -> b) -> a -> b
$ Origin -> Access
PrivateAccess Origin
UserWritten
    valu [1] = Access -> R Access
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (Access -> R Access) -> Access -> R Access
forall a b. (a -> b) -> a -> b
$ Origin -> Access
PrivateAccess Origin
Inserted
    valu []  = Access
-> Arrows (Constant Int32 (Domains Access)) (R (CoDomain Access))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Access
PublicAccess
    valu _   = R Access
forall a. R a
malformed

instance EmbPrj NameSpace where
  icod_ :: NameSpace -> S Int32
icod_ (NameSpace a :: NamesInScope
a b :: ModulesInScope
b c :: InScopeSet
c) = (NamesInScope -> ModulesInScope -> InScopeSet -> NameSpace)
-> NamesInScope -> ModulesInScope -> InScopeSet -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' NamesInScope -> ModulesInScope -> InScopeSet -> NameSpace
NameSpace NamesInScope
a ModulesInScope
b InScopeSet
c

  value :: Int32 -> R NameSpace
value = (NamesInScope -> ModulesInScope -> InScopeSet -> NameSpace)
-> Int32
-> R (CoDomain
        (NamesInScope -> ModulesInScope -> InScopeSet -> NameSpace))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Int32 -> R (CoDomain t)
valueN NamesInScope -> ModulesInScope -> InScopeSet -> NameSpace
NameSpace

instance EmbPrj WhyInScope where
  icod_ :: WhyInScope -> S Int32
icod_ Defined       = WhyInScope -> Arrows (Domains WhyInScope) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' WhyInScope
Defined
  icod_ (Opened a :: QName
a b :: WhyInScope
b)  = Int32
-> (QName -> WhyInScope -> WhyInScope)
-> QName
-> WhyInScope
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 0 QName -> WhyInScope -> WhyInScope
Opened QName
a WhyInScope
b
  icod_ (Applied a :: QName
a b :: WhyInScope
b) = Int32
-> (QName -> WhyInScope -> WhyInScope)
-> QName
-> WhyInScope
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 1 QName -> WhyInScope -> WhyInScope
Applied QName
a WhyInScope
b

  value :: Int32 -> R WhyInScope
value = (Node -> R WhyInScope) -> Int32 -> R WhyInScope
forall a. EmbPrj a => (Node -> R a) -> Int32 -> R a
vcase Node -> R WhyInScope
valu where
    valu :: Node -> R WhyInScope
valu []        = WhyInScope
-> Arrows
     (Constant Int32 (Domains WhyInScope)) (R (CoDomain WhyInScope))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN WhyInScope
Defined
    valu [0, a :: Int32
a, b :: Int32
b] = (QName -> WhyInScope -> WhyInScope)
-> Int32 -> Int32 -> R WhyInScope
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN QName -> WhyInScope -> WhyInScope
Opened Int32
a Int32
b
    valu [1, a :: Int32
a, b :: Int32
b] = (QName -> WhyInScope -> WhyInScope)
-> Int32 -> Int32 -> R WhyInScope
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN QName -> WhyInScope -> WhyInScope
Applied Int32
a Int32
b
    valu _         = R WhyInScope
forall a. R a
malformed

-- Issue #1346: QNames are shared on their nameIds, so serializing will lose fixity information for
-- rebound fixities. We don't care about that in terms, but in the scope it's important to keep the
-- right fixity. Thus serialize the fixity separately.

data AbsNameWithFixity = AbsNameWithFixity Fixity A.QName KindOfName WhyInScope NameMetadata

toAbsName :: AbsNameWithFixity -> AbstractName
toAbsName :: AbsNameWithFixity -> AbstractName
toAbsName (AbsNameWithFixity fx :: Fixity
fx a :: QName
a b :: KindOfName
b c :: WhyInScope
c d :: NameMetadata
d) = QName -> KindOfName -> WhyInScope -> NameMetadata -> AbstractName
AbsName (Lens' Fixity QName -> LensSet Fixity QName
forall i o. Lens' i o -> LensSet i o
set forall a. LensFixity a => Lens' Fixity a
Lens' Fixity QName
lensFixity Fixity
fx QName
a) KindOfName
b WhyInScope
c NameMetadata
d

fromAbsName :: AbstractName -> AbsNameWithFixity
fromAbsName :: AbstractName -> AbsNameWithFixity
fromAbsName (AbsName a :: QName
a b :: KindOfName
b c :: WhyInScope
c d :: NameMetadata
d) = Fixity
-> QName
-> KindOfName
-> WhyInScope
-> NameMetadata
-> AbsNameWithFixity
AbsNameWithFixity (QName
a QName -> Lens' Fixity QName -> Fixity
forall o i. o -> Lens' i o -> i
^. forall a. LensFixity a => Lens' Fixity a
Lens' Fixity QName
lensFixity) QName
a KindOfName
b WhyInScope
c NameMetadata
d

instance EmbPrj AbsNameWithFixity where
  icod_ :: AbsNameWithFixity -> S Int32
icod_ (AbsNameWithFixity a :: Fixity
a b :: QName
b c :: KindOfName
c d :: WhyInScope
d e :: NameMetadata
e) = (Fixity
 -> QName
 -> KindOfName
 -> WhyInScope
 -> NameMetadata
 -> AbsNameWithFixity)
-> Fixity
-> QName
-> KindOfName
-> WhyInScope
-> NameMetadata
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' Fixity
-> QName
-> KindOfName
-> WhyInScope
-> NameMetadata
-> AbsNameWithFixity
AbsNameWithFixity Fixity
a QName
b KindOfName
c WhyInScope
d NameMetadata
e
  value :: Int32 -> R AbsNameWithFixity
value = (Fixity
 -> QName
 -> KindOfName
 -> WhyInScope
 -> NameMetadata
 -> AbsNameWithFixity)
-> Int32
-> R (CoDomain
        (Fixity
         -> QName
         -> KindOfName
         -> WhyInScope
         -> NameMetadata
         -> AbsNameWithFixity))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Int32 -> R (CoDomain t)
valueN Fixity
-> QName
-> KindOfName
-> WhyInScope
-> NameMetadata
-> AbsNameWithFixity
AbsNameWithFixity

instance EmbPrj AbstractName where
  icod_ :: AbstractName -> S Int32
icod_ a :: AbstractName
a = AbsNameWithFixity -> S Int32
forall a. EmbPrj a => a -> S Int32
icod_ (AbstractName -> AbsNameWithFixity
fromAbsName AbstractName
a)
  value :: Int32 -> R AbstractName
value = AbsNameWithFixity -> AbstractName
toAbsName (AbsNameWithFixity -> AbstractName)
-> (Int32 -> R AbsNameWithFixity) -> Int32 -> R AbstractName
forall (m :: * -> *) b c a.
Functor m =>
(b -> c) -> (a -> m b) -> a -> m c
<.> Int32 -> R AbsNameWithFixity
forall a. EmbPrj a => Int32 -> R a
value

instance EmbPrj NameMetadata where
  icod_ :: NameMetadata -> S Int32
icod_ NoMetadata                  = NameMetadata -> Arrows (Domains NameMetadata) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' NameMetadata
NoMetadata
  icod_ (GeneralizedVarsMetadata a :: Map QName Name
a) = (Map QName Name -> NameMetadata) -> Map QName Name -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' Map QName Name -> NameMetadata
GeneralizedVarsMetadata Map QName Name
a

  value :: Int32 -> R NameMetadata
value = (Node -> R NameMetadata) -> Int32 -> R NameMetadata
forall a. EmbPrj a => (Node -> R a) -> Int32 -> R a
vcase Node -> R NameMetadata
valu where
    valu :: Node -> R NameMetadata
valu []  = NameMetadata
-> Arrows
     (Constant Int32 (Domains NameMetadata)) (R (CoDomain NameMetadata))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN NameMetadata
NoMetadata
    valu [a :: Int32
a] = (Map QName Name -> NameMetadata) -> Int32 -> R NameMetadata
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Map QName Name -> NameMetadata
GeneralizedVarsMetadata Int32
a
    valu _   = R NameMetadata
forall a. R a
malformed

instance EmbPrj AbstractModule where
  icod_ :: AbstractModule -> S Int32
icod_ (AbsModule a :: ModuleName
a b :: WhyInScope
b) = (ModuleName -> WhyInScope -> AbstractModule)
-> ModuleName -> WhyInScope -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' ModuleName -> WhyInScope -> AbstractModule
AbsModule ModuleName
a WhyInScope
b

  value :: Int32 -> R AbstractModule
value = (ModuleName -> WhyInScope -> AbstractModule)
-> Int32
-> R (CoDomain (ModuleName -> WhyInScope -> AbstractModule))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Int32 -> R (CoDomain t)
valueN ModuleName -> WhyInScope -> AbstractModule
AbsModule

instance EmbPrj KindOfName where
  -- -- Enums have a generic EmbPrj
  --
  -- icod_ DefName        = icodeN' DefName
  -- icod_ ConName        = icodeN 1 ConName
  -- icod_ FldName        = icodeN 2 FldName
  -- icod_ PatternSynName = icodeN 3 PatternSynName
  -- icod_ QuotableName   = icodeN 4 QuotableName
  -- icod_ MacroName      = icodeN 5 MacroName
  -- icod_ GeneralizeName = icodeN 6 GeneralizeName
  -- icod_ DisallowedGeneralizeName = icodeN 7 DisallowedGeneralizeName

  -- value = vcase valu where
  --   valu []  = valuN DefName
  --   valu [1] = valuN ConName
  --   valu [2] = valuN FldName
  --   valu [3] = valuN PatternSynName
  --   valu [4] = valuN QuotableName
  --   valu [5] = valuN MacroName
  --   valu [6] = valuN GeneralizeName
  --   valu [7] = valuN DisallowedGeneralizeName
  --   valu _   = malformed

instance EmbPrj BindingSource where
  icod_ :: BindingSource -> S Int32
icod_ LambdaBound   = BindingSource -> Arrows (Domains BindingSource) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' BindingSource
LambdaBound
  icod_ PatternBound  = Int32 -> BindingSource -> Arrows (Domains BindingSource) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 1 BindingSource
PatternBound
  icod_ LetBound      = Int32 -> BindingSource -> Arrows (Domains BindingSource) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 2 BindingSource
LetBound

  value :: Int32 -> R BindingSource
value = (Node -> R BindingSource) -> Int32 -> R BindingSource
forall a. EmbPrj a => (Node -> R a) -> Int32 -> R a
vcase Node -> R BindingSource
forall a. (Eq a, Num a) => [a] -> R BindingSource
valu where
    valu :: [a] -> R BindingSource
valu []  = BindingSource
-> Arrows
     (Constant Int32 (Domains BindingSource))
     (R (CoDomain BindingSource))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN BindingSource
LambdaBound
    valu [1] = BindingSource
-> Arrows
     (Constant Int32 (Domains BindingSource))
     (R (CoDomain BindingSource))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN BindingSource
PatternBound
    valu [2] = BindingSource
-> Arrows
     (Constant Int32 (Domains BindingSource))
     (R (CoDomain BindingSource))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN BindingSource
LetBound
    valu _   = R BindingSource
forall a. R a
malformed

instance EmbPrj LocalVar where
  icod_ :: LocalVar -> S Int32
icod_ (LocalVar a :: Name
a b :: BindingSource
b c :: [AbstractName]
c)  = (Name -> BindingSource -> [AbstractName] -> LocalVar)
-> Name -> BindingSource -> [AbstractName] -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' Name -> BindingSource -> [AbstractName] -> LocalVar
LocalVar Name
a BindingSource
b [AbstractName]
c

  value :: Int32 -> R LocalVar
value = (Name -> BindingSource -> [AbstractName] -> LocalVar)
-> Int32
-> R (CoDomain
        (Name -> BindingSource -> [AbstractName] -> LocalVar))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Int32 -> R (CoDomain t)
valueN Name -> BindingSource -> [AbstractName] -> LocalVar
LocalVar

instance EmbPrj ConPatInfo where
  icod_ :: ConPatInfo -> S Int32
icod_ (ConPatInfo a :: ConOrigin
a _ b :: ConPatLazy
b) = (ConOrigin -> ConPatLazy -> ConPatInfo)
-> ConOrigin -> ConPatLazy -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' (\a :: ConOrigin
a b :: ConPatLazy
b -> ConOrigin -> PatInfo -> ConPatLazy -> ConPatInfo
ConPatInfo ConOrigin
a PatInfo
patNoRange ConPatLazy
b) ConOrigin
a ConPatLazy
b

  value :: Int32 -> R ConPatInfo
value = (ConOrigin -> ConPatLazy -> ConPatInfo) -> Int32 -> R ConPatInfo
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Int32 -> R (CoDomain t)
valueN ((ConOrigin -> ConPatLazy -> ConPatInfo) -> Int32 -> R ConPatInfo)
-> (ConOrigin -> ConPatLazy -> ConPatInfo) -> Int32 -> R ConPatInfo
forall a b. (a -> b) -> a -> b
$ \a :: ConOrigin
a b :: ConPatLazy
b -> ConOrigin -> PatInfo -> ConPatLazy -> ConPatInfo
ConPatInfo ConOrigin
a PatInfo
patNoRange ConPatLazy
b

instance EmbPrj ConPatLazy

-- Only for pattern synonyms (where a is Void)
instance EmbPrj a => EmbPrj (A.Pattern' a) where
  icod_ :: Pattern' a -> S Int32
icod_ (A.VarP a :: BindName
a)            = Int32 -> (BindName -> Pattern' Any) -> BindName -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 0 BindName -> Pattern' Any
forall e. BindName -> Pattern' e
A.VarP BindName
a
  icod_ (A.ConP a :: ConPatInfo
a b :: AmbiguousQName
b c :: NAPs a
c)        = Int32
-> (ConPatInfo -> AmbiguousQName -> NAPs a -> Pattern' a)
-> ConPatInfo
-> AmbiguousQName
-> NAPs a
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 1 ConPatInfo -> AmbiguousQName -> NAPs a -> Pattern' a
forall e. ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.ConP ConPatInfo
a AmbiguousQName
b NAPs a
c
  icod_ (A.DefP p :: PatInfo
p a :: AmbiguousQName
a b :: NAPs a
b)        = Int32
-> (AmbiguousQName -> NAPs a -> Pattern' a)
-> AmbiguousQName
-> NAPs a
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 2 (PatInfo -> AmbiguousQName -> NAPs a -> Pattern' a
forall e. PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.DefP PatInfo
p) AmbiguousQName
a NAPs a
b
  icod_ t :: Pattern' a
t@(A.WildP p :: PatInfo
p)         = Int32 -> Pattern' a -> Arrows (Domains (Pattern' a)) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 3 Pattern' a
t
  icod_ (A.AsP p :: PatInfo
p a :: BindName
a b :: Pattern' a
b)         = Int32
-> (BindName -> Pattern' a -> Pattern' a)
-> BindName
-> Pattern' a
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 4 (PatInfo -> BindName -> Pattern' a -> Pattern' a
forall e. PatInfo -> BindName -> Pattern' e -> Pattern' e
A.AsP PatInfo
p) BindName
a Pattern' a
b
  icod_ (A.DotP p :: PatInfo
p a :: a
a)          = Int32 -> (a -> Pattern' a) -> a -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 5 (PatInfo -> a -> Pattern' a
forall e. PatInfo -> e -> Pattern' e
A.DotP PatInfo
p) a
a
  icod_ t :: Pattern' a
t@(A.AbsurdP _)       = Int32 -> Pattern' a -> Arrows (Domains (Pattern' a)) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 6 Pattern' a
t
  icod_ (A.LitP a :: Literal
a)            = Int32 -> (Literal -> Pattern' Any) -> Literal -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 7 Literal -> Pattern' Any
forall e. Literal -> Pattern' e
A.LitP Literal
a
  icod_ (A.ProjP p :: PatInfo
p a :: ProjOrigin
a b :: AmbiguousQName
b)       = Int32
-> (ProjOrigin -> AmbiguousQName -> Pattern' Any)
-> ProjOrigin
-> AmbiguousQName
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 8 (PatInfo -> ProjOrigin -> AmbiguousQName -> Pattern' Any
forall e. PatInfo -> ProjOrigin -> AmbiguousQName -> Pattern' e
A.ProjP PatInfo
p) ProjOrigin
a AmbiguousQName
b
  icod_ (A.PatternSynP p :: PatInfo
p a :: AmbiguousQName
a b :: NAPs a
b) = Int32
-> (AmbiguousQName -> NAPs a -> Pattern' a)
-> AmbiguousQName
-> NAPs a
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 9 (PatInfo -> AmbiguousQName -> NAPs a -> Pattern' a
forall e. PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.PatternSynP PatInfo
p) AmbiguousQName
a NAPs a
b
  icod_ (A.RecP p :: PatInfo
p a :: [FieldAssignment' (Pattern' a)]
a)          = Int32
-> ([FieldAssignment' (Pattern' a)] -> Pattern' a)
-> [FieldAssignment' (Pattern' a)]
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 10 (PatInfo -> [FieldAssignment' (Pattern' a)] -> Pattern' a
forall e. PatInfo -> [FieldAssignment' (Pattern' e)] -> Pattern' e
A.RecP PatInfo
p) [FieldAssignment' (Pattern' a)]
a
  icod_ (A.EqualP _ a :: [(a, a)]
a)        = S Int32
forall a. HasCallStack => a
__IMPOSSIBLE__
  icod_ (A.WithP i :: PatInfo
i a :: Pattern' a
a)         = Int32 -> (Pattern' a -> Pattern' a) -> Pattern' a -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 11 (PatInfo -> Pattern' a -> Pattern' a
forall e. PatInfo -> Pattern' e -> Pattern' e
A.WithP PatInfo
i) Pattern' a
a

  value :: Int32 -> R (Pattern' a)
value = (Node -> R (Pattern' a)) -> Int32 -> R (Pattern' a)
forall a. EmbPrj a => (Node -> R a) -> Int32 -> R a
vcase Node -> R (Pattern' a)
forall e. EmbPrj e => Node -> R (Pattern' e)
valu where
    valu :: Node -> R (Pattern' e)
valu [0, a :: Int32
a]       = (BindName -> Pattern' e) -> Int32 -> R (Pattern' e)
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN BindName -> Pattern' e
forall e. BindName -> Pattern' e
A.VarP Int32
a
    valu [1, a :: Int32
a, b :: Int32
b, c :: Int32
c] = (ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e)
-> Int32 -> Int32 -> Int32 -> R (Pattern' e)
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
forall e. ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.ConP Int32
a Int32
b Int32
c
    valu [2, a :: Int32
a, b :: Int32
b]    = (AmbiguousQName -> NAPs e -> Pattern' e)
-> Int32 -> Int32 -> R (Pattern' e)
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
forall e. PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.DefP PatInfo
i) Int32
a Int32
b
    valu [3]          = Pattern' e
-> Arrows
     (Constant Int32 (Domains (Pattern' e))) (R (CoDomain (Pattern' e)))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> Pattern' e
forall e. PatInfo -> Pattern' e
A.WildP PatInfo
i)
    valu [4, a :: Int32
a, b :: Int32
b]    = (BindName -> Pattern' e -> Pattern' e)
-> Int32 -> Int32 -> R (Pattern' e)
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> BindName -> Pattern' e -> Pattern' e
forall e. PatInfo -> BindName -> Pattern' e -> Pattern' e
A.AsP PatInfo
i) Int32
a Int32
b
    valu [5, a :: Int32
a]       = (e -> Pattern' e) -> Int32 -> R (Pattern' e)
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> e -> Pattern' e
forall e. PatInfo -> e -> Pattern' e
A.DotP PatInfo
i) Int32
a
    valu [6]          = Pattern' e
-> Arrows
     (Constant Int32 (Domains (Pattern' e))) (R (CoDomain (Pattern' e)))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> Pattern' e
forall e. PatInfo -> Pattern' e
A.AbsurdP PatInfo
i)
    valu [7, a :: Int32
a]       = (Literal -> Pattern' e) -> Int32 -> R (Pattern' e)
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (Literal -> Pattern' e
forall e. Literal -> Pattern' e
A.LitP) Int32
a
    valu [8, a :: Int32
a, b :: Int32
b]    = (ProjOrigin -> AmbiguousQName -> Pattern' e)
-> Int32 -> Int32 -> R (Pattern' e)
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> ProjOrigin -> AmbiguousQName -> Pattern' e
forall e. PatInfo -> ProjOrigin -> AmbiguousQName -> Pattern' e
A.ProjP PatInfo
i) Int32
a Int32
b
    valu [9, a :: Int32
a, b :: Int32
b]    = (AmbiguousQName -> NAPs e -> Pattern' e)
-> Int32 -> Int32 -> R (Pattern' e)
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
forall e. PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.PatternSynP PatInfo
i) Int32
a Int32
b
    valu [10, a :: Int32
a]      = ([FieldAssignment' (Pattern' e)] -> Pattern' e)
-> Int32 -> R (Pattern' e)
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> [FieldAssignment' (Pattern' e)] -> Pattern' e
forall e. PatInfo -> [FieldAssignment' (Pattern' e)] -> Pattern' e
A.RecP PatInfo
i) Int32
a
    valu [11, a :: Int32
a]      = (Pattern' e -> Pattern' e) -> Int32 -> R (Pattern' e)
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> Pattern' e -> Pattern' e
forall e. PatInfo -> Pattern' e -> Pattern' e
A.WithP PatInfo
i) Int32
a
    valu _            = R (Pattern' e)
forall a. R a
malformed

    i :: PatInfo
i = PatInfo
patNoRange

instance EmbPrj ParenPreference where
  icod_ :: ParenPreference -> S Int32
icod_ PreferParen     = ParenPreference -> Arrows (Domains ParenPreference) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' ParenPreference
PreferParen
  icod_ PreferParenless = Int32
-> ParenPreference -> Arrows (Domains ParenPreference) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 1 ParenPreference
PreferParenless
  value :: Int32 -> R ParenPreference
value = (Node -> R ParenPreference) -> Int32 -> R ParenPreference
forall a. EmbPrj a => (Node -> R a) -> Int32 -> R a
vcase Node -> R ParenPreference
forall a. (Eq a, Num a) => [a] -> R ParenPreference
valu where
    valu :: [a] -> R ParenPreference
valu []  = ParenPreference
-> Arrows
     (Constant Int32 (Domains ParenPreference))
     (R (CoDomain ParenPreference))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN ParenPreference
PreferParen
    valu [1] = ParenPreference
-> Arrows
     (Constant Int32 (Domains ParenPreference))
     (R (CoDomain ParenPreference))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN ParenPreference
PreferParenless
    valu _   = R ParenPreference
forall a. R a
malformed

instance EmbPrj Precedence where
  icod_ :: Precedence -> S Int32
icod_ TopCtx                 = Precedence -> Arrows (Domains Precedence) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' Precedence
TopCtx
  icod_ FunctionSpaceDomainCtx = Int32 -> Precedence -> Arrows (Domains Precedence) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 1 Precedence
FunctionSpaceDomainCtx
  icod_ (LeftOperandCtx a :: Fixity
a)     = Int32 -> (Fixity -> Precedence) -> Fixity -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 2 Fixity -> Precedence
LeftOperandCtx Fixity
a
  icod_ (RightOperandCtx a :: Fixity
a b :: ParenPreference
b)  = Int32
-> (Fixity -> ParenPreference -> Precedence)
-> Fixity
-> ParenPreference
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 3 Fixity -> ParenPreference -> Precedence
RightOperandCtx Fixity
a ParenPreference
b
  icod_ FunctionCtx            = Int32 -> Precedence -> Arrows (Domains Precedence) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 4 Precedence
FunctionCtx
  icod_ (ArgumentCtx a :: ParenPreference
a)        = Int32
-> (ParenPreference -> Precedence) -> ParenPreference -> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 5 ParenPreference -> Precedence
ArgumentCtx ParenPreference
a
  icod_ InsideOperandCtx       = Int32 -> Precedence -> Arrows (Domains Precedence) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 6 Precedence
InsideOperandCtx
  icod_ WithFunCtx             = Int32 -> Precedence -> Arrows (Domains Precedence) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 7 Precedence
WithFunCtx
  icod_ WithArgCtx             = Int32 -> Precedence -> Arrows (Domains Precedence) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 8 Precedence
WithArgCtx
  icod_ DotPatternCtx          = Int32 -> Precedence -> Arrows (Domains Precedence) (S Int32)
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
Int32 -> t -> Arrows (Domains t) (S Int32)
icodeN 9 Precedence
DotPatternCtx

  value :: Int32 -> R Precedence
value = (Node -> R Precedence) -> Int32 -> R Precedence
forall a. EmbPrj a => (Node -> R a) -> Int32 -> R a
vcase Node -> R Precedence
valu where
    valu :: Node -> R Precedence
valu []        = Precedence
-> Arrows
     (Constant Int32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Precedence
TopCtx
    valu [1]       = Precedence
-> Arrows
     (Constant Int32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Precedence
FunctionSpaceDomainCtx
    valu [2, a :: Int32
a]    = (Fixity -> Precedence) -> Int32 -> R Precedence
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Fixity -> Precedence
LeftOperandCtx Int32
a
    valu [3, a :: Int32
a, b :: Int32
b] = (Fixity -> ParenPreference -> Precedence)
-> Int32 -> Int32 -> R Precedence
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Fixity -> ParenPreference -> Precedence
RightOperandCtx Int32
a Int32
b
    valu [4]       = Precedence
-> Arrows
     (Constant Int32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Precedence
FunctionCtx
    valu [5, a :: Int32
a]    = (ParenPreference -> Precedence) -> Int32 -> R Precedence
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN ParenPreference -> Precedence
ArgumentCtx Int32
a
    valu [6]       = Precedence
-> Arrows
     (Constant Int32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Precedence
InsideOperandCtx
    valu [7]       = Precedence
-> Arrows
     (Constant Int32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Precedence
WithFunCtx
    valu [8]       = Precedence
-> Arrows
     (Constant Int32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Precedence
WithArgCtx
    valu [9]       = Precedence
-> Arrows
     (Constant Int32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (IsBase t),
 Currying (Constant Int32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Int32 (Domains t)) (R (CoDomain t))
valuN Precedence
DotPatternCtx
    valu _         = R Precedence
forall a. R a
malformed

instance EmbPrj ScopeInfo where
  icod_ :: ScopeInfo -> S Int32
icod_ (ScopeInfo a :: ModuleName
a b :: Map ModuleName Scope
b c :: LocalVars
c d :: LocalVars
d e :: PrecedenceStack
e f :: NameMap
f g :: ModuleMap
g h :: InScopeSet
h i :: Fixities
i j :: Polarities
j) = (ModuleName
 -> Map ModuleName Scope
 -> LocalVars
 -> LocalVars
 -> PrecedenceStack
 -> ScopeInfo)
-> ModuleName
-> Map ModuleName Scope
-> LocalVars
-> LocalVars
-> PrecedenceStack
-> S Int32
forall t.
(ICODE t (IsBase t), Currying (Domains t) (S Int32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Int32)
icodeN' (\ a :: ModuleName
a b :: Map ModuleName Scope
b c :: LocalVars
c d :: LocalVars
d e :: PrecedenceStack
e -> ModuleName
-> Map ModuleName Scope
-> LocalVars
-> LocalVars
-> PrecedenceStack
-> NameMap
-> ModuleMap
-> InScopeSet
-> Fixities
-> Polarities
-> ScopeInfo
ScopeInfo ModuleName
a Map ModuleName Scope
b LocalVars
c LocalVars
d PrecedenceStack
e NameMap
f ModuleMap
g InScopeSet
h Fixities
i Polarities
j) ModuleName
a Map ModuleName Scope
b LocalVars
c LocalVars
d PrecedenceStack
e

  value :: Int32 -> R ScopeInfo
value = (ModuleName
 -> Map ModuleName Scope
 -> LocalVars
 -> LocalVars
 -> PrecedenceStack
 -> ScopeInfo)
-> Int32
-> R (CoDomain
        (ModuleName
         -> Map ModuleName Scope
         -> LocalVars
         -> LocalVars
         -> PrecedenceStack
         -> ScopeInfo))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Int32 -> R (CoDomain t)
valueN (\ a :: ModuleName
a b :: Map ModuleName Scope
b c :: LocalVars
c d :: LocalVars
d e :: PrecedenceStack
e -> ModuleName
-> Map ModuleName Scope
-> LocalVars
-> LocalVars
-> PrecedenceStack
-> NameMap
-> ModuleMap
-> InScopeSet
-> Fixities
-> Polarities
-> ScopeInfo
ScopeInfo ModuleName
a Map ModuleName Scope
b LocalVars
c LocalVars
d PrecedenceStack
e NameMap
forall k a. Map k a
Map.empty ModuleMap
forall k a. Map k a
Map.empty InScopeSet
forall a. Set a
Set.empty Fixities
forall k a. Map k a
Map.empty Polarities
forall k a. Map k a
Map.empty)

instance EmbPrj NameOrModule