{-# OPTIONS_GHC -Wunused-imports #-}
{-# OPTIONS_GHC -Wno-orphans #-}

module Agda.TypeChecking.Serialise.Instances.Abstract where

import Control.Monad
import Control.Monad.Reader

import Data.HashMap.Strict qualified as HMap
import Data.Map qualified as Map
import Data.Set qualified as Set
import Data.Void (Void)

import Agda.Syntax.Abstract qualified as A
import Agda.Syntax.Abstract.Pattern ( noDotOrEqPattern )
import Agda.Syntax.Common
import Agda.Syntax.Fixity
import Agda.Syntax.Info
import Agda.Syntax.Position
import Agda.Syntax.Scope.Base

import Agda.TypeChecking.Serialise.Base
import Agda.TypeChecking.Serialise.Instances.Common (SerialisedRange(..))

import Agda.Utils.Functor
import Agda.Utils.Lens
import Agda.Utils.Null

import Agda.Utils.Impossible

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

instance EmbPrj Scope where
  icod_ :: Scope -> S Word32
icod_ (Scope ModuleName
a [ModuleName]
b ScopeNameSpaces
c Map QName ModuleName
d Maybe DataOrRecordModule
e Maybe ScopeCopyRef
f) = (ModuleName
 -> [ModuleName]
 -> ScopeNameSpaces
 -> Map QName ModuleName
 -> Maybe DataOrRecordModule
 -> Scope)
-> Arrows
     (Domains
        (ModuleName
         -> [ModuleName]
         -> ScopeNameSpaces
         -> Map QName ModuleName
         -> Maybe DataOrRecordModule
         -> Scope))
     (S Word32)
forall t.
(ICODE t (Arity t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' (\ModuleName
a [ModuleName]
b ScopeNameSpaces
c Map QName ModuleName
d Maybe DataOrRecordModule
e -> ModuleName
-> [ModuleName]
-> ScopeNameSpaces
-> Map QName ModuleName
-> Maybe DataOrRecordModule
-> Maybe ScopeCopyRef
-> Scope
Scope ModuleName
a [ModuleName]
b ScopeNameSpaces
c Map QName ModuleName
d Maybe DataOrRecordModule
e Maybe ScopeCopyRef
f) ModuleName
a [ModuleName]
b ScopeNameSpaces
c Map QName ModuleName
d Maybe DataOrRecordModule
e

  value :: Word32 -> R Scope
value = (ModuleName
 -> [ModuleName]
 -> ScopeNameSpaces
 -> Map QName ModuleName
 -> Maybe DataOrRecordModule
 -> Scope)
-> Word32
-> R (CoDomain
        (ModuleName
         -> [ModuleName]
         -> ScopeNameSpaces
         -> Map QName ModuleName
         -> Maybe DataOrRecordModule
         -> Scope))
forall t.
(VALU t (Arity t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN \ModuleName
a [ModuleName]
b ScopeNameSpaces
c Map QName ModuleName
d Maybe DataOrRecordModule
e -> ModuleName
-> [ModuleName]
-> ScopeNameSpaces
-> Map QName ModuleName
-> Maybe DataOrRecordModule
-> Maybe ScopeCopyRef
-> Scope
Scope ModuleName
a [ModuleName]
b ScopeNameSpaces
c Map QName ModuleName
d Maybe DataOrRecordModule
e Maybe ScopeCopyRef
forall a. Maybe a
Nothing

instance EmbPrj DataOrRecordModule where
  icod_ :: DataOrRecordModule -> S Word32
icod_ DataOrRecordModule
IsDataModule   = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
0
  icod_ DataOrRecordModule
IsRecordModule = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
1

  value :: Word32 -> R DataOrRecordModule
value = \case
    Word32
0 -> DataOrRecordModule -> R DataOrRecordModule
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure DataOrRecordModule
IsDataModule
    Word32
1 -> DataOrRecordModule -> R DataOrRecordModule
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure DataOrRecordModule
IsRecordModule
    Word32
_ -> R DataOrRecordModule
forall a. HasCallStack => R a
malformed

instance EmbPrj NameSpaceId where
  icod_ :: NameSpaceId -> S Word32
icod_ NameSpaceId
PublicNS        = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
0
  icod_ NameSpaceId
PrivateNS       = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
1
  icod_ NameSpaceId
ImportedNS      = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
2

  value :: Word32 -> R NameSpaceId
value = \case
    Word32
0 -> NameSpaceId -> R NameSpaceId
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NameSpaceId
PublicNS
    Word32
1 -> NameSpaceId -> R NameSpaceId
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NameSpaceId
PrivateNS
    Word32
2 -> NameSpaceId -> R NameSpaceId
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NameSpaceId
ImportedNS
    Word32
_ -> R NameSpaceId
forall a. HasCallStack => R a
malformed

instance EmbPrj Access where
  icod_ :: Access -> S Word32
icod_ (PrivateAccess KwRange
_ Origin
UserWritten) = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
0
  icod_ PrivateAccess{}               = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
1
  icod_ Access
PublicAccess                  = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
2

  value :: Word32 -> R Access
value = \case
    Word32
0 -> Access -> R Access
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Access -> R Access) -> Access -> R Access
forall a b. (a -> b) -> a -> b
$ KwRange -> Origin -> Access
PrivateAccess KwRange
forall a. Null a => a
empty Origin
UserWritten
    Word32
1 -> Access -> R Access
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Access -> R Access) -> Access -> R Access
forall a b. (a -> b) -> a -> b
$ Access
privateAccessInserted
    Word32
2 -> Access -> R Access
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Access
PublicAccess
    Word32
_ -> R Access
forall a. HasCallStack => R a
malformed

instance EmbPrj NameSpace where
  icod_ :: NameSpace -> S Word32
icod_ (NameSpace NamesInScope
a NamePartsInScope
b ModulesInScope
c InScopeSet
d) = (NamesInScope
 -> NamePartsInScope -> ModulesInScope -> InScopeSet -> NameSpace)
-> Arrows
     (Domains
        (NamesInScope
         -> NamePartsInScope -> ModulesInScope -> InScopeSet -> NameSpace))
     (S Word32)
forall t.
(ICODE t (Arity t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' NamesInScope
-> NamePartsInScope -> ModulesInScope -> InScopeSet -> NameSpace
NameSpace NamesInScope
a NamePartsInScope
b ModulesInScope
c InScopeSet
d

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

-- Andreas, 2025-10-23:
-- We serialize the Ranges in WhyInScope
-- so that we have then e.g. in the ClashingDefinition error.

instance EmbPrj WhyInScope where
  icod_ :: WhyInScope -> S Word32
icod_ WhyInScope
Defined       = WhyInScope -> Arrows (Domains WhyInScope) (S Word32)
forall t.
(ICODE t (Arity t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' WhyInScope
Defined
  icod_ (Opened QName
a WhyInScope
b)  = Word32
-> (SerialisedRange -> QName -> WhyInScope -> WhyInScope)
-> Arrows
     (Domains (SerialisedRange -> QName -> WhyInScope -> WhyInScope))
     (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 (\(SerialisedRange
_ :: SerialisedRange) -> QName -> WhyInScope -> WhyInScope
Opened) (Range -> SerialisedRange
SerialisedRange (QName -> Range
forall a. HasRange a => a -> Range
getRange QName
a)) QName
a WhyInScope
b
  icod_ (Applied QName
a WhyInScope
b) = Word32
-> (SerialisedRange -> QName -> WhyInScope -> WhyInScope)
-> Arrows
     (Domains (SerialisedRange -> QName -> WhyInScope -> WhyInScope))
     (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 (\(SerialisedRange
_ :: SerialisedRange) -> QName -> WhyInScope -> WhyInScope
Applied) (Range -> SerialisedRange
SerialisedRange (QName -> Range
forall a. HasRange a => a -> Range
getRange QName
a)) QName
a WhyInScope
b

  value :: Word32 -> R WhyInScope
value = (Node -> R WhyInScope) -> Word32 -> R WhyInScope
forall a. EmbPrj a => (Node -> R a) -> Word32 -> R a
vcase \case
    Node
N0           -> WhyInScope
-> Arrows
     (Constant Word32 (Domains WhyInScope)) (R (CoDomain WhyInScope))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN WhyInScope
Defined
    (N4 Word32
0 Word32
r Word32
a Word32
b) -> (SerialisedRange -> QName -> WhyInScope -> WhyInScope)
-> Arrows
     (Constant
        Word32
        (Domains (SerialisedRange -> QName -> WhyInScope -> WhyInScope)))
     (R (CoDomain
           (SerialisedRange -> QName -> WhyInScope -> WhyInScope)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (\(SerialisedRange Range
r) QName
a WhyInScope
b -> QName -> WhyInScope -> WhyInScope
Opened (Range -> QName -> QName
forall a. SetRange a => Range -> a -> a
setRange Range
r QName
a) WhyInScope
b) Word32
r Word32
a Word32
b
    (N4 Word32
1 Word32
r Word32
a Word32
b) -> (SerialisedRange -> QName -> WhyInScope -> WhyInScope)
-> Arrows
     (Constant
        Word32
        (Domains (SerialisedRange -> QName -> WhyInScope -> WhyInScope)))
     (R (CoDomain
           (SerialisedRange -> QName -> WhyInScope -> WhyInScope)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (\(SerialisedRange Range
r) QName
a WhyInScope
b -> QName -> WhyInScope -> WhyInScope
Applied (Range -> QName -> QName
forall a. SetRange a => Range -> a -> a
setRange Range
r QName
a) WhyInScope
b) Word32
r Word32
a Word32
b
    Node
_            -> R WhyInScope
forall a. HasCallStack => 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 Fixity
fx QName
a KindOfName
b WhyInScope
c NameMetadata
d) = QName -> KindOfName -> WhyInScope -> NameMetadata -> AbstractName
AbsName (Lens' QName Fixity -> LensSet QName Fixity
forall o i. Lens' o i -> LensSet o i
set (Fixity -> f Fixity) -> QName -> f QName
forall a. LensFixity a => Lens' a Fixity
Lens' QName Fixity
lensFixity Fixity
fx QName
a) KindOfName
b WhyInScope
c NameMetadata
d

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

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

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

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

  value :: Word32 -> R NameMetadata
value = (Node -> R NameMetadata) -> Word32 -> R NameMetadata
forall a. EmbPrj a => (Node -> R a) -> Word32 -> R a
vcase Node -> R NameMetadata
valu where
    valu :: Node
-> Arrows
     (Constant Word32 (Domains NameMetadata))
     (R (CoDomain NameMetadata))
valu Node
N0     = NameMetadata
-> Arrows
     (Constant Word32 (Domains NameMetadata))
     (R (CoDomain NameMetadata))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN NameMetadata
NoMetadata
    valu (N1 Word32
a) = (Map QName Name -> NameMetadata)
-> Arrows
     (Constant Word32 (Domains (Map QName Name -> NameMetadata)))
     (R (CoDomain (Map QName Name -> NameMetadata)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Map QName Name -> NameMetadata
GeneralizedVarsMetadata Word32
a
    valu Node
_      = R NameMetadata
Arrows
  (Constant Word32 (Domains NameMetadata))
  (R (CoDomain NameMetadata))
forall a. HasCallStack => R a
malformed

instance EmbPrj A.Suffix where
  icod_ :: Suffix -> S Word32
icod_ Suffix
A.NoSuffix   = Suffix -> Arrows (Domains Suffix) (S Word32)
forall t.
(ICODE t (Arity t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Suffix
A.NoSuffix
  icod_ (A.Suffix Integer
a) = (Integer -> Suffix)
-> Arrows (Domains (Integer -> Suffix)) (S Word32)
forall t.
(ICODE t (Arity t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Integer -> Suffix
A.Suffix Integer
a

  value :: Word32 -> R Suffix
value = (Node -> R Suffix) -> Word32 -> R Suffix
forall a. EmbPrj a => (Node -> R a) -> Word32 -> R a
vcase Node -> R Suffix
valu where
    valu :: Node
-> Arrows (Constant Word32 (Domains Suffix)) (R (CoDomain Suffix))
valu Node
N0     = Suffix
-> Arrows (Constant Word32 (Domains Suffix)) (R (CoDomain Suffix))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Suffix
A.NoSuffix
    valu (N1 Word32
a) = (Integer -> Suffix)
-> Arrows
     (Constant Word32 (Domains (Integer -> Suffix)))
     (R (CoDomain (Integer -> Suffix)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Integer -> Suffix
A.Suffix Word32
a
    valu Node
_      = R Suffix
Arrows (Constant Word32 (Domains Suffix)) (R (CoDomain Suffix))
forall a. HasCallStack => R a
malformed

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

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

instance EmbPrj KindOfName where
  -- Enums have a generic EmbPrj

instance EmbPrj BindingSource where
  icod_ :: BindingSource -> S Word32
icod_ = \case
    BindingSource
LambdaBound     -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
0
    PatternBound Hiding
_  -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
1
    BindingSource
LetBound        -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
2
    BindingSource
WithBound       -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
3
    BindingSource
MacroBound      -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
4

  value :: Word32 -> R BindingSource
value = \case
    Word32
0 -> BindingSource -> R BindingSource
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BindingSource
LambdaBound
    Word32
1 -> BindingSource -> R BindingSource
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (BindingSource -> R BindingSource)
-> BindingSource -> R BindingSource
forall a b. (a -> b) -> a -> b
$ Hiding -> BindingSource
PatternBound Hiding
forall a. Null a => a
empty
    Word32
2 -> BindingSource -> R BindingSource
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BindingSource
LetBound
    Word32
3 -> BindingSource -> R BindingSource
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BindingSource
WithBound
    Word32
4 -> BindingSource -> R BindingSource
forall a. a -> ReaderT Decode IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BindingSource
MacroBound
    Word32
_ -> R BindingSource
forall a. HasCallStack => R a
malformed

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

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

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

  value :: Word32 -> R ConPatInfo
value = (ConOrigin -> ConPatLazy -> ConPatInfo)
-> Word32 -> R (CoDomain (ConOrigin -> ConPatLazy -> ConPatInfo))
forall t.
(VALU t (Arity t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN ((ConOrigin -> ConPatLazy -> ConPatInfo)
 -> Word32 -> R (CoDomain (ConOrigin -> ConPatLazy -> ConPatInfo)))
-> (ConOrigin -> ConPatLazy -> ConPatInfo)
-> Word32
-> R (CoDomain (ConOrigin -> ConPatLazy -> ConPatInfo))
forall a b. (a -> b) -> a -> b
$ \ConOrigin
a 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 Word32
icod_ Pattern' a
x = (Dict -> IO Word32) -> S Word32
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT \Dict
dict -> case Pattern' a
x of
    (A.VarP BindName
a)            -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32
-> (BindName -> Pattern' (ZonkAny 0))
-> Arrows (Domains (BindName -> Pattern' (ZonkAny 0))) (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 BindName -> Pattern' (ZonkAny 0)
forall e. BindName -> Pattern' e
A.VarP BindName
a) Dict
dict
    (A.ConP ConPatInfo
a AmbiguousQName
b NAPs a
c)        -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32
-> (ConPatInfo -> AmbiguousQName -> NAPs a -> Pattern' a)
-> Arrows
     (Domains (ConPatInfo -> AmbiguousQName -> NAPs a -> Pattern' a))
     (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 ConPatInfo -> AmbiguousQName -> NAPs a -> Pattern' a
forall e. ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.ConP ConPatInfo
a AmbiguousQName
b NAPs a
c) Dict
dict
    (A.DefP PatInfo
p AmbiguousQName
a NAPs a
b)        -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32
-> (AmbiguousQName -> NAPs a -> Pattern' a)
-> Arrows
     (Domains (AmbiguousQName -> NAPs a -> Pattern' a)) (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
2 (PatInfo -> AmbiguousQName -> NAPs a -> Pattern' a
forall e. PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.DefP PatInfo
p) AmbiguousQName
a NAPs a
b) Dict
dict
    t :: Pattern' a
t@(A.WildP PatInfo
p)         -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32 -> Pattern' a -> Arrows (Domains (Pattern' a)) (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
3 Pattern' a
t) Dict
dict
    (A.AsP PatInfo
p BindName
a Pattern' a
b)         -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32
-> (BindName -> Pattern' a -> Pattern' a)
-> Arrows
     (Domains (BindName -> Pattern' a -> Pattern' a)) (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
4 (PatInfo -> BindName -> Pattern' a -> Pattern' a
forall e. PatInfo -> BindName -> Pattern' e -> Pattern' e
A.AsP PatInfo
p) BindName
a Pattern' a
b) Dict
dict
    (A.DotP PatInfo
r a
a)          -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32
-> (a -> Pattern' a)
-> Arrows (Domains (a -> Pattern' a)) (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
5 (PatInfo -> a -> Pattern' a
forall e. PatInfo -> e -> Pattern' e
A.DotP PatInfo
r) a
a) Dict
dict
    t :: Pattern' a
t@(A.AbsurdP PatInfo
_)       -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32 -> Pattern' a -> Arrows (Domains (Pattern' a)) (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
6 Pattern' a
t) Dict
dict
    (A.LitP PatInfo
i Literal
a)          -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32
-> (Literal -> Pattern' (ZonkAny 1))
-> Arrows (Domains (Literal -> Pattern' (ZonkAny 1))) (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
7 (PatInfo -> Literal -> Pattern' (ZonkAny 1)
forall e. PatInfo -> Literal -> Pattern' e
A.LitP PatInfo
i) Literal
a) Dict
dict
    (A.ProjP PatInfo
p ProjOrigin
a AmbiguousQName
b)       -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32
-> (ProjOrigin -> AmbiguousQName -> Pattern' (ZonkAny 2))
-> Arrows
     (Domains (ProjOrigin -> AmbiguousQName -> Pattern' (ZonkAny 2)))
     (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
8 (PatInfo -> ProjOrigin -> AmbiguousQName -> Pattern' (ZonkAny 2)
forall e. PatInfo -> ProjOrigin -> AmbiguousQName -> Pattern' e
A.ProjP PatInfo
p) ProjOrigin
a AmbiguousQName
b) Dict
dict
    (A.PatternSynP PatInfo
p AmbiguousQName
a NAPs a
b) -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32
-> (AmbiguousQName -> NAPs a -> Pattern' a)
-> Arrows
     (Domains (AmbiguousQName -> NAPs a -> Pattern' a)) (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
9 (PatInfo -> AmbiguousQName -> NAPs a -> Pattern' a
forall e. PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.PatternSynP PatInfo
p) AmbiguousQName
a NAPs a
b) Dict
dict
    (A.RecP KwRange
r ConPatInfo
a [FieldAssignment' (Pattern' a)]
b)        -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32
-> (ConPatInfo -> [FieldAssignment' (Pattern' a)] -> Pattern' a)
-> Arrows
     (Domains
        (ConPatInfo -> [FieldAssignment' (Pattern' a)] -> Pattern' a))
     (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
10 (KwRange
-> ConPatInfo -> [FieldAssignment' (Pattern' a)] -> Pattern' a
forall e.
KwRange
-> ConPatInfo -> [FieldAssignment' (Pattern' e)] -> Pattern' e
A.RecP KwRange
r) ConPatInfo
a [FieldAssignment' (Pattern' a)]
b) Dict
dict
    (A.EqualP PatInfo
_ List1 (a, a)
a)        -> Dict -> IO Word32
forall a. HasCallStack => a
__IMPOSSIBLE__ Dict
dict
    (A.WithP PatInfo
i Pattern' a
a)         -> S Word32 -> Dict -> IO Word32
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Word32
-> (Pattern' a -> Pattern' a)
-> Arrows (Domains (Pattern' a -> Pattern' a)) (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
11 (PatInfo -> Pattern' a -> Pattern' a
forall e. PatInfo -> Pattern' e -> Pattern' e
A.WithP PatInfo
i) Pattern' a
a) Dict
dict

  value :: Word32 -> R (Pattern' a)
value Word32
x = (Decode -> IO (Pattern' a)) -> R (Pattern' a)
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT \Decode
dict -> R (Pattern' a) -> Decode -> IO (Pattern' a)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((Node -> R (Pattern' a)) -> Word32 -> R (Pattern' a)
forall a. EmbPrj a => (Node -> R a) -> Word32 -> R a
vcase Node -> R (Pattern' a)
forall {e}.
(EmbPrj e, EmbPrj (Pattern' e)) =>
Node -> ReaderT Decode IO (Pattern' e)
valu Word32
x) Decode
dict where
    valu :: Node -> ReaderT Decode IO (Pattern' e)
valu Node
x = (Decode -> IO (Pattern' e)) -> ReaderT Decode IO (Pattern' e)
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT \Decode
dict -> case Node
x of
      (N2 Word32
0 Word32
a)     -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((BindName -> Pattern' e)
-> Arrows
     (Constant Word32 (Domains (BindName -> Pattern' e)))
     (R (CoDomain (BindName -> Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN BindName -> Pattern' e
forall e. BindName -> Pattern' e
A.VarP Word32
a) Decode
dict
      (N4 Word32
1 Word32
a Word32
b Word32
c) -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e)
-> Arrows
     (Constant
        Word32
        (Domains (ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e)))
     (R (CoDomain
           (ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
forall e. ConPatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.ConP Word32
a Word32
b Word32
c) Decode
dict
      (N3 Word32
2 Word32
a Word32
b)   -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((AmbiguousQName -> NAPs e -> Pattern' e)
-> Arrows
     (Constant
        Word32 (Domains (AmbiguousQName -> NAPs e -> Pattern' e)))
     (R (CoDomain (AmbiguousQName -> NAPs e -> Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
forall e. PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.DefP PatInfo
i) Word32
a Word32
b) Decode
dict
      (N1 Word32
3)       -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Pattern' e
-> Arrows
     (Constant Word32 (Domains (Pattern' e)))
     (R (CoDomain (Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> Pattern' e
forall e. PatInfo -> Pattern' e
A.WildP PatInfo
i)) Decode
dict
      (N3 Word32
4 Word32
a Word32
b)   -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((BindName -> Pattern' e -> Pattern' e)
-> Arrows
     (Constant Word32 (Domains (BindName -> Pattern' e -> Pattern' e)))
     (R (CoDomain (BindName -> Pattern' e -> Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> BindName -> Pattern' e -> Pattern' e
forall e. PatInfo -> BindName -> Pattern' e -> Pattern' e
A.AsP PatInfo
i) Word32
a Word32
b) Decode
dict
      (N2 Word32
5 Word32
a)     -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((e -> Pattern' e)
-> Arrows
     (Constant Word32 (Domains (e -> Pattern' e)))
     (R (CoDomain (e -> Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> e -> Pattern' e
forall e. PatInfo -> e -> Pattern' e
A.DotP PatInfo
i) Word32
a) Decode
dict
      (N1 Word32
6)       -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (Pattern' e
-> Arrows
     (Constant Word32 (Domains (Pattern' e)))
     (R (CoDomain (Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> Pattern' e
forall e. PatInfo -> Pattern' e
A.AbsurdP PatInfo
i)) Decode
dict
      (N2 Word32
7 Word32
a)     -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((Literal -> Pattern' e)
-> Arrows
     (Constant Word32 (Domains (Literal -> Pattern' e)))
     (R (CoDomain (Literal -> Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> Literal -> Pattern' e
forall e. PatInfo -> Literal -> Pattern' e
A.LitP PatInfo
i) Word32
a) Decode
dict
      (N3 Word32
8 Word32
a Word32
b)   -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((ProjOrigin -> AmbiguousQName -> Pattern' e)
-> Arrows
     (Constant
        Word32 (Domains (ProjOrigin -> AmbiguousQName -> Pattern' e)))
     (R (CoDomain (ProjOrigin -> AmbiguousQName -> Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> ProjOrigin -> AmbiguousQName -> Pattern' e
forall e. PatInfo -> ProjOrigin -> AmbiguousQName -> Pattern' e
A.ProjP PatInfo
i) Word32
a Word32
b) Decode
dict
      (N3 Word32
9 Word32
a Word32
b)   -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((AmbiguousQName -> NAPs e -> Pattern' e)
-> Arrows
     (Constant
        Word32 (Domains (AmbiguousQName -> NAPs e -> Pattern' e)))
     (R (CoDomain (AmbiguousQName -> NAPs e -> Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
forall e. PatInfo -> AmbiguousQName -> NAPs e -> Pattern' e
A.PatternSynP PatInfo
i) Word32
a Word32
b) Decode
dict
      (N3 Word32
10 Word32
a Word32
b)  -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((ConPatInfo -> [FieldAssignment' (Pattern' e)] -> Pattern' e)
-> Arrows
     (Constant
        Word32
        (Domains
           (ConPatInfo -> [FieldAssignment' (Pattern' e)] -> Pattern' e)))
     (R (CoDomain
           (ConPatInfo -> [FieldAssignment' (Pattern' e)] -> Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (KwRange
-> ConPatInfo -> [FieldAssignment' (Pattern' e)] -> Pattern' e
forall e.
KwRange
-> ConPatInfo -> [FieldAssignment' (Pattern' e)] -> Pattern' e
A.RecP KwRange
forall a. Null a => a
empty) Word32
a Word32
b) Decode
dict
      (N2 Word32
11 Word32
a)    -> ReaderT Decode IO (Pattern' e) -> Decode -> IO (Pattern' e)
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ((Pattern' e -> Pattern' e)
-> Arrows
     (Constant Word32 (Domains (Pattern' e -> Pattern' e)))
     (R (CoDomain (Pattern' e -> Pattern' e)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN (PatInfo -> Pattern' e -> Pattern' e
forall e. PatInfo -> Pattern' e -> Pattern' e
A.WithP PatInfo
i) Word32
a) Decode
dict
      Node
_            -> IO (Pattern' e)
forall a. HasCallStack => IO a
malformedIO

    i :: PatInfo
i = PatInfo
patNoRange

-- | Hackish serialization for patterns that deletes dot patterns.
--   So that we can serialize the 'WithClauseProjectionFixityMismatch'
--   without having to define serialization of expressions.
--
instance {-# OVERLAPS #-} EmbPrj A.Pattern where
  icod_ :: Pattern -> S Word32
icod_ = Pattern' Void -> S Word32
forall a. EmbPrj a => a -> S Word32
icod_ (Pattern' Void -> S Word32)
-> (Pattern -> ReaderT Dict IO (Pattern' Void))
-> Pattern
-> S Word32
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< ReaderT Dict IO (Pattern' Void)
-> Pattern -> ReaderT Dict IO (Pattern' Void)
forall (m :: * -> *) e.
Monad m =>
m (Pattern' Void) -> Pattern' e -> m (Pattern' Void)
noDotOrEqPattern (Pattern' Void -> ReaderT Dict IO (Pattern' Void)
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Pattern' Void -> ReaderT Dict IO (Pattern' Void))
-> Pattern' Void -> ReaderT Dict IO (Pattern' Void)
forall a b. (a -> b) -> a -> b
$ PatInfo -> Pattern' Void
forall e. PatInfo -> Pattern' e
A.WildP PatInfo
forall a. Null a => a
empty)
  value :: Word32 -> R Pattern
value = (Void -> Expr) -> Pattern' Void -> Pattern
forall a b. (a -> b) -> Pattern' a -> Pattern' b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Void -> Expr
forall a. HasCallStack => a
__IMPOSSIBLE__ :: Void -> A.Expr) (Pattern' Void -> Pattern)
-> (Word32 -> ReaderT Decode IO (Pattern' Void))
-> Word32
-> R Pattern
forall (m :: * -> *) b c a.
Functor m =>
(b -> c) -> (a -> m b) -> a -> m c
<.> Word32 -> ReaderT Decode IO (Pattern' Void)
forall a. EmbPrj a => Word32 -> R a
value

instance EmbPrj ParenPreference where
  icod_ :: ParenPreference -> S Word32
icod_ ParenPreference
PreferParen     = ParenPreference -> Arrows (Domains ParenPreference) (S Word32)
forall t.
(ICODE t (Arity t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' ParenPreference
PreferParen
  icod_ ParenPreference
PreferParenless = Word32
-> ParenPreference -> Arrows (Domains ParenPreference) (S Word32)
forall t.
(ICODE (Word32 -> t) (Arity (Word32 -> t)),
 StrictCurrying (Domains (Word32 -> t)) (S Word32),
 All EmbPrj (Domains (Word32 -> t))) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 ParenPreference
PreferParenless
  value :: Word32 -> R ParenPreference
value = (Node -> R ParenPreference) -> Word32 -> R ParenPreference
forall a. EmbPrj a => (Node -> R a) -> Word32 -> R a
vcase Node -> R ParenPreference
valu where
    valu :: Node
-> Arrows
     (Constant Word32 (Domains ParenPreference))
     (R (CoDomain ParenPreference))
valu Node
N0     = ParenPreference
-> Arrows
     (Constant Word32 (Domains ParenPreference))
     (R (CoDomain ParenPreference))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN ParenPreference
PreferParen
    valu (N1 Word32
1) = ParenPreference
-> Arrows
     (Constant Word32 (Domains ParenPreference))
     (R (CoDomain ParenPreference))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN ParenPreference
PreferParenless
    valu Node
_      = R ParenPreference
Arrows
  (Constant Word32 (Domains ParenPreference))
  (R (CoDomain ParenPreference))
forall a. HasCallStack => R a
malformed

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

  value :: Word32 -> R Precedence
value = (Node -> R Precedence) -> Word32 -> R Precedence
forall a. EmbPrj a => (Node -> R a) -> Word32 -> R a
vcase Node -> R Precedence
valu where
    valu :: Node
-> Arrows
     (Constant Word32 (Domains Precedence)) (R (CoDomain Precedence))
valu Node
N0         = Precedence
-> Arrows
     (Constant Word32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Precedence
TopCtx
    valu (N1 Word32
1)     = Precedence
-> Arrows
     (Constant Word32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Precedence
FunctionSpaceDomainCtx
    valu (N2 Word32
2 Word32
a)   = (Fixity -> Precedence)
-> Arrows
     (Constant Word32 (Domains (Fixity -> Precedence)))
     (R (CoDomain (Fixity -> Precedence)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Fixity -> Precedence
LeftOperandCtx Word32
a
    valu (N3 Word32
3 Word32
a Word32
b) = (Fixity -> ParenPreference -> Precedence)
-> Arrows
     (Constant
        Word32 (Domains (Fixity -> ParenPreference -> Precedence)))
     (R (CoDomain (Fixity -> ParenPreference -> Precedence)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Fixity -> ParenPreference -> Precedence
RightOperandCtx Word32
a Word32
b
    valu (N1 Word32
4)     = Precedence
-> Arrows
     (Constant Word32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Precedence
FunctionCtx
    valu (N2 Word32
5 Word32
a)   = (ParenPreference -> Precedence)
-> Arrows
     (Constant Word32 (Domains (ParenPreference -> Precedence)))
     (R (CoDomain (ParenPreference -> Precedence)))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN ParenPreference -> Precedence
ArgumentCtx Word32
a
    valu (N1 Word32
6)     = Precedence
-> Arrows
     (Constant Word32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Precedence
InsideOperandCtx
    valu (N1 Word32
7)     = Precedence
-> Arrows
     (Constant Word32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Precedence
WithFunCtx
    valu (N1 Word32
8)     = Precedence
-> Arrows
     (Constant Word32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Precedence
WithArgCtx
    valu (N1 Word32
9)     = Precedence
-> Arrows
     (Constant Word32 (Domains Precedence)) (R (CoDomain Precedence))
forall t.
(VALU t (Arity t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Precedence
DotPatternCtx
    valu Node
_          = R Precedence
Arrows
  (Constant Word32 (Domains Precedence)) (R (CoDomain Precedence))
forall a. HasCallStack => R a
malformed

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

  value :: Word32 -> R ScopeInfo
value = (ModuleName
 -> Map ModuleName Scope
 -> LocalVars
 -> LocalVars
 -> PrecedenceStack
 -> ScopeInfo)
-> Word32
-> R (CoDomain
        (ModuleName
         -> Map ModuleName Scope
         -> LocalVars
         -> LocalVars
         -> PrecedenceStack
         -> ScopeInfo))
forall t.
(VALU t (Arity t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN (\ ModuleName
a Map ModuleName Scope
b LocalVars
c LocalVars
d PrecedenceStack
e -> ModuleName
-> Map ModuleName Scope
-> LocalVars
-> LocalVars
-> PrecedenceStack
-> NameMap
-> ModuleMap
-> InScopeSet
-> Fixities
-> Polarities
-> Map QName (QName, Maybe Induction)
-> ScopeInfo
ScopeInfo ModuleName
a Map ModuleName Scope
b LocalVars
c LocalVars
d PrecedenceStack
e NameMap
forall k v. HashMap k v
HMap.empty ModuleMap
forall k v. HashMap k v
HMap.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 Map QName (QName, Maybe Induction)
forall k a. Map k a
Map.empty)

instance EmbPrj NameOrModule