{-# LANGUAGE UndecidableInstances #-}

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

module Agda.TypeChecking.Serialise.Instances.Common (SerialisedRange(..)) where

import qualified Control.Exception as E
import Control.Monad              ( (<$!>) )
import Control.Monad.IO.Class     ( MonadIO(..) )
import Control.Monad.State        ( runStateT )
import Control.Monad.State.Strict ( gets, modify )

import Agda.Syntax.Common
import Agda.Syntax.Builtin
import Agda.Syntax.Concrete.Name as C
import Agda.Syntax.Concrete (RecordDirective(..))
import qualified Agda.Syntax.Concrete as C
import qualified Agda.Syntax.Abstract as A
import Agda.Syntax.Position as P
import Agda.Syntax.Literal
import Agda.Syntax.TopLevelModuleName
import Agda.Interaction.FindFile
import Agda.Interaction.Library

import Agda.TypeChecking.Monad.Base.Types
import Agda.TypeChecking.Serialise.Base
import Agda.TypeChecking.Serialise.Instances.General ()

import Agda.Utils.FileId (getIdFile)
import Agda.Utils.Null

import Agda.Utils.Impossible
import Agda.Utils.CallStack

instance EmbPrj ConstructorOrPatternSynonym

instance EmbPrj FileType where
  icod_ :: FileType -> S Word32
icod_ FileType
AgdaFileType  = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
0
  icod_ FileType
MdFileType    = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
1
  icod_ FileType
RstFileType   = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
2
  icod_ FileType
TexFileType   = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
3
  icod_ FileType
OrgFileType   = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
4
  icod_ FileType
TypstFileType = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
5
  icod_ FileType
TreeFileType  = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
6

  value :: Word32 -> R FileType
value = \case
    Word32
0 -> FileType -> R FileType
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FileType
AgdaFileType
    Word32
1 -> FileType -> R FileType
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FileType
MdFileType
    Word32
2 -> FileType -> R FileType
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FileType
RstFileType
    Word32
3 -> FileType -> R FileType
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FileType
TexFileType
    Word32
4 -> FileType -> R FileType
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FileType
OrgFileType
    Word32
5 -> FileType -> R FileType
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FileType
TypstFileType
    Word32
6 -> FileType -> R FileType
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure FileType
TreeFileType
    Word32
_ -> R FileType
forall a. R a
malformed

instance EmbPrj Cubical where
  icod_ :: Cubical -> S Word32
icod_ Cubical
CErased = Cubical -> Arrows (Domains Cubical) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN'  Cubical
CErased
  icod_ Cubical
CFull   = Word32 -> Cubical -> Arrows (Domains Cubical) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 Cubical
CFull

  value :: Word32 -> R Cubical
value = ([Word32] -> R Cubical) -> Word32 -> R Cubical
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase (([Word32] -> R Cubical) -> Word32 -> R Cubical)
-> ([Word32] -> R Cubical) -> Word32 -> R Cubical
forall a b. (a -> b) -> a -> b
$ \case
    []  -> Cubical
-> Arrows
     (Constant Word32 (Domains Cubical)) (R (CoDomain Cubical))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Cubical
CErased
    [Word32
0] -> Cubical
-> Arrows
     (Constant Word32 (Domains Cubical)) (R (CoDomain Cubical))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Cubical
CFull
    [Word32]
_   -> R Cubical
forall a. R a
malformed

instance EmbPrj Language where
  icod_ :: Language -> S Word32
icod_ Language
WithoutK    = Language -> Arrows (Domains Language) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN'  Language
WithoutK
  icod_ Language
WithK       = Word32 -> Language -> Arrows (Domains Language) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 Language
WithK
  icod_ (Cubical Cubical
a) = Word32
-> (Cubical -> Language)
-> Arrows (Domains (Cubical -> Language)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 Cubical -> Language
Cubical Cubical
a

  value :: Word32 -> R Language
value = ([Word32] -> R Language) -> Word32 -> R Language
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase (([Word32] -> R Language) -> Word32 -> R Language)
-> ([Word32] -> R Language) -> Word32 -> R Language
forall a b. (a -> b) -> a -> b
$ \case
    []     -> Language
-> Arrows
     (Constant Word32 (Domains Language)) (R (CoDomain Language))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Language
WithoutK
    [Word32
0]    -> Language
-> Arrows
     (Constant Word32 (Domains Language)) (R (CoDomain Language))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Language
WithK
    [Word32
1, Word32
a] -> (Cubical -> Language)
-> Arrows
     (Constant Word32 (Domains (Cubical -> Language)))
     (R (CoDomain (Cubical -> Language)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Cubical -> Language
Cubical Word32
a
    [Word32]
_      -> R Language
forall a. R a
malformed

instance EmbPrj a => EmbPrj (Position' a) where
  icod_ :: Position' a -> S Word32
icod_ (P.Pn a
file Word32
pos Word32
line Word32
col) = (a -> Word32 -> Word32 -> Word32 -> Position' a)
-> Arrows
     (Domains (a -> Word32 -> Word32 -> Word32 -> Position' a))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' a -> Word32 -> Word32 -> Word32 -> Position' a
forall a. a -> Word32 -> Word32 -> Word32 -> Position' a
P.Pn a
file Word32
pos Word32
line Word32
col

  value :: Word32 -> R (Position' a)
value = (a -> Word32 -> Word32 -> Word32 -> Position' a)
-> Word32
-> R (CoDomain (a -> Word32 -> Word32 -> Word32 -> Position' a))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN a -> Word32 -> Word32 -> Word32 -> Position' a
forall a. a -> Word32 -> Word32 -> Word32 -> Position' a
P.Pn

instance EmbPrj TopLevelModuleName where
  icod_ :: TopLevelModuleName -> S Word32
icod_ (TopLevelModuleName Range
a ModuleNameHash
b TopLevelModuleNameParts
c Bool
d) = (Range
 -> ModuleNameHash
 -> TopLevelModuleNameParts
 -> Bool
 -> TopLevelModuleName)
-> Arrows
     (Domains
        (Range
         -> ModuleNameHash
         -> TopLevelModuleNameParts
         -> Bool
         -> TopLevelModuleName))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Range
-> ModuleNameHash
-> TopLevelModuleNameParts
-> Bool
-> TopLevelModuleName
forall range.
range
-> ModuleNameHash
-> TopLevelModuleNameParts
-> Bool
-> TopLevelModuleName' range
TopLevelModuleName Range
a ModuleNameHash
b TopLevelModuleNameParts
c Bool
d

  value :: Word32 -> R TopLevelModuleName
value = (Range
 -> ModuleNameHash
 -> TopLevelModuleNameParts
 -> Bool
 -> TopLevelModuleName)
-> Word32
-> R (CoDomain
        (Range
         -> ModuleNameHash
         -> TopLevelModuleNameParts
         -> Bool
         -> TopLevelModuleName))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Range
-> ModuleNameHash
-> TopLevelModuleNameParts
-> Bool
-> TopLevelModuleName
forall range.
range
-> ModuleNameHash
-> TopLevelModuleNameParts
-> Bool
-> TopLevelModuleName' range
TopLevelModuleName

instance EmbPrj a => EmbPrj (P.Interval' a) where
  icod_ :: Interval' a -> S Word32
icod_ (P.Interval a
f PositionWithoutFile
p PositionWithoutFile
q) = (a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a)
-> Arrows
     (Domains
        (a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
forall a.
a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
P.Interval a
f PositionWithoutFile
p PositionWithoutFile
q

  value :: Word32 -> R (Interval' a)
value = (a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a)
-> Word32
-> R (CoDomain
        (a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
forall a.
a -> PositionWithoutFile -> PositionWithoutFile -> Interval' a
P.Interval

instance EmbPrj RangeFile where
  icod_ :: RangeFile -> S Word32
icod_ (RangeFile AbsolutePath
_ Maybe TopLevelModuleName
Nothing)  = S Word32
forall a. HasCallStack => a
__IMPOSSIBLE__
  icod_ (RangeFile AbsolutePath
_ (Just TopLevelModuleName
a)) = TopLevelModuleName -> S Word32
forall a. EmbPrj a => a -> S Word32
icode TopLevelModuleName
a

  value :: Word32 -> R RangeFile
value Word32
r = do
    m :: TopLevelModuleName
            <- Word32 -> R TopLevelModuleName
forall a. EmbPrj a => Word32 -> R a
value Word32
r
    mf      <- gets modFile
    incs    <- gets includes
    (r, mf) <- liftIO $ runStateT (findFile'' incs m) mf
    modify $ \St
s -> St
s { modFile = mf }
    case r of
      Left FindError
err -> IO RangeFile -> R RangeFile
forall a. IO a -> StateT St IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RangeFile -> R RangeFile) -> IO RangeFile -> R RangeFile
forall a b. (a -> b) -> a -> b
$ ErrorCall -> IO RangeFile
forall e a. (HasCallStack, Exception e) => e -> IO a
E.throwIO (ErrorCall -> IO RangeFile) -> ErrorCall -> IO RangeFile
forall a b. (a -> b) -> a -> b
$ String -> ErrorCall
E.ErrorCall (String -> ErrorCall) -> String -> ErrorCall
forall a b. (a -> b) -> a -> b
$ String
"file not found: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ FindError -> String
forall a. Show a => a -> String
show FindError
err
      Right (SourceFile FileId
i)  -> do
        let fp :: AbsolutePath
fp = FileDictWithBuiltins -> FileId -> AbsolutePath
forall a. GetIdFile a => a -> FileId -> AbsolutePath
getIdFile (ModuleToSource -> FileDictWithBuiltins
fileDict ModuleToSource
mf) FileId
i
        RangeFile -> R RangeFile
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (RangeFile -> R RangeFile) -> RangeFile -> R RangeFile
forall a b. (a -> b) -> a -> b
$ AbsolutePath -> Maybe TopLevelModuleName -> RangeFile
RangeFile AbsolutePath
fp (TopLevelModuleName -> Maybe TopLevelModuleName
forall a. a -> Maybe a
Just TopLevelModuleName
m)

-- | Ranges are always deserialised as 'noRange'.

instance EmbPrj Range where
  icod_ :: Range -> S Word32
icod_ Range
_ = () -> Arrows (Domains ()) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' ()
  value :: Word32 -> R Range
value Word32
_ = Range -> R Range
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Range
forall a. Range' a
noRange

instance EmbPrj KwRange where
  icod_ :: KwRange -> S Word32
icod_ KwRange
_ = () -> Arrows (Domains ()) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' ()
  value :: Word32 -> R KwRange
value Word32
_ = KwRange -> R KwRange
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return KwRange
forall a. Null a => a
empty

-- | Ranges that should be serialised properly.

newtype SerialisedRange = SerialisedRange { SerialisedRange -> Range
underlyingRange :: Range }

instance EmbPrj SerialisedRange where
  icod_ :: SerialisedRange -> S Word32
icod_ (SerialisedRange Range
r) = (SrcFile -> [IntervalWithoutFile] -> Range)
-> Arrows
     (Domains (SrcFile -> [IntervalWithoutFile] -> Range)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' SrcFile -> [IntervalWithoutFile] -> Range
forall a. a -> [IntervalWithoutFile] -> Range' a
P.intervalsToRange (Range -> SrcFile
P.rangeFile Range
r) (Range -> [IntervalWithoutFile]
forall a. Range' a -> [IntervalWithoutFile]
P.rangeIntervals Range
r)

  value :: Word32 -> R SerialisedRange
value Word32
i = Range -> SerialisedRange
SerialisedRange (Range -> SerialisedRange) -> R Range -> R SerialisedRange
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> (SrcFile -> [IntervalWithoutFile] -> Range)
-> Word32
-> R (CoDomain (SrcFile -> [IntervalWithoutFile] -> Range))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN SrcFile -> [IntervalWithoutFile] -> Range
forall a. a -> [IntervalWithoutFile] -> Range' a
P.intervalsToRange Word32
i

instance EmbPrj C.Name where
  icod_ :: Name -> S Word32
icod_ (C.NoName Range
a NameId
b)     = Word32
-> (Range -> NameId -> Name)
-> Arrows (Domains (Range -> NameId -> Name)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 Range -> NameId -> Name
C.NoName Range
a NameId
b
  icod_ (C.Name Range
r NameInScope
nis NameParts
xs)  = Word32
-> (Range -> NameInScope -> NameParts -> Name)
-> Arrows
     (Domains (Range -> NameInScope -> NameParts -> Name)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 Range -> NameInScope -> NameParts -> Name
C.Name Range
r NameInScope
nis NameParts
xs

  value :: Word32 -> R Name
value = ([Word32] -> R Name) -> Word32 -> R Name
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R Name
valu where
    valu :: [Word32] -> R Name
valu [Word32
0, Word32
a, Word32
b]       = (Range -> NameId -> Name)
-> Arrows
     (Constant Word32 (Domains (Range -> NameId -> Name)))
     (R (CoDomain (Range -> NameId -> Name)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Range -> NameId -> Name
C.NoName Word32
a Word32
b
    valu [Word32
1, Word32
r, Word32
nis, Word32
xs] = (Range -> NameInScope -> NameParts -> Name)
-> Arrows
     (Constant
        Word32 (Domains (Range -> NameInScope -> NameParts -> Name)))
     (R (CoDomain (Range -> NameInScope -> NameParts -> Name)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Range -> NameInScope -> NameParts -> Name
C.Name   Word32
r Word32
nis Word32
xs
    valu [Word32]
_               = R Name
forall a. R a
malformed

instance EmbPrj NamePart where
  icod_ :: NamePart -> S Word32
icod_ NamePart
Hole   = NamePart -> Arrows (Domains NamePart) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' NamePart
Hole
  icod_ (Id String
a) = (String -> NamePart)
-> Arrows (Domains (String -> NamePart)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' String -> NamePart
Id String
a

  value :: Word32 -> R NamePart
value = ([Word32] -> R NamePart) -> Word32 -> R NamePart
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R NamePart
valu where
    valu :: [Word32]
-> Arrows
     (Constant Word32 (Domains NamePart)) (R (CoDomain NamePart))
valu []  = NamePart
-> Arrows
     (Constant Word32 (Domains NamePart)) (R (CoDomain NamePart))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN NamePart
Hole
    valu [Word32
a] = (String -> NamePart)
-> Arrows
     (Constant Word32 (Domains (String -> NamePart)))
     (R (CoDomain (String -> NamePart)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN String -> NamePart
Id Word32
a
    valu [Word32]
_   = R NamePart
Arrows (Constant Word32 (Domains NamePart)) (R (CoDomain NamePart))
forall a. R a
malformed

instance EmbPrj NameInScope where
  icod_ :: NameInScope -> S Word32
icod_ NameInScope
InScope    = NameInScope -> Arrows (Domains NameInScope) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' NameInScope
InScope
  icod_ NameInScope
NotInScope = Word32 -> NameInScope -> Arrows (Domains NameInScope) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 NameInScope
NotInScope

  value :: Word32 -> R NameInScope
value = ([Word32] -> R NameInScope) -> Word32 -> R NameInScope
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R NameInScope
forall {a}. (Eq a, Num a) => [a] -> R NameInScope
valu where
    valu :: [a]
-> Arrows
     (Constant Word32 (Domains NameInScope)) (R (CoDomain NameInScope))
valu []  = NameInScope
-> Arrows
     (Constant Word32 (Domains NameInScope)) (R (CoDomain NameInScope))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN NameInScope
InScope
    valu [a
0] = NameInScope
-> Arrows
     (Constant Word32 (Domains NameInScope)) (R (CoDomain NameInScope))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN NameInScope
NotInScope
    valu [a]
_   = R NameInScope
Arrows
  (Constant Word32 (Domains NameInScope)) (R (CoDomain NameInScope))
forall a. R a
malformed

instance EmbPrj C.QName where
  icod_ :: QName -> S Word32
icod_ (Qual    Name
a QName
b) = (Name -> QName -> QName)
-> Arrows (Domains (Name -> QName -> QName)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Name -> QName -> QName
Qual Name
a QName
b
  icod_ (C.QName Name
a  ) = (Name -> QName) -> Arrows (Domains (Name -> QName)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Name -> QName
C.QName Name
a

  value :: Word32 -> R QName
value = ([Word32] -> R QName) -> Word32 -> R QName
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R QName
valu where
    valu :: [Word32] -> R QName
valu [Word32
a, Word32
b] = (Name -> QName -> QName)
-> Arrows
     (Constant Word32 (Domains (Name -> QName -> QName)))
     (R (CoDomain (Name -> QName -> QName)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Name -> QName -> QName
Qual    Word32
a Word32
b
    valu [Word32
a]    = (Name -> QName)
-> Arrows
     (Constant Word32 (Domains (Name -> QName)))
     (R (CoDomain (Name -> QName)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Name -> QName
C.QName Word32
a
    valu [Word32]
_      = R QName
forall a. R a
malformed

instance (EmbPrj a, EmbPrj b) => EmbPrj (ImportedName' a b) where
  icod_ :: ImportedName' a b -> S Word32
icod_ (ImportedModule b
a) = Word32
-> (b -> ImportedName' (ZonkAny 1) b)
-> Arrows (Domains (b -> ImportedName' (ZonkAny 1) b)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 b -> ImportedName' (ZonkAny 1) b
forall n m. m -> ImportedName' n m
ImportedModule b
a
  icod_ (ImportedName a
a)   = Word32
-> (a -> ImportedName' a (ZonkAny 2))
-> Arrows (Domains (a -> ImportedName' a (ZonkAny 2))) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
2 a -> ImportedName' a (ZonkAny 2)
forall n m. n -> ImportedName' n m
ImportedName a
a

  value :: Word32 -> R (ImportedName' a b)
value = ([Word32] -> R (ImportedName' a b))
-> Word32 -> R (ImportedName' a b)
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R (ImportedName' a b)
forall {m} {n}.
(EmbPrj m, EmbPrj n) =>
[Word32] -> R (ImportedName' n m)
valu where
    valu :: [Word32] -> R (ImportedName' n m)
valu [Word32
1, Word32
a] = (m -> ImportedName' n m)
-> Arrows
     (Constant Word32 (Domains (m -> ImportedName' n m)))
     (R (CoDomain (m -> ImportedName' n m)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN m -> ImportedName' n m
forall n m. m -> ImportedName' n m
ImportedModule Word32
a
    valu [Word32
2, Word32
a] = (n -> ImportedName' n m)
-> Arrows
     (Constant Word32 (Domains (n -> ImportedName' n m)))
     (R (CoDomain (n -> ImportedName' n m)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN n -> ImportedName' n m
forall n m. n -> ImportedName' n m
ImportedName Word32
a
    valu [Word32]
_ = R (ImportedName' n m)
forall a. R a
malformed

instance EmbPrj Associativity where
  icod_ :: Associativity -> S Word32
icod_ Associativity
LeftAssoc  = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
0
  icod_ Associativity
RightAssoc = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
1
  icod_ Associativity
NonAssoc   = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
2

  value :: Word32 -> R Associativity
value = \case
    Word32
0 -> Associativity -> R Associativity
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Associativity
LeftAssoc
    Word32
1 -> Associativity -> R Associativity
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Associativity
RightAssoc
    Word32
2 -> Associativity -> R Associativity
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Associativity
NonAssoc
    Word32
_ -> R Associativity
forall a. R a
malformed

instance EmbPrj FixityLevel where
  icod_ :: FixityLevel -> S Word32
icod_ FixityLevel
Unrelated   = FixityLevel -> Arrows (Domains FixityLevel) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' FixityLevel
Unrelated
  icod_ (Related PrecedenceLevel
a) = (PrecedenceLevel -> FixityLevel)
-> Arrows (Domains (PrecedenceLevel -> FixityLevel)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' PrecedenceLevel -> FixityLevel
Related PrecedenceLevel
a

  value :: Word32 -> R FixityLevel
value = ([Word32] -> R FixityLevel) -> Word32 -> R FixityLevel
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R FixityLevel
valu where
    valu :: [Word32]
-> Arrows
     (Constant Word32 (Domains FixityLevel)) (R (CoDomain FixityLevel))
valu []  = FixityLevel
-> Arrows
     (Constant Word32 (Domains FixityLevel)) (R (CoDomain FixityLevel))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN FixityLevel
Unrelated
    valu [Word32
a] = (PrecedenceLevel -> FixityLevel)
-> Arrows
     (Constant Word32 (Domains (PrecedenceLevel -> FixityLevel)))
     (R (CoDomain (PrecedenceLevel -> FixityLevel)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN PrecedenceLevel -> FixityLevel
Related Word32
a
    valu [Word32]
_   = R FixityLevel
Arrows
  (Constant Word32 (Domains FixityLevel)) (R (CoDomain FixityLevel))
forall a. R a
malformed

instance EmbPrj Fixity where
  icod_ :: Fixity -> S Word32
icod_ (Fixity Range
a FixityLevel
b Associativity
c) = (Range -> FixityLevel -> Associativity -> Fixity)
-> Arrows
     (Domains (Range -> FixityLevel -> Associativity -> Fixity))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Range -> FixityLevel -> Associativity -> Fixity
Fixity Range
a FixityLevel
b Associativity
c

  value :: Word32 -> R Fixity
value = (Range -> FixityLevel -> Associativity -> Fixity)
-> Word32
-> R (CoDomain (Range -> FixityLevel -> Associativity -> Fixity))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Range -> FixityLevel -> Associativity -> Fixity
Fixity

instance EmbPrj Fixity' where
  icod_ :: Fixity' -> S Word32
icod_ (Fixity' Fixity
a Notation
b Range
r) = (Fixity -> Notation -> Fixity')
-> Arrows (Domains (Fixity -> Notation -> Fixity')) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' (\ Fixity
a Notation
b -> Fixity -> Notation -> Range -> Fixity'
Fixity' Fixity
a Notation
b Range
r) Fixity
a Notation
b  -- discard theNameRange

  value :: Word32 -> R Fixity'
value = (Fixity -> Notation -> Fixity')
-> Word32 -> R (CoDomain (Fixity -> Notation -> Fixity'))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN (\ Fixity
f Notation
n -> Fixity -> Notation -> Range -> Fixity'
Fixity' Fixity
f Notation
n Range
forall a. Range' a
noRange)

instance EmbPrj BoundVariablePosition where
  icod_ :: BoundVariablePosition -> S Word32
icod_ (BoundVariablePosition Int
a Int
b) = (Int -> Int -> BoundVariablePosition)
-> Arrows
     (Domains (Int -> Int -> BoundVariablePosition)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Int -> Int -> BoundVariablePosition
BoundVariablePosition Int
a Int
b

  value :: Word32 -> R BoundVariablePosition
value = (Int -> Int -> BoundVariablePosition)
-> Word32 -> R (CoDomain (Int -> Int -> BoundVariablePosition))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Int -> Int -> BoundVariablePosition
BoundVariablePosition

instance EmbPrj NotationPart where
  icod_ :: NotationPart -> S Word32
icod_ (VarPart Range
a Ranged BoundVariablePosition
b)  = Word32
-> (Range -> Ranged BoundVariablePosition -> NotationPart)
-> Arrows
     (Domains (Range -> Ranged BoundVariablePosition -> NotationPart))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 Range -> Ranged BoundVariablePosition -> NotationPart
VarPart Range
a Ranged BoundVariablePosition
b
  icod_ (HolePart Range
a NamedArg (Ranged Int)
b) = Word32
-> (Range -> NamedArg (Ranged Int) -> NotationPart)
-> Arrows
     (Domains (Range -> NamedArg (Ranged Int) -> NotationPart))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 Range -> NamedArg (Ranged Int) -> NotationPart
HolePart Range
a NamedArg (Ranged Int)
b
  icod_ (WildPart Ranged BoundVariablePosition
a)   = Word32
-> (Ranged BoundVariablePosition -> NotationPart)
-> Arrows
     (Domains (Ranged BoundVariablePosition -> NotationPart)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
2 Ranged BoundVariablePosition -> NotationPart
WildPart Ranged BoundVariablePosition
a
  icod_ (IdPart RString
a)     = (RString -> NotationPart)
-> Arrows (Domains (RString -> NotationPart)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' RString -> NotationPart
IdPart RString
a

  value :: Word32 -> R NotationPart
value = ([Word32] -> R NotationPart) -> Word32 -> R NotationPart
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R NotationPart
valu where
    valu :: [Word32] -> R NotationPart
valu [Word32
0, Word32
a, Word32
b] = (Range -> Ranged BoundVariablePosition -> NotationPart)
-> Arrows
     (Constant
        Word32
        (Domains (Range -> Ranged BoundVariablePosition -> NotationPart)))
     (R (CoDomain
           (Range -> Ranged BoundVariablePosition -> NotationPart)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Range -> Ranged BoundVariablePosition -> NotationPart
VarPart Word32
a Word32
b
    valu [Word32
1, Word32
a, Word32
b] = (Range -> NamedArg (Ranged Int) -> NotationPart)
-> Arrows
     (Constant
        Word32 (Domains (Range -> NamedArg (Ranged Int) -> NotationPart)))
     (R (CoDomain (Range -> NamedArg (Ranged Int) -> NotationPart)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Range -> NamedArg (Ranged Int) -> NotationPart
HolePart Word32
a Word32
b
    valu [Word32
2, Word32
a]    = (Ranged BoundVariablePosition -> NotationPart)
-> Arrows
     (Constant
        Word32 (Domains (Ranged BoundVariablePosition -> NotationPart)))
     (R (CoDomain (Ranged BoundVariablePosition -> NotationPart)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Ranged BoundVariablePosition -> NotationPart
WildPart Word32
a
    valu [Word32
a]       = (RString -> NotationPart)
-> Arrows
     (Constant Word32 (Domains (RString -> NotationPart)))
     (R (CoDomain (RString -> NotationPart)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN RString -> NotationPart
IdPart Word32
a
    valu [Word32]
_         = R NotationPart
forall a. R a
malformed

instance EmbPrj MetaId where
  icod_ :: MetaId -> S Word32
icod_ (MetaId Word64
a ModuleNameHash
b) = (Word64, ModuleNameHash) -> S Word32
forall a. EmbPrj a => a -> S Word32
icode (Word64
a, ModuleNameHash
b)

  value :: Word32 -> R MetaId
value Word32
m = (Word64 -> ModuleNameHash -> MetaId)
-> (Word64, ModuleNameHash) -> MetaId
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Word64 -> ModuleNameHash -> MetaId
MetaId ((Word64, ModuleNameHash) -> MetaId)
-> StateT St IO (Word64, ModuleNameHash) -> R MetaId
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> StateT St IO (Word64, ModuleNameHash)
forall a. EmbPrj a => Word32 -> R a
value Word32
m

instance EmbPrj ProblemId where
  icod_ :: ProblemId -> S Word32
icod_ (ProblemId Int
a) = Int -> S Word32
forall a. EmbPrj a => a -> S Word32
icode Int
a

  value :: Word32 -> R ProblemId
value Word32
m = Int -> ProblemId
ProblemId (Int -> ProblemId) -> StateT St IO Int -> R ProblemId
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> StateT St IO Int
forall a. EmbPrj a => Word32 -> R a
value Word32
m

instance EmbPrj A.QName where
  icod_ :: QName -> S Word32
icod_ n :: QName
n@(A.QName ModuleName
a Name
b) = (Dict -> HashTable QNameId Word32)
-> (Dict -> IORef FreshAndReuse) -> QNameId -> S Word32 -> S Word32
forall a.
(Ord a, Hashable a) =>
(Dict -> HashTable a Word32)
-> (Dict -> IORef FreshAndReuse) -> a -> S Word32 -> S Word32
icodeMemo Dict -> HashTable QNameId Word32
qnameD Dict -> IORef FreshAndReuse
qnameC (QName -> QNameId
qnameId QName
n) (S Word32 -> S Word32) -> S Word32 -> S Word32
forall a b. (a -> b) -> a -> b
$ (ModuleName -> Name -> QName)
-> Arrows (Domains (ModuleName -> Name -> QName)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' ModuleName -> Name -> QName
A.QName ModuleName
a Name
b

  value :: Word32 -> R QName
value = (ModuleName -> Name -> QName)
-> Word32 -> R (CoDomain (ModuleName -> Name -> QName))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN ModuleName -> Name -> QName
A.QName

instance EmbPrj A.AmbiguousQName where
  icod_ :: AmbiguousQName -> S Word32
icod_ (A.AmbQ List1 QName
a) = List1 QName -> S Word32
forall a. EmbPrj a => a -> S Word32
icode List1 QName
a
  value :: Word32 -> R AmbiguousQName
value Word32
n          = List1 QName -> AmbiguousQName
A.AmbQ (List1 QName -> AmbiguousQName)
-> StateT St IO (List1 QName) -> R AmbiguousQName
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> StateT St IO (List1 QName)
forall a. EmbPrj a => Word32 -> R a
value Word32
n

instance EmbPrj A.ModuleName where
  icod_ :: ModuleName -> S Word32
icod_ (A.MName [Name]
a) = [Name] -> S Word32
forall a. EmbPrj a => a -> S Word32
icode [Name]
a
  value :: Word32 -> R ModuleName
value Word32
n           = [Name] -> ModuleName
A.MName ([Name] -> ModuleName) -> StateT St IO [Name] -> R ModuleName
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> StateT St IO [Name]
forall a. EmbPrj a => Word32 -> R a
value Word32
n

instance EmbPrj A.Name where
  icod_ :: Name -> S Word32
icod_ (A.Name NameId
a Name
b Name
c Range
d Fixity'
e Bool
f) = (Dict -> HashTable NameId Word32)
-> (Dict -> IORef FreshAndReuse) -> NameId -> S Word32 -> S Word32
forall a.
(Ord a, Hashable a) =>
(Dict -> HashTable a Word32)
-> (Dict -> IORef FreshAndReuse) -> a -> S Word32 -> S Word32
icodeMemo Dict -> HashTable NameId Word32
nameD Dict -> IORef FreshAndReuse
nameC NameId
a (S Word32 -> S Word32) -> S Word32 -> S Word32
forall a b. (a -> b) -> a -> b
$
    (NameId
 -> Name -> Name -> SerialisedRange -> Fixity' -> Bool -> Name)
-> Arrows
     (Domains
        (NameId
         -> Name -> Name -> SerialisedRange -> Fixity' -> Bool -> Name))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' (\ NameId
a Name
b Name
c -> NameId -> Name -> Name -> Range -> Fixity' -> Bool -> Name
A.Name NameId
a Name
b Name
c (Range -> Fixity' -> Bool -> Name)
-> (SerialisedRange -> Range)
-> SerialisedRange
-> Fixity'
-> Bool
-> Name
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SerialisedRange -> Range
underlyingRange) NameId
a Name
b Name
c (Range -> SerialisedRange
SerialisedRange Range
d) Fixity'
e Bool
f

  value :: Word32 -> R Name
value = (NameId
 -> Name -> Name -> SerialisedRange -> Fixity' -> Bool -> Name)
-> Word32
-> R (CoDomain
        (NameId
         -> Name -> Name -> SerialisedRange -> Fixity' -> Bool -> Name))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN (\NameId
a Name
b Name
c SerialisedRange
d -> NameId -> Name -> Name -> Range -> Fixity' -> Bool -> Name
A.Name NameId
a Name
b Name
c (SerialisedRange -> Range
underlyingRange SerialisedRange
d))

instance EmbPrj a => EmbPrj (C.FieldAssignment' a) where
  icod_ :: FieldAssignment' a -> S Word32
icod_ (C.FieldAssignment Name
a a
b) = (Name -> a -> FieldAssignment' a)
-> Arrows (Domains (Name -> a -> FieldAssignment' a)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Name -> a -> FieldAssignment' a
forall a. Name -> a -> FieldAssignment' a
C.FieldAssignment Name
a a
b

  value :: Word32 -> R (FieldAssignment' a)
value = (Name -> a -> FieldAssignment' a)
-> Word32 -> R (CoDomain (Name -> a -> FieldAssignment' a))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Name -> a -> FieldAssignment' a
forall a. Name -> a -> FieldAssignment' a
C.FieldAssignment

instance (EmbPrj s, EmbPrj t) => EmbPrj (Named s t) where
  icod_ :: Named s t -> S Word32
icod_ (Named Maybe s
a t
b) = (Maybe s -> t -> Named s t)
-> Arrows (Domains (Maybe s -> t -> Named s t)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Maybe s -> t -> Named s t
forall name a. Maybe name -> a -> Named name a
Named Maybe s
a t
b

  value :: Word32 -> R (Named s t)
value = (Maybe s -> t -> Named s t)
-> Word32 -> R (CoDomain (Maybe s -> t -> Named s t))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Maybe s -> t -> Named s t
forall name a. Maybe name -> a -> Named name a
Named

instance EmbPrj a => EmbPrj (Ranged a) where
  icod_ :: Ranged a -> S Word32
icod_ (Ranged Range
r a
x) = (Range -> a -> Ranged a)
-> Arrows (Domains (Range -> a -> Ranged a)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Range -> a -> Ranged a
forall a. Range -> a -> Ranged a
Ranged Range
r a
x

  value :: Word32 -> R (Ranged a)
value = (Range -> a -> Ranged a)
-> Word32 -> R (CoDomain (Range -> a -> Ranged a))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Range -> a -> Ranged a
forall a. Range -> a -> Ranged a
Ranged

instance EmbPrj ArgInfo where
  icod_ :: ArgInfo -> S Word32
icod_ (ArgInfo Hiding
h Modality
r Origin
o FreeVariables
fv Annotation
ann) = (Hiding
 -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo)
-> Arrows
     (Domains
        (Hiding
         -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Hiding
-> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo
ArgInfo Hiding
h Modality
r Origin
o FreeVariables
fv Annotation
ann

  value :: Word32 -> R ArgInfo
value = (Hiding
 -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo)
-> Word32
-> R (CoDomain
        (Hiding
         -> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Hiding
-> Modality -> Origin -> FreeVariables -> Annotation -> ArgInfo
ArgInfo

instance EmbPrj ModuleNameHash where
  icod_ :: ModuleNameHash -> S Word32
icod_ (ModuleNameHash Word64
a) = (Word64 -> ModuleNameHash)
-> Arrows (Domains (Word64 -> ModuleNameHash)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Word64 -> ModuleNameHash
ModuleNameHash Word64
a

  value :: Word32 -> R ModuleNameHash
value = (Word64 -> ModuleNameHash)
-> Word32 -> R (CoDomain (Word64 -> ModuleNameHash))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Word64 -> ModuleNameHash
ModuleNameHash

instance EmbPrj NameId where
  icod_ :: NameId -> S Word32
icod_ (NameId Word64
a ModuleNameHash
b) = (Word64 -> ModuleNameHash -> NameId)
-> Arrows (Domains (Word64 -> ModuleNameHash -> NameId)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Word64 -> ModuleNameHash -> NameId
NameId Word64
a ModuleNameHash
b

  value :: Word32 -> R NameId
value = (Word64 -> ModuleNameHash -> NameId)
-> Word32 -> R (CoDomain (Word64 -> ModuleNameHash -> NameId))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Word64 -> ModuleNameHash -> NameId
NameId

instance EmbPrj OpaqueId where
  icod_ :: OpaqueId -> S Word32
icod_ (OpaqueId Word64
a ModuleNameHash
b) = (Word64 -> ModuleNameHash -> OpaqueId)
-> Arrows
     (Domains (Word64 -> ModuleNameHash -> OpaqueId)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Word64 -> ModuleNameHash -> OpaqueId
OpaqueId Word64
a ModuleNameHash
b

  value :: Word32 -> R OpaqueId
value = (Word64 -> ModuleNameHash -> OpaqueId)
-> Word32 -> R (CoDomain (Word64 -> ModuleNameHash -> OpaqueId))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Word64 -> ModuleNameHash -> OpaqueId
OpaqueId

instance EmbPrj a => EmbPrj (WithHiding a) where
  icod_ :: WithHiding a -> S Word32
icod_ (WithHiding Hiding
a a
b) = (Hiding -> a -> WithHiding a)
-> Arrows (Domains (Hiding -> a -> WithHiding a)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Hiding -> a -> WithHiding a
forall a. Hiding -> a -> WithHiding a
WithHiding Hiding
a a
b

  value :: Word32 -> R (WithHiding a)
value = (Hiding -> a -> WithHiding a)
-> Word32 -> R (CoDomain (Hiding -> a -> WithHiding a))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Hiding -> a -> WithHiding a
forall a. Hiding -> a -> WithHiding a
WithHiding

instance EmbPrj a => EmbPrj (Arg a) where
  icod_ :: Arg a -> S Word32
icod_ (Arg ArgInfo
i a
e) = (ArgInfo -> a -> Arg a)
-> Arrows (Domains (ArgInfo -> a -> Arg a)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' ArgInfo -> a -> Arg a
forall e. ArgInfo -> e -> Arg e
Arg ArgInfo
i a
e

  value :: Word32 -> R (Arg a)
value = (ArgInfo -> a -> Arg a)
-> Word32 -> R (CoDomain (ArgInfo -> a -> Arg a))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN ArgInfo -> a -> Arg a
forall e. ArgInfo -> e -> Arg e
Arg

instance EmbPrj a => EmbPrj (HasEta' a) where
  icod_ :: HasEta' a -> S Word32
icod_ HasEta' a
YesEta    = HasEta' (ZonkAny 0)
-> Arrows (Domains (HasEta' (ZonkAny 0))) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' HasEta' (ZonkAny 0)
forall a. HasEta' a
YesEta
  icod_ (NoEta a
a) = (a -> HasEta' a) -> Arrows (Domains (a -> HasEta' a)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' a -> HasEta' a
forall a. a -> HasEta' a
NoEta a
a

  value :: Word32 -> R (HasEta' a)
value = ([Word32] -> R (HasEta' a)) -> Word32 -> R (HasEta' a)
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R (HasEta' a)
forall {a}. EmbPrj a => [Word32] -> StateT St IO (HasEta' a)
valu where
    valu :: [Word32]
-> Arrows
     (Constant Word32 (Domains (HasEta' a))) (R (CoDomain (HasEta' a)))
valu []  = HasEta' a
-> Arrows
     (Constant Word32 (Domains (HasEta' a))) (R (CoDomain (HasEta' a)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN HasEta' a
forall a. HasEta' a
YesEta
    valu [Word32
a] = (a -> HasEta' a)
-> Arrows
     (Constant Word32 (Domains (a -> HasEta' a)))
     (R (CoDomain (a -> HasEta' a)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN a -> HasEta' a
forall a. a -> HasEta' a
NoEta Word32
a
    valu [Word32]
_   = StateT St IO (HasEta' a)
Arrows
  (Constant Word32 (Domains (HasEta' a))) (R (CoDomain (HasEta' a)))
forall a. R a
malformed

instance EmbPrj PatternOrCopattern
instance EmbPrj OverlapMode

instance EmbPrj Induction where
  icod_ :: Induction -> S Word32
icod_ Induction
Inductive   = Induction -> Arrows (Domains Induction) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Induction
Inductive
  icod_ Induction
CoInductive = Word32 -> Induction -> Arrows (Domains Induction) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 Induction
CoInductive

  value :: Word32 -> R Induction
value = ([Word32] -> R Induction) -> Word32 -> R Induction
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R Induction
forall {a}. (Eq a, Num a) => [a] -> R Induction
valu where
    valu :: [a]
-> Arrows
     (Constant Word32 (Domains Induction)) (R (CoDomain Induction))
valu []  = Induction
-> Arrows
     (Constant Word32 (Domains Induction)) (R (CoDomain Induction))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Induction
Inductive
    valu [a
1] = Induction
-> Arrows
     (Constant Word32 (Domains Induction)) (R (CoDomain Induction))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Induction
CoInductive
    valu [a]
_   = R Induction
Arrows
  (Constant Word32 (Domains Induction)) (R (CoDomain Induction))
forall a. R a
malformed

instance EmbPrj Hiding where
  icod_ :: Hiding -> S Word32
icod_ Hiding
Hidden                = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
  icod_ Hiding
NotHidden             = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
  icod_ (Instance Overlappable
NoOverlap)  = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2
  icod_ (Instance Overlappable
YesOverlap) = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
3

  value :: Word32 -> R Hiding
value Word32
0 = Hiding -> R Hiding
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Hiding
Hidden
  value Word32
1 = Hiding -> R Hiding
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Hiding
NotHidden
  value Word32
2 = Hiding -> R Hiding
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Overlappable -> Hiding
Instance Overlappable
NoOverlap)
  value Word32
3 = Hiding -> R Hiding
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Overlappable -> Hiding
Instance Overlappable
YesOverlap)
  value Word32
_ = R Hiding
forall a. R a
malformed

instance EmbPrj Q0Origin where
  icod_ :: Q0Origin -> S Word32
icod_ = \case
    Q0Origin
Q0Inferred -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
    Q0 Range
_       -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
    Q0Erased Range
_ -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2

  value :: Word32 -> R Q0Origin
value = \case
    Word32
0 -> Q0Origin -> R Q0Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Q0Origin -> R Q0Origin) -> Q0Origin -> R Q0Origin
forall a b. (a -> b) -> a -> b
$ Q0Origin
Q0Inferred
    Word32
1 -> Q0Origin -> R Q0Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Q0Origin -> R Q0Origin) -> Q0Origin -> R Q0Origin
forall a b. (a -> b) -> a -> b
$ Range -> Q0Origin
Q0       Range
forall a. Range' a
noRange
    Word32
2 -> Q0Origin -> R Q0Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Q0Origin -> R Q0Origin) -> Q0Origin -> R Q0Origin
forall a b. (a -> b) -> a -> b
$ Range -> Q0Origin
Q0Erased Range
forall a. Range' a
noRange
    Word32
_ -> R Q0Origin
forall a. R a
malformed

instance EmbPrj Q1Origin where
  icod_ :: Q1Origin -> S Word32
icod_ = \case
    Q1Origin
Q1Inferred -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
    Q1 Range
_       -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
    Q1Linear Range
_ -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2

  value :: Word32 -> R Q1Origin
value = \case
    Word32
0 -> Q1Origin -> R Q1Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Q1Origin -> R Q1Origin) -> Q1Origin -> R Q1Origin
forall a b. (a -> b) -> a -> b
$ Q1Origin
Q1Inferred
    Word32
1 -> Q1Origin -> R Q1Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Q1Origin -> R Q1Origin) -> Q1Origin -> R Q1Origin
forall a b. (a -> b) -> a -> b
$ Range -> Q1Origin
Q1       Range
forall a. Range' a
noRange
    Word32
2 -> Q1Origin -> R Q1Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Q1Origin -> R Q1Origin) -> Q1Origin -> R Q1Origin
forall a b. (a -> b) -> a -> b
$ Range -> Q1Origin
Q1Linear Range
forall a. Range' a
noRange
    Word32
_ -> R Q1Origin
forall a. R a
malformed

instance EmbPrj QωOrigin where
  icod_ :: QωOrigin -> S Word32
icod_ = \case
    QωOrigin
QωInferred -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
    Qω Range
_       -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
    QωPlenty Range
_ -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2

  value :: Word32 -> R QωOrigin
value = \case
    Word32
0 -> QωOrigin -> R QωOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (QωOrigin -> R QωOrigin) -> QωOrigin -> R QωOrigin
forall a b. (a -> b) -> a -> b
$ QωOrigin
QωInferred
    Word32
1 -> QωOrigin -> R QωOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (QωOrigin -> R QωOrigin) -> QωOrigin -> R QωOrigin
forall a b. (a -> b) -> a -> b
$ Range -> QωOrigin
Qω       Range
forall a. Range' a
noRange
    Word32
2 -> QωOrigin -> R QωOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (QωOrigin -> R QωOrigin) -> QωOrigin -> R QωOrigin
forall a b. (a -> b) -> a -> b
$ Range -> QωOrigin
QωPlenty Range
forall a. Range' a
noRange
    Word32
_ -> R QωOrigin
forall a. R a
malformed

instance EmbPrj Quantity where
  icod_ :: Quantity -> S Word32
icod_ = \case
    Quantity0 Q0Origin
a -> Word32
-> (Q0Origin -> Quantity)
-> Arrows (Domains (Q0Origin -> Quantity)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 Q0Origin -> Quantity
Quantity0 Q0Origin
a
    Quantity1 Q1Origin
a -> Word32
-> (Q1Origin -> Quantity)
-> Arrows (Domains (Q1Origin -> Quantity)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 Q1Origin -> Quantity
Quantity1 Q1Origin
a
    Quantityω QωOrigin
a -> (QωOrigin -> Quantity)
-> Arrows (Domains (QωOrigin -> Quantity)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN'  QωOrigin -> Quantity
Quantityω QωOrigin
a  -- default quantity, shorter code

  value :: Word32 -> R Quantity
value = ([Word32] -> R Quantity) -> Word32 -> R Quantity
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase (([Word32] -> R Quantity) -> Word32 -> R Quantity)
-> ([Word32] -> R Quantity) -> Word32 -> R Quantity
forall a b. (a -> b) -> a -> b
$ \case
    [Word32
0, Word32
a] -> (Q0Origin -> Quantity)
-> Arrows
     (Constant Word32 (Domains (Q0Origin -> Quantity)))
     (R (CoDomain (Q0Origin -> Quantity)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Q0Origin -> Quantity
Quantity0 Word32
a
    [Word32
1, Word32
a] -> (Q1Origin -> Quantity)
-> Arrows
     (Constant Word32 (Domains (Q1Origin -> Quantity)))
     (R (CoDomain (Q1Origin -> Quantity)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Q1Origin -> Quantity
Quantity1 Word32
a
    [Word32
a]    -> (QωOrigin -> Quantity)
-> Arrows
     (Constant Word32 (Domains (QωOrigin -> Quantity)))
     (R (CoDomain (QωOrigin -> Quantity)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN QωOrigin -> Quantity
Quantityω Word32
a
    [Word32]
_      -> R Quantity
forall a. R a
malformed

-- -- ALT: forget quantity origin when serializing?
-- instance EmbPrj Quantity where
--   icod_ Quantity0 = return 0
--   icod_ Quantity1 = return 1
--   icod_ Quantityω = return 2

--   value 0 = return Quantity0
--   value 1 = return Quantity1
--   value 2 = return Quantityω
--   value _ = malformed

instance EmbPrj Cohesion where
  icod_ :: Cohesion -> S Word32
icod_ Cohesion
Flat       = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
  icod_ Cohesion
Continuous = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
  icod_ Cohesion
Squash     = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2

  value :: Word32 -> R Cohesion
value Word32
0 = Cohesion -> R Cohesion
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Cohesion
Flat
  value Word32
1 = Cohesion -> R Cohesion
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Cohesion
Continuous
  value Word32
2 = Cohesion -> R Cohesion
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Cohesion
Squash
  value Word32
_ = R Cohesion
forall a. R a
malformed

instance EmbPrj ModalPolarity where
  icod_ :: ModalPolarity -> S Word32
icod_ ModalPolarity
UnusedPolarity = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
  icod_ ModalPolarity
StrictlyPositive = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
  icod_ ModalPolarity
Positive = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2
  icod_ ModalPolarity
Negative = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
3
  icod_ ModalPolarity
MixedPolarity = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
4

  value :: Word32 -> R ModalPolarity
value Word32
0 = ModalPolarity -> R ModalPolarity
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ModalPolarity
UnusedPolarity
  value Word32
1 = ModalPolarity -> R ModalPolarity
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ModalPolarity
StrictlyPositive
  value Word32
2 = ModalPolarity -> R ModalPolarity
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ModalPolarity
Positive
  value Word32
3 = ModalPolarity -> R ModalPolarity
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ModalPolarity
Negative
  value Word32
4 = ModalPolarity -> R ModalPolarity
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ModalPolarity
MixedPolarity
  value Word32
_ = R ModalPolarity
forall a. R a
malformed

instance EmbPrj PolarityModality where
  icod_ :: PolarityModality -> S Word32
icod_ (PolarityModality ModalPolarity
p ModalPolarity
o ModalPolarity
l) = (ModalPolarity, ModalPolarity, ModalPolarity) -> S Word32
forall a. EmbPrj a => a -> S Word32
icod_ (ModalPolarity
p, ModalPolarity
o, ModalPolarity
l)

  value :: Word32 -> R PolarityModality
value Word32
n = do
    (p, o, l) <- R (ModalPolarity, ModalPolarity, ModalPolarity)
polPair
    return $ PolarityModality p o l
    where
      polPair :: R (ModalPolarity, ModalPolarity, ModalPolarity)
      polPair :: R (ModalPolarity, ModalPolarity, ModalPolarity)
polPair = Word32 -> R (ModalPolarity, ModalPolarity, ModalPolarity)
forall a. EmbPrj a => Word32 -> R a
value Word32
n

instance EmbPrj Modality where
  icod_ :: Modality -> S Word32
icod_ (Modality Relevance
a Quantity
b Cohesion
c PolarityModality
d) = (Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality)
-> Arrows
     (Domains
        (Relevance
         -> Quantity -> Cohesion -> PolarityModality -> Modality))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
Modality Relevance
a Quantity
b Cohesion
c PolarityModality
d

  value :: Word32 -> R Modality
value = ([Word32] -> R Modality) -> Word32 -> R Modality
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase (([Word32] -> R Modality) -> Word32 -> R Modality)
-> ([Word32] -> R Modality) -> Word32 -> R Modality
forall a b. (a -> b) -> a -> b
$ \case
    [Word32
a, Word32
b, Word32
c, Word32
d] -> (Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality)
-> Arrows
     (Constant
        Word32
        (Domains
           (Relevance
            -> Quantity -> Cohesion -> PolarityModality -> Modality)))
     (R (CoDomain
           (Relevance
            -> Quantity -> Cohesion -> PolarityModality -> Modality)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Relevance -> Quantity -> Cohesion -> PolarityModality -> Modality
Modality Word32
a Word32
b Word32
c Word32
d
    [Word32]
_ -> R Modality
forall a. R a
malformed

instance EmbPrj OriginRelevant where
  icod_ :: OriginRelevant -> S Word32
icod_ = \case
    OriginRelevant
ORelInferred   -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
    ORelRelevant Range
_ -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1

  value :: Word32 -> R OriginRelevant
value = \case
    Word32
0 -> OriginRelevant -> R OriginRelevant
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (OriginRelevant -> R OriginRelevant)
-> OriginRelevant -> R OriginRelevant
forall a b. (a -> b) -> a -> b
$ OriginRelevant
ORelInferred
    Word32
1 -> OriginRelevant -> R OriginRelevant
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (OriginRelevant -> R OriginRelevant)
-> OriginRelevant -> R OriginRelevant
forall a b. (a -> b) -> a -> b
$ Range -> OriginRelevant
ORelRelevant Range
forall a. Range' a
noRange
    Word32
_ -> R OriginRelevant
forall a. R a
malformed

instance EmbPrj OriginIrrelevant where
  icod_ :: OriginIrrelevant -> S Word32
icod_ = \case
    OriginIrrelevant
OIrrInferred     -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
    OIrrDot Range
_        -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
    OIrrIrr Range
_        -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2
    OIrrIrrelevant Range
_ -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
3

  value :: Word32 -> R OriginIrrelevant
value = \case
    Word32
0 -> OriginIrrelevant -> R OriginIrrelevant
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (OriginIrrelevant -> R OriginIrrelevant)
-> OriginIrrelevant -> R OriginIrrelevant
forall a b. (a -> b) -> a -> b
$ OriginIrrelevant
OIrrInferred
    Word32
1 -> OriginIrrelevant -> R OriginIrrelevant
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (OriginIrrelevant -> R OriginIrrelevant)
-> OriginIrrelevant -> R OriginIrrelevant
forall a b. (a -> b) -> a -> b
$ Range -> OriginIrrelevant
OIrrDot        Range
forall a. Range' a
noRange
    Word32
2 -> OriginIrrelevant -> R OriginIrrelevant
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (OriginIrrelevant -> R OriginIrrelevant)
-> OriginIrrelevant -> R OriginIrrelevant
forall a b. (a -> b) -> a -> b
$ Range -> OriginIrrelevant
OIrrIrr        Range
forall a. Range' a
noRange
    Word32
3 -> OriginIrrelevant -> R OriginIrrelevant
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (OriginIrrelevant -> R OriginIrrelevant)
-> OriginIrrelevant -> R OriginIrrelevant
forall a b. (a -> b) -> a -> b
$ Range -> OriginIrrelevant
OIrrIrrelevant Range
forall a. Range' a
noRange
    Word32
_ -> R OriginIrrelevant
forall a. R a
malformed

instance EmbPrj OriginShapeIrrelevant where
  icod_ :: OriginShapeIrrelevant -> S Word32
icod_ = \case
    OriginShapeIrrelevant
OShIrrInferred          -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
    OShIrrDotDot Range
_          -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
    OShIrrShIrr Range
_           -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2
    OShIrrShapeIrrelevant Range
_ -> Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
3

  value :: Word32 -> R OriginShapeIrrelevant
value = \case
    Word32
0 -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (OriginShapeIrrelevant -> R OriginShapeIrrelevant)
-> OriginShapeIrrelevant -> R OriginShapeIrrelevant
forall a b. (a -> b) -> a -> b
$ OriginShapeIrrelevant
OShIrrInferred
    Word32
1 -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (OriginShapeIrrelevant -> R OriginShapeIrrelevant)
-> OriginShapeIrrelevant -> R OriginShapeIrrelevant
forall a b. (a -> b) -> a -> b
$ Range -> OriginShapeIrrelevant
OShIrrDotDot          Range
forall a. Range' a
noRange
    Word32
2 -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (OriginShapeIrrelevant -> R OriginShapeIrrelevant)
-> OriginShapeIrrelevant -> R OriginShapeIrrelevant
forall a b. (a -> b) -> a -> b
$ Range -> OriginShapeIrrelevant
OShIrrShIrr           Range
forall a. Range' a
noRange
    Word32
3 -> OriginShapeIrrelevant -> R OriginShapeIrrelevant
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (OriginShapeIrrelevant -> R OriginShapeIrrelevant)
-> OriginShapeIrrelevant -> R OriginShapeIrrelevant
forall a b. (a -> b) -> a -> b
$ Range -> OriginShapeIrrelevant
OShIrrShapeIrrelevant Range
forall a. Range' a
noRange
    Word32
_ -> R OriginShapeIrrelevant
forall a. R a
malformed

instance EmbPrj Relevance where
  icod_ :: Relevance -> S Word32
icod_ = \case
    Relevant   OriginRelevant
a      -> (OriginRelevant -> Relevance)
-> Arrows (Domains (OriginRelevant -> Relevance)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' OriginRelevant -> Relevance
Relevant OriginRelevant
a
    Irrelevant OriginIrrelevant
a      -> Word32
-> (OriginIrrelevant -> Relevance)
-> Arrows (Domains (OriginIrrelevant -> Relevance)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 OriginIrrelevant -> Relevance
Irrelevant OriginIrrelevant
a
    ShapeIrrelevant OriginShapeIrrelevant
a -> Word32
-> (OriginShapeIrrelevant -> Relevance)
-> Arrows (Domains (OriginShapeIrrelevant -> Relevance)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 OriginShapeIrrelevant -> Relevance
ShapeIrrelevant OriginShapeIrrelevant
a

  value :: Word32 -> R Relevance
value = ([Word32] -> R Relevance) -> Word32 -> R Relevance
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase \case
    [Word32
a]    -> (OriginRelevant -> Relevance)
-> Arrows
     (Constant Word32 (Domains (OriginRelevant -> Relevance)))
     (R (CoDomain (OriginRelevant -> Relevance)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN OriginRelevant -> Relevance
Relevant Word32
a
    [Word32
0, Word32
a] -> (OriginIrrelevant -> Relevance)
-> Arrows
     (Constant Word32 (Domains (OriginIrrelevant -> Relevance)))
     (R (CoDomain (OriginIrrelevant -> Relevance)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN OriginIrrelevant -> Relevance
Irrelevant Word32
a
    [Word32
1, Word32
a] -> (OriginShapeIrrelevant -> Relevance)
-> Arrows
     (Constant Word32 (Domains (OriginShapeIrrelevant -> Relevance)))
     (R (CoDomain (OriginShapeIrrelevant -> Relevance)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN OriginShapeIrrelevant -> Relevance
ShapeIrrelevant Word32
a
    [Word32]
_      -> R Relevance
forall a. R a
malformed

instance EmbPrj Annotation where
  icod_ :: Annotation -> S Word32
icod_ (Annotation Lock
l) = (Lock -> Annotation)
-> Arrows (Domains (Lock -> Annotation)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Lock -> Annotation
Annotation Lock
l

  value :: Word32 -> R Annotation
value = (Lock -> Annotation) -> Word32 -> R (CoDomain (Lock -> Annotation))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Lock -> Annotation
Annotation

instance EmbPrj Lock where
  icod_ :: Lock -> S Word32
icod_ Lock
IsNotLock          = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
0
  icod_ (IsLock LockOrigin
LockOTick) = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
1
  icod_ (IsLock LockOrigin
LockOLock) = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word32
2

  value :: Word32 -> R Lock
value Word32
0 = Lock -> R Lock
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Lock
IsNotLock
  value Word32
1 = Lock -> R Lock
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (LockOrigin -> Lock
IsLock LockOrigin
LockOTick)
  value Word32
2 = Lock -> R Lock
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (LockOrigin -> Lock
IsLock LockOrigin
LockOLock)
  value Word32
_ = R Lock
forall a. R a
malformed

instance EmbPrj Origin where
  icod_ :: Origin -> S Word32
icod_ Origin
UserWritten = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
  icod_ Origin
Inserted    = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
  icod_ Origin
Reflected   = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2
  icod_ Origin
CaseSplit   = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
3
  icod_ Origin
Substitution = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
4
  icod_ Origin
ExpandedPun = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
5
  icod_ Origin
Generalization = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
6

  value :: Word32 -> R Origin
value Word32
0 = Origin -> R Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Origin
UserWritten
  value Word32
1 = Origin -> R Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Origin
Inserted
  value Word32
2 = Origin -> R Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Origin
Reflected
  value Word32
3 = Origin -> R Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Origin
CaseSplit
  value Word32
4 = Origin -> R Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Origin
Substitution
  value Word32
5 = Origin -> R Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Origin
ExpandedPun
  value Word32
6 = Origin -> R Origin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Origin
Generalization
  value Word32
_ = R Origin
forall a. R a
malformed

instance EmbPrj a => EmbPrj (WithOrigin a) where
  icod_ :: WithOrigin a -> S Word32
icod_ (WithOrigin Origin
a a
b) = (Origin -> a -> WithOrigin a)
-> Arrows (Domains (Origin -> a -> WithOrigin a)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Origin -> a -> WithOrigin a
forall a. Origin -> a -> WithOrigin a
WithOrigin Origin
a a
b

  value :: Word32 -> R (WithOrigin a)
value = (Origin -> a -> WithOrigin a)
-> Word32 -> R (CoDomain (Origin -> a -> WithOrigin a))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Origin -> a -> WithOrigin a
forall a. Origin -> a -> WithOrigin a
WithOrigin

instance EmbPrj FreeVariables where
  icod_ :: FreeVariables -> S Word32
icod_ FreeVariables
UnknownFVs   = FreeVariables -> Arrows (Domains FreeVariables) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' FreeVariables
UnknownFVs
  icod_ (KnownFVs VarSet
a) = (VarSet -> FreeVariables)
-> Arrows (Domains (VarSet -> FreeVariables)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' VarSet -> FreeVariables
KnownFVs VarSet
a

  value :: Word32 -> R FreeVariables
value = ([Word32] -> R FreeVariables) -> Word32 -> R FreeVariables
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R FreeVariables
valu where
    valu :: [Word32]
-> Arrows
     (Constant Word32 (Domains FreeVariables))
     (R (CoDomain FreeVariables))
valu []  = FreeVariables
-> Arrows
     (Constant Word32 (Domains FreeVariables))
     (R (CoDomain FreeVariables))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN FreeVariables
UnknownFVs
    valu [Word32
a] = (VarSet -> FreeVariables)
-> Arrows
     (Constant Word32 (Domains (VarSet -> FreeVariables)))
     (R (CoDomain (VarSet -> FreeVariables)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN VarSet -> FreeVariables
KnownFVs Word32
a
    valu [Word32]
_   = R FreeVariables
Arrows
  (Constant Word32 (Domains FreeVariables))
  (R (CoDomain FreeVariables))
forall a. R a
malformed

instance EmbPrj ConOrigin where
  icod_ :: ConOrigin -> S Word32
icod_ ConOrigin
ConOSystem   = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
  icod_ ConOrigin
ConOCon      = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
  icod_ ConOrigin
ConORec      = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2
  icod_ ConOrigin
ConOSplit    = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
3
  icod_ ConOrigin
ConORecWhere = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
4

  value :: Word32 -> R ConOrigin
value Word32
0 = ConOrigin -> R ConOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ConOrigin
ConOSystem
  value Word32
1 = ConOrigin -> R ConOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ConOrigin
ConOCon
  value Word32
2 = ConOrigin -> R ConOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ConOrigin
ConORec
  value Word32
3 = ConOrigin -> R ConOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ConOrigin
ConOSplit
  value Word32
4 = ConOrigin -> R ConOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ConOrigin
ConORecWhere
  value Word32
_ = R ConOrigin
forall a. R a
malformed

instance EmbPrj ProjOrigin where
  icod_ :: ProjOrigin -> S Word32
icod_ ProjOrigin
ProjPrefix  = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
0
  icod_ ProjOrigin
ProjPostfix = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
1
  icod_ ProjOrigin
ProjSystem  = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
2

  value :: Word32 -> R ProjOrigin
value Word32
0 = ProjOrigin -> R ProjOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjOrigin
ProjPrefix
  value Word32
1 = ProjOrigin -> R ProjOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjOrigin
ProjPostfix
  value Word32
2 = ProjOrigin -> R ProjOrigin
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ProjOrigin
ProjSystem
  value Word32
_ = R ProjOrigin
forall a. R a
malformed

instance EmbPrj Agda.Syntax.Literal.Literal where
  icod_ :: Literal -> S Word32
icod_ (LitNat    Integer
a)   = (Integer -> Literal)
-> Arrows (Domains (Integer -> Literal)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Integer -> Literal
LitNat Integer
a
  icod_ (LitFloat  PrecedenceLevel
a)   = Word32
-> (PrecedenceLevel -> Literal)
-> Arrows (Domains (PrecedenceLevel -> Literal)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 PrecedenceLevel -> Literal
LitFloat PrecedenceLevel
a
  icod_ (LitString Text
a)   = Word32
-> (Text -> Literal)
-> Arrows (Domains (Text -> Literal)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
2 Text -> Literal
LitString Text
a
  icod_ (LitChar   Char
a)   = Word32
-> (Char -> Literal)
-> Arrows (Domains (Char -> Literal)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
3 Char -> Literal
LitChar Char
a
  icod_ (LitQName  QName
a)   = Word32
-> (QName -> Literal)
-> Arrows (Domains (QName -> Literal)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
5 QName -> Literal
LitQName QName
a
  icod_ (LitMeta   TopLevelModuleName
a MetaId
b) = Word32
-> (TopLevelModuleName -> MetaId -> Literal)
-> Arrows
     (Domains (TopLevelModuleName -> MetaId -> Literal)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
6 TopLevelModuleName -> MetaId -> Literal
LitMeta TopLevelModuleName
a MetaId
b
  icod_ (LitWord64 Word64
a)   = Word32
-> (Word64 -> Literal)
-> Arrows (Domains (Word64 -> Literal)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
7 Word64 -> Literal
LitWord64 Word64
a

  value :: Word32 -> R Literal
value = ([Word32] -> R Literal) -> Word32 -> R Literal
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R Literal
valu where
    valu :: [Word32] -> R Literal
valu [Word32
a]       = (Integer -> Literal)
-> Arrows
     (Constant Word32 (Domains (Integer -> Literal)))
     (R (CoDomain (Integer -> Literal)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Integer -> Literal
LitNat    Word32
a
    valu [Word32
1, Word32
a]    = (PrecedenceLevel -> Literal)
-> Arrows
     (Constant Word32 (Domains (PrecedenceLevel -> Literal)))
     (R (CoDomain (PrecedenceLevel -> Literal)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN PrecedenceLevel -> Literal
LitFloat  Word32
a
    valu [Word32
2, Word32
a]    = (Text -> Literal)
-> Arrows
     (Constant Word32 (Domains (Text -> Literal)))
     (R (CoDomain (Text -> Literal)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Text -> Literal
LitString Word32
a
    valu [Word32
3, Word32
a]    = (Char -> Literal)
-> Arrows
     (Constant Word32 (Domains (Char -> Literal)))
     (R (CoDomain (Char -> Literal)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Char -> Literal
LitChar   Word32
a
    valu [Word32
5, Word32
a]    = (QName -> Literal)
-> Arrows
     (Constant Word32 (Domains (QName -> Literal)))
     (R (CoDomain (QName -> Literal)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN QName -> Literal
LitQName  Word32
a
    valu [Word32
6, Word32
a, Word32
b] = (TopLevelModuleName -> MetaId -> Literal)
-> Arrows
     (Constant
        Word32 (Domains (TopLevelModuleName -> MetaId -> Literal)))
     (R (CoDomain (TopLevelModuleName -> MetaId -> Literal)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN TopLevelModuleName -> MetaId -> Literal
LitMeta   Word32
a Word32
b
    valu [Word32
7, Word32
a]    = (Word64 -> Literal)
-> Arrows
     (Constant Word32 (Domains (Word64 -> Literal)))
     (R (CoDomain (Word64 -> Literal)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Word64 -> Literal
LitWord64 Word32
a
    valu [Word32]
_            = R Literal
forall a. R a
malformed

instance EmbPrj IsAbstract where
  icod_ :: IsAbstract -> S Word32
icod_ IsAbstract
AbstractDef = Word32 -> IsAbstract -> Arrows (Domains IsAbstract) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 IsAbstract
AbstractDef
  icod_ IsAbstract
ConcreteDef = IsAbstract -> Arrows (Domains IsAbstract) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' IsAbstract
ConcreteDef

  value :: Word32 -> R IsAbstract
value = ([Word32] -> R IsAbstract) -> Word32 -> R IsAbstract
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R IsAbstract
forall {a}. (Eq a, Num a) => [a] -> R IsAbstract
valu where
    valu :: [a]
-> Arrows
     (Constant Word32 (Domains IsAbstract)) (R (CoDomain IsAbstract))
valu [a
0] = IsAbstract
-> Arrows
     (Constant Word32 (Domains IsAbstract)) (R (CoDomain IsAbstract))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN IsAbstract
AbstractDef
    valu []  = IsAbstract
-> Arrows
     (Constant Word32 (Domains IsAbstract)) (R (CoDomain IsAbstract))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN IsAbstract
ConcreteDef
    valu [a]
_   = R IsAbstract
Arrows
  (Constant Word32 (Domains IsAbstract)) (R (CoDomain IsAbstract))
forall a. R a
malformed

instance EmbPrj IsOpaque where
  icod_ :: IsOpaque -> S Word32
icod_ (OpaqueDef OpaqueId
a)  = (OpaqueId -> IsOpaque)
-> Arrows (Domains (OpaqueId -> IsOpaque)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' OpaqueId -> IsOpaque
OpaqueDef OpaqueId
a
  icod_ IsOpaque
TransparentDef = IsOpaque -> Arrows (Domains IsOpaque) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' IsOpaque
TransparentDef

  value :: Word32 -> R IsOpaque
value = ([Word32] -> R IsOpaque) -> Word32 -> R IsOpaque
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R IsOpaque
valu where
    valu :: [Word32] -> R IsOpaque
valu [Word32
a] = (OpaqueId -> IsOpaque)
-> Arrows
     (Constant Word32 (Domains (OpaqueId -> IsOpaque)))
     (R (CoDomain (OpaqueId -> IsOpaque)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN OpaqueId -> IsOpaque
OpaqueDef Word32
a
    valu []  = IsOpaque
-> Arrows
     (Constant Word32 (Domains IsOpaque)) (R (CoDomain IsOpaque))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN IsOpaque
TransparentDef
    valu [Word32]
_   = R IsOpaque
forall a. R a
malformed

instance EmbPrj SrcLoc where
  icod_ :: SrcLoc -> S Word32
icod_ (SrcLoc String
p String
m String
f Int
sl Int
sc Int
el Int
ec) = (String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc)
-> Arrows
     (Domains
        (String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc
SrcLoc String
p String
m String
f Int
sl Int
sc Int
el Int
ec
  value :: Word32 -> R SrcLoc
value = (String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc)
-> Word32
-> R (CoDomain
        (String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN String -> String -> String -> Int -> Int -> Int -> Int -> SrcLoc
SrcLoc

instance EmbPrj CallStack where
  icod_ :: CallStack -> S Word32
icod_ = [(String, SrcLoc)] -> S Word32
forall a. EmbPrj a => a -> S Word32
icode ([(String, SrcLoc)] -> S Word32)
-> (CallStack -> [(String, SrcLoc)]) -> CallStack -> S Word32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CallStack -> [(String, SrcLoc)]
getCallStack
  value :: Word32 -> R CallStack
value = ([(String, SrcLoc)] -> CallStack)
-> StateT St IO [(String, SrcLoc)] -> R CallStack
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
(<$!>) [(String, SrcLoc)] -> CallStack
fromCallSiteList (StateT St IO [(String, SrcLoc)] -> R CallStack)
-> (Word32 -> StateT St IO [(String, SrcLoc)])
-> Word32
-> R CallStack
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> StateT St IO [(String, SrcLoc)]
forall a. EmbPrj a => Word32 -> R a
value

instance EmbPrj Impossible where
  icod_ :: Impossible -> S Word32
icod_ (Impossible CallStack
a)              = Word32
-> (CallStack -> Impossible)
-> Arrows (Domains (CallStack -> Impossible)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 CallStack -> Impossible
Impossible CallStack
a
  icod_ (Unreachable CallStack
a)             = Word32
-> (CallStack -> Impossible)
-> Arrows (Domains (CallStack -> Impossible)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 CallStack -> Impossible
Unreachable CallStack
a
  icod_ (ImpMissingDefinitions [String]
a String
b) = Word32
-> ([String] -> String -> Impossible)
-> Arrows (Domains ([String] -> String -> Impossible)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
2 [String] -> String -> Impossible
ImpMissingDefinitions [String]
a String
b

  value :: Word32 -> R Impossible
value = ([Word32] -> R Impossible) -> Word32 -> R Impossible
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R Impossible
valu where
    valu :: [Word32] -> R Impossible
valu [Word32
0, Word32
a]    = (CallStack -> Impossible)
-> Arrows
     (Constant Word32 (Domains (CallStack -> Impossible)))
     (R (CoDomain (CallStack -> Impossible)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN CallStack -> Impossible
Impossible  Word32
a
    valu [Word32
1, Word32
a]    = (CallStack -> Impossible)
-> Arrows
     (Constant Word32 (Domains (CallStack -> Impossible)))
     (R (CoDomain (CallStack -> Impossible)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN CallStack -> Impossible
Unreachable Word32
a
    valu [Word32
2, Word32
a, Word32
b] = ([String] -> String -> Impossible)
-> Arrows
     (Constant Word32 (Domains ([String] -> String -> Impossible)))
     (R (CoDomain ([String] -> String -> Impossible)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN [String] -> String -> Impossible
ImpMissingDefinitions Word32
a Word32
b
    valu [Word32]
_         = R Impossible
forall a. R a
malformed

instance EmbPrj ExpandedEllipsis where
  icod_ :: ExpandedEllipsis -> S Word32
icod_ ExpandedEllipsis
NoEllipsis = ExpandedEllipsis -> Arrows (Domains ExpandedEllipsis) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' ExpandedEllipsis
NoEllipsis
  icod_ (ExpandedEllipsis Range
a Int
b) = Word32
-> (Range -> Int -> ExpandedEllipsis)
-> Arrows (Domains (Range -> Int -> ExpandedEllipsis)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 Range -> Int -> ExpandedEllipsis
ExpandedEllipsis Range
a Int
b

  value :: Word32 -> R ExpandedEllipsis
value = ([Word32] -> R ExpandedEllipsis) -> Word32 -> R ExpandedEllipsis
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R ExpandedEllipsis
valu where
    valu :: [Word32]
-> Arrows
     (Constant Word32 (Domains ExpandedEllipsis))
     (R (CoDomain ExpandedEllipsis))
valu []      = ExpandedEllipsis
-> Arrows
     (Constant Word32 (Domains ExpandedEllipsis))
     (R (CoDomain ExpandedEllipsis))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN ExpandedEllipsis
NoEllipsis
    valu [Word32
1,Word32
a,Word32
b] = (Range -> Int -> ExpandedEllipsis)
-> Arrows
     (Constant Word32 (Domains (Range -> Int -> ExpandedEllipsis)))
     (R (CoDomain (Range -> Int -> ExpandedEllipsis)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Range -> Int -> ExpandedEllipsis
ExpandedEllipsis Word32
a Word32
b
    valu [Word32]
_       = R ExpandedEllipsis
Arrows
  (Constant Word32 (Domains ExpandedEllipsis))
  (R (CoDomain ExpandedEllipsis))
forall a. R a
malformed

instance EmbPrj OptionsPragma where
  icod_ :: OptionsPragma -> S Word32
icod_ (OptionsPragma [String]
a Range
b) = ([String], Range) -> S Word32
forall a. EmbPrj a => a -> S Word32
icod_ ([String]
a, Range
b)

  value :: Word32 -> R OptionsPragma
value Word32
op = ([String] -> Range -> OptionsPragma)
-> ([String], Range) -> OptionsPragma
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry [String] -> Range -> OptionsPragma
OptionsPragma (([String], Range) -> OptionsPragma)
-> StateT St IO ([String], Range) -> R OptionsPragma
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> StateT St IO ([String], Range)
forall a. EmbPrj a => Word32 -> R a
value Word32
op

instance EmbPrj BuiltinId
instance EmbPrj PrimitiveId

instance EmbPrj SomeBuiltin where
  icod_ :: SomeBuiltin -> S Word32
icod_ (BuiltinName BuiltinId
x)   = Word32
-> (BuiltinId -> SomeBuiltin)
-> Arrows (Domains (BuiltinId -> SomeBuiltin)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 BuiltinId -> SomeBuiltin
BuiltinName BuiltinId
x
  icod_ (PrimitiveName PrimitiveId
x) = Word32
-> (PrimitiveId -> SomeBuiltin)
-> Arrows (Domains (PrimitiveId -> SomeBuiltin)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 PrimitiveId -> SomeBuiltin
PrimitiveName PrimitiveId
x

  value :: Word32 -> R SomeBuiltin
value = ([Word32] -> R SomeBuiltin) -> Word32 -> R SomeBuiltin
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R SomeBuiltin
valu where
    valu :: [Word32] -> R SomeBuiltin
valu [Word32
0, Word32
x] = (BuiltinId -> SomeBuiltin)
-> Arrows
     (Constant Word32 (Domains (BuiltinId -> SomeBuiltin)))
     (R (CoDomain (BuiltinId -> SomeBuiltin)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN BuiltinId -> SomeBuiltin
BuiltinName Word32
x
    valu [Word32
1, Word32
x] = (PrimitiveId -> SomeBuiltin)
-> Arrows
     (Constant Word32 (Domains (PrimitiveId -> SomeBuiltin)))
     (R (CoDomain (PrimitiveId -> SomeBuiltin)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN PrimitiveId -> SomeBuiltin
PrimitiveName Word32
x
    valu [Word32]
_      = R SomeBuiltin
forall a. R a
malformed

instance EmbPrj IsInstance where
  icod_ :: IsInstance -> S Word32
icod_ = \case
    InstanceDef KwRange
a  -> (KwRange -> IsInstance)
-> Arrows (Domains (KwRange -> IsInstance)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' KwRange -> IsInstance
InstanceDef KwRange
a
    IsInstance
NotInstanceDef -> IsInstance -> Arrows (Domains IsInstance) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' IsInstance
NotInstanceDef

  value :: Word32 -> R IsInstance
value = ([Word32] -> R IsInstance) -> Word32 -> R IsInstance
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase \case
    [Word32
a] -> (KwRange -> IsInstance)
-> Arrows
     (Constant Word32 (Domains (KwRange -> IsInstance)))
     (R (CoDomain (KwRange -> IsInstance)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN KwRange -> IsInstance
InstanceDef Word32
a
    []  -> IsInstance
-> Arrows
     (Constant Word32 (Domains IsInstance)) (R (CoDomain IsInstance))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN IsInstance
NotInstanceDef
    [Word32]
_ -> R IsInstance
forall a. R a
malformed

instance EmbPrj a => EmbPrj (RecordDirectives' a) where
  icod_ :: RecordDirectives' a -> S Word32
icod_ (RecordDirectives Maybe (Ranged Induction)
a Maybe (Ranged HasEta0)
b Maybe Range
c a
d) = (Maybe (Ranged Induction)
 -> Maybe (Ranged HasEta0)
 -> Maybe Range
 -> a
 -> RecordDirectives' a)
-> Arrows
     (Domains
        (Maybe (Ranged Induction)
         -> Maybe (Ranged HasEta0)
         -> Maybe Range
         -> a
         -> RecordDirectives' a))
     (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Maybe (Ranged Induction)
-> Maybe (Ranged HasEta0)
-> Maybe Range
-> a
-> RecordDirectives' a
forall a.
Maybe (Ranged Induction)
-> Maybe (Ranged HasEta0)
-> Maybe Range
-> a
-> RecordDirectives' a
RecordDirectives Maybe (Ranged Induction)
a Maybe (Ranged HasEta0)
b Maybe Range
c a
d

  value :: Word32 -> R (RecordDirectives' a)
value = ([Word32] -> R (RecordDirectives' a))
-> Word32 -> R (RecordDirectives' a)
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase \case
    [Word32
a, Word32
b, Word32
c, Word32
d] -> (Maybe (Ranged Induction)
 -> Maybe (Ranged HasEta0)
 -> Maybe Range
 -> a
 -> RecordDirectives' a)
-> Arrows
     (Constant
        Word32
        (Domains
           (Maybe (Ranged Induction)
            -> Maybe (Ranged HasEta0)
            -> Maybe Range
            -> a
            -> RecordDirectives' a)))
     (R (CoDomain
           (Maybe (Ranged Induction)
            -> Maybe (Ranged HasEta0)
            -> Maybe Range
            -> a
            -> RecordDirectives' a)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Maybe (Ranged Induction)
-> Maybe (Ranged HasEta0)
-> Maybe Range
-> a
-> RecordDirectives' a
forall a.
Maybe (Ranged Induction)
-> Maybe (Ranged HasEta0)
-> Maybe Range
-> a
-> RecordDirectives' a
RecordDirectives Word32
a Word32
b Word32
c Word32
d
    [Word32]
_ -> R (RecordDirectives' a)
forall a. R a
malformed

instance EmbPrj RecordDirective where
  icod_ :: RecordDirective -> S Word32
icod_ = \case
    Constructor Name
a IsInstance
b      -> Word32
-> (Name -> IsInstance -> RecordDirective)
-> Arrows
     (Domains (Name -> IsInstance -> RecordDirective)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
0 Name -> IsInstance -> RecordDirective
Constructor Name
a IsInstance
b
    Eta Ranged HasEta0
a                -> Word32
-> (Ranged HasEta0 -> RecordDirective)
-> Arrows (Domains (Ranged HasEta0 -> RecordDirective)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
1 Ranged HasEta0 -> RecordDirective
Eta Ranged HasEta0
a
    Induction Ranged Induction
a          -> Word32
-> (Ranged Induction -> RecordDirective)
-> Arrows
     (Domains (Ranged Induction -> RecordDirective)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
2 Ranged Induction -> RecordDirective
Induction Ranged Induction
a
    PatternOrCopattern Range
a -> Word32
-> (Range -> RecordDirective)
-> Arrows (Domains (Range -> RecordDirective)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
Word32 -> t -> Arrows (Domains t) (S Word32)
icodeN Word32
3 Range -> RecordDirective
PatternOrCopattern Range
a

  value :: Word32 -> R RecordDirective
value = ([Word32] -> R RecordDirective) -> Word32 -> R RecordDirective
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase \case
    [Word32
0, Word32
a, Word32
b] -> (Name -> IsInstance -> RecordDirective)
-> Arrows
     (Constant Word32 (Domains (Name -> IsInstance -> RecordDirective)))
     (R (CoDomain (Name -> IsInstance -> RecordDirective)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Name -> IsInstance -> RecordDirective
Constructor Word32
a Word32
b
    [Word32
1, Word32
a]    -> (Ranged HasEta0 -> RecordDirective)
-> Arrows
     (Constant Word32 (Domains (Ranged HasEta0 -> RecordDirective)))
     (R (CoDomain (Ranged HasEta0 -> RecordDirective)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Ranged HasEta0 -> RecordDirective
Eta Word32
a
    [Word32
2, Word32
a]    -> (Ranged Induction -> RecordDirective)
-> Arrows
     (Constant Word32 (Domains (Ranged Induction -> RecordDirective)))
     (R (CoDomain (Ranged Induction -> RecordDirective)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Ranged Induction -> RecordDirective
Induction Word32
a
    [Word32
3, Word32
a]    -> (Range -> RecordDirective)
-> Arrows
     (Constant Word32 (Domains (Range -> RecordDirective)))
     (R (CoDomain (Range -> RecordDirective)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Range -> RecordDirective
PatternOrCopattern Word32
a
    [Word32]
_ -> R RecordDirective
forall a. R a
malformed

instance EmbPrj Catchall where
  icod_ :: Catchall -> S Word32
icod_ Catchall
NoCatchall  = Catchall -> Arrows (Domains Catchall) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Catchall
NoCatchall
  icod_ (YesCatchall Range
x) = (Range -> Catchall)
-> Arrows (Domains (Range -> Catchall)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' Range -> Catchall
YesCatchall Range
x

  value :: Word32 -> R Catchall
value = ([Word32] -> R Catchall) -> Word32 -> R Catchall
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R Catchall
valu where
    valu :: [Word32]
-> Arrows
     (Constant Word32 (Domains Catchall)) (R (CoDomain Catchall))
valu []  = Catchall
-> Arrows
     (Constant Word32 (Domains Catchall)) (R (CoDomain Catchall))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Catchall
NoCatchall
    valu [Word32
x] = (Range -> Catchall)
-> Arrows
     (Constant Word32 (Domains (Range -> Catchall)))
     (R (CoDomain (Range -> Catchall)))
forall t.
(VALU t (IsBase t),
 StrictCurrying (Constant Word32 (Domains t)) (R (CoDomain t)),
 All EmbPrj (Domains t)) =>
t -> Arrows (Constant Word32 (Domains t)) (R (CoDomain t))
valuN Range -> Catchall
YesCatchall Word32
x
    valu [Word32]
_   = R Catchall
Arrows (Constant Word32 (Domains Catchall)) (R (CoDomain Catchall))
forall a. R a
malformed