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

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.Except       ( MonadError(..) )
import Control.Monad.Reader       ( MonadReader(..), asks )
import Control.Monad.State        ( runStateT )
import Control.Monad.State.Strict ( gets, modify )

import Data.Array.IArray
import qualified Data.Foldable as Fold
import Data.Hashable
import Data.HashMap.Strict (HashMap)
import qualified Data.HashMap.Strict as HMap
import Data.Int (Int32)
import Data.IntSet (IntSet)
import qualified Data.IntSet as IntSet
import Data.Map (Map)
import qualified Data.Map as Map
import Data.Sequence (Seq)
import qualified Data.Sequence as Seq
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Strict.Tuple (Pair(..))
import qualified Data.Text      as T
import qualified Data.Text.Lazy as TL
import Data.Typeable
import Data.Void
import Data.Word (Word32, Word64)

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.Utils.BiMap (BiMap)
import qualified Agda.Utils.BiMap as BiMap
import Agda.Utils.FileId (getIdFile)
import Agda.Utils.List1 (List1)
import qualified Agda.Utils.List1 as List1
import Agda.Utils.List2 (List2(List2))
import qualified Agda.Utils.List2 as List2
import qualified Agda.Utils.Maybe.Strict as Strict
import Agda.Utils.Null
import Agda.Utils.SmallSet (SmallSet(..))
import Agda.Utils.Set1 (Set1)
import qualified Agda.Utils.Set1 as Set1
import Agda.Utils.Trie (Trie(..))
import Agda.Utils.WithDefault

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

instance {-# OVERLAPPING #-} EmbPrj String where
  icod_ :: String -> S Word32
icod_   = String -> S Word32
icodeString
  value :: Word32 -> R String
value Word32
i = (Array Word32 String -> Word32 -> String
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
! Word32
i) (Array Word32 String -> String)
-> StateT St IO (Array Word32 String) -> R String
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> (St -> Array Word32 String) -> StateT St IO (Array Word32 String)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets St -> Array Word32 String
stringE

instance EmbPrj TL.Text where
  icod_ :: Text -> S Word32
icod_   = (Dict -> HashTable Text Word32)
-> (Dict -> IORef FreshAndReuse) -> Text -> S Word32
forall k.
(Eq k, Hashable k) =>
(Dict -> HashTable k Word32)
-> (Dict -> IORef FreshAndReuse) -> k -> S Word32
icodeX Dict -> HashTable Text Word32
lTextD Dict -> IORef FreshAndReuse
lTextC
  value :: Word32 -> R Text
value Word32
i = (Array Word32 Text -> Word32 -> Text
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
! Word32
i) (Array Word32 Text -> Text)
-> StateT St IO (Array Word32 Text) -> R Text
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> (St -> Array Word32 Text) -> StateT St IO (Array Word32 Text)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets St -> Array Word32 Text
lTextE

instance EmbPrj T.Text where
  icod_ :: Text -> S Word32
icod_   = (Dict -> HashTable Text Word32)
-> (Dict -> IORef FreshAndReuse) -> Text -> S Word32
forall k.
(Eq k, Hashable k) =>
(Dict -> HashTable k Word32)
-> (Dict -> IORef FreshAndReuse) -> k -> S Word32
icodeX Dict -> HashTable Text Word32
sTextD Dict -> IORef FreshAndReuse
sTextC
  value :: Word32 -> R Text
value Word32
i = (Array Word32 Text -> Word32 -> Text
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
! Word32
i) (Array Word32 Text -> Text)
-> StateT St IO (Array Word32 Text) -> R Text
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> (St -> Array Word32 Text) -> StateT St IO (Array Word32 Text)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets St -> Array Word32 Text
sTextE

instance EmbPrj Integer where
  icod_ :: Integer -> S Word32
icod_   = Integer -> S Word32
icodeInteger
  value :: Word32 -> R Integer
value Word32
i = (Array Word32 Integer -> Word32 -> Integer
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
! Word32
i) (Array Word32 Integer -> Integer)
-> StateT St IO (Array Word32 Integer) -> R Integer
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> (St -> Array Word32 Integer) -> StateT St IO (Array Word32 Integer)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets St -> Array Word32 Integer
integerE

instance EmbPrj Word64 where
  icod_ :: Word64 -> S Word32
icod_ Word64
i = (Word32 -> Word32 -> Word32)
-> Arrows (Domains (Word32 -> Word32 -> Word32)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' (Word32 -> Word32 -> Word32
forall a. HasCallStack => a
undefined :: Word32 -> Word32 -> Word32) (Word64 -> Word32
word32 Word64
q) (Word64 -> Word32
word32 Word64
r)
    where (Word64
q, Word64
r) = Word64 -> Word64 -> (Word64, Word64)
forall a. Integral a => a -> a -> (a, a)
quotRem Word64
i (Word64
2 Word64 -> Integer -> Word64
forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
32)
          word32 :: Word64 -> Word32
          word32 :: Word64 -> Word32
word32 = Word64 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral

  value :: Word32 -> R Word64
value = ([Word32] -> R Word64) -> Word32 -> R Word64
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R Word64
valu where
    valu :: [Word32] -> R Word64
valu [Word32
a, Word32
b] = Word64 -> R Word64
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word64 -> R Word64) -> Word64 -> R Word64
forall a b. (a -> b) -> a -> b
$! Word64
n Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
* Word32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
a Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
b
    valu [Word32]
_      = R Word64
forall a. R a
malformed
    n :: Word64
n = Word64
2 Word64 -> Integer -> Word64
forall a b. (Num a, Integral b) => a -> b -> a
^ Integer
32

instance EmbPrj Word32 where
  icod_ :: Word32 -> S Word32
icod_ Word32
i = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
i
  value :: Word32 -> R Word32
value Word32
i = Word32 -> R Word32
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
i

-- Andreas, Agda Hackathon 2024-10-15
-- Are we sure we never use an Int that does not fit into 32 bits?
instance EmbPrj Int where
  icod_ :: Int -> S Word32
icod_ Int
i = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32 -> S Word32) -> Word32 -> S Word32
forall a b. (a -> b) -> a -> b
$! Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i
  value :: Word32 -> R Int
value Word32
i = Int -> R Int
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> R Int) -> Int -> R Int
forall a b. (a -> b) -> a -> b
$! Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
i

instance EmbPrj Int32 where
  icod_ :: Int32 -> S Word32
icod_ Int32
i = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32 -> S Word32) -> Word32 -> S Word32
forall a b. (a -> b) -> a -> b
$! Int32 -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
i
  value :: Word32 -> R Int32
value Word32
i = Int32 -> R Int32
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32 -> R Int32) -> Int32 -> R Int32
forall a b. (a -> b) -> a -> b
$! Word32 -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
i

instance EmbPrj Char where
  icod_ :: Char -> S Word32
icod_ Char
c = Word32 -> S Word32
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32 -> S Word32) -> Word32 -> S Word32
forall a b. (a -> b) -> a -> b
$! Int -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word32) -> Int -> Word32
forall a b. (a -> b) -> a -> b
$ Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
c
  value :: Word32 -> R Char
value Word32
i = Char -> R Char
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> R Char) -> Char -> R Char
forall a b. (a -> b) -> a -> b
$! Int -> Char
forall a. Enum a => Int -> a
toEnum (Int -> Char) -> Int -> Char
forall a b. (a -> b) -> a -> b
$ Integer -> Int
forall a. Num a => Integer -> a
fromInteger (Integer -> Int) -> Integer -> Int
forall a b. (a -> b) -> a -> b
$ Word32 -> Integer
forall a. Integral a => a -> Integer
toInteger Word32
i

instance EmbPrj Double where
  icod_ :: Double -> S Word32
icod_   = Double -> S Word32
icodeDouble
  value :: Word32 -> R Double
value Word32
i = (Array Word32 Double -> Word32 -> Double
forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
! Word32
i) (Array Word32 Double -> Double)
-> StateT St IO (Array Word32 Double) -> R Double
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> (St -> Array Word32 Double) -> StateT St IO (Array Word32 Double)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets St -> Array Word32 Double
doubleE

instance EmbPrj Void where
  icod_ :: Void -> S Word32
icod_ = Void -> S Word32
forall a. Void -> a
absurd
  value :: Word32 -> R Void
value = ([Word32] -> R Void) -> Word32 -> R Void
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R Void
forall {p} {a}. p -> R a
valu where valu :: p -> R a
valu p
_ = R a
forall a. R a
malformed

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

  value :: Word32 -> R ()
value Word32
0 = () -> R ()
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
  value Word32
_ = R ()
forall a. R a
malformed

instance (EmbPrj a, EmbPrj b) => EmbPrj (a, b) where
  icod_ :: (a, b) -> S Word32
icod_ (a
a, b
b) = (a -> b -> (a, b))
-> Arrows (Domains (a -> b -> (a, b))) (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
a b
b

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

instance (EmbPrj a, EmbPrj b) => EmbPrj (Pair a b) where
  icod_ :: Pair a b -> S Word32
icod_ (a
a :!: b
b) = (a -> b -> Pair a b)
-> Arrows (Domains (a -> b -> Pair a b)) (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 -> b -> Pair a b
forall a b. a -> b -> Pair a b
(:!:) a
a b
b

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

instance (EmbPrj a, EmbPrj b, EmbPrj c) => EmbPrj (a, b, c) where
  icod_ :: (a, b, c) -> S Word32
icod_ (a
a, b
b, c
c) = (a -> b -> c -> (a, b, c))
-> Arrows (Domains (a -> b -> c -> (a, b, c))) (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
a b
b c
c

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

instance (EmbPrj a, EmbPrj b) => EmbPrj (Either a b) where
  icod_ :: Either a b -> S Word32
icod_ (Left  a
x) = Word32
-> (a -> Either a Any)
-> Arrows (Domains (a -> Either a Any)) (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 a -> Either a Any
forall a b. a -> Either a b
Left a
x
  icod_ (Right b
x) = Word32
-> (b -> Either Any b)
-> Arrows (Domains (b -> Either Any 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 -> Either Any b
forall a b. b -> Either a b
Right b
x

  value :: Word32 -> R (Either a b)
value = ([Word32] -> R (Either a b)) -> Word32 -> R (Either a b)
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R (Either a b)
forall {a} {b}. (EmbPrj a, EmbPrj b) => [Word32] -> R (Either a b)
valu where
    valu :: [Word32] -> R (Either a b)
valu [Word32
0, Word32
x] = (a -> Either a b)
-> Arrows
     (Constant Word32 (Domains (a -> Either a b)))
     (R (CoDomain (a -> Either a b)))
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 -> Either a b
forall a b. a -> Either a b
Left  Word32
x
    valu [Word32
1, Word32
x] = (b -> Either a b)
-> Arrows
     (Constant Word32 (Domains (b -> Either a b)))
     (R (CoDomain (b -> Either a b)))
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 b -> Either a b
forall a b. b -> Either a b
Right Word32
x
    valu [Word32]
_   = R (Either a b)
forall a. R a
malformed

instance EmbPrj a => EmbPrj (Maybe a) where
  icod_ :: Maybe a -> S Word32
icod_ Maybe a
Nothing  = Maybe Any -> Arrows (Domains (Maybe Any)) (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 Any
forall a. Maybe a
Nothing
  icod_ (Just a
x) = (a -> Maybe a) -> Arrows (Domains (a -> Maybe 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 -> Maybe a
forall a. a -> Maybe a
Just a
x

  value :: Word32 -> R (Maybe a)
value = ([Word32] -> R (Maybe a)) -> Word32 -> R (Maybe a)
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase [Word32] -> R (Maybe a)
forall {a}. EmbPrj a => [Word32] -> StateT St IO (Maybe a)
valu where
    valu :: [Word32]
-> Arrows
     (Constant Word32 (Domains (Maybe a))) (R (CoDomain (Maybe a)))
valu []  = Maybe a
-> Arrows
     (Constant Word32 (Domains (Maybe a))) (R (CoDomain (Maybe 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 a
forall a. Maybe a
Nothing
    valu [Word32
x] = (a -> Maybe a)
-> Arrows
     (Constant Word32 (Domains (a -> Maybe a)))
     (R (CoDomain (a -> Maybe 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 -> Maybe a
forall a. a -> Maybe a
Just Word32
x
    valu [Word32]
_   = StateT St IO (Maybe a)
Arrows
  (Constant Word32 (Domains (Maybe a))) (R (CoDomain (Maybe a)))
forall a. R a
malformed

instance EmbPrj a => EmbPrj (Strict.Maybe a) where
  icod_ :: Maybe a -> S Word32
icod_ Maybe a
m = Maybe a -> S Word32
forall a. EmbPrj a => a -> S Word32
icode (Maybe a -> Maybe a
forall lazy strict. Strict lazy strict => strict -> lazy
Strict.toLazy Maybe a
m)
  value :: Word32 -> R (Maybe a)
value Word32
m = Maybe a -> Maybe a
forall lazy strict. Strict lazy strict => lazy -> strict
Strict.toStrict (Maybe a -> Maybe a) -> StateT St IO (Maybe a) -> R (Maybe a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> StateT St IO (Maybe a)
forall a. EmbPrj a => Word32 -> R a
value Word32
m

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

  value :: Word32 -> R Bool
value Word32
0 = Bool -> R Bool
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
  value Word32
1 = Bool -> R Bool
forall a. a -> StateT St IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
  value Word32
_ = R Bool
forall a. R a
malformed

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 a, Typeable b) => EmbPrj (WithDefault' a b) where
  icod_ :: WithDefault' a b -> S Word32
icod_ = \case
    WithDefault' a b
Default -> WithDefault' Any Any
-> Arrows (Domains (WithDefault' Any Any)) (S Word32)
forall t.
(ICODE t (IsBase t), StrictCurrying (Domains t) (S Word32),
 All EmbPrj (Domains t)) =>
t -> Arrows (Domains t) (S Word32)
icodeN' WithDefault' Any Any
forall a (b :: Bool). WithDefault' a b
Default
    Value a
b -> (a -> WithDefault' a Any)
-> Arrows (Domains (a -> WithDefault' a Any)) (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 -> WithDefault' a Any
forall a (b :: Bool). a -> WithDefault' a b
Value a
b

  value :: Word32 -> R (WithDefault' a b)
value = ([Word32] -> R (WithDefault' a b))
-> Word32 -> R (WithDefault' a b)
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase (([Word32] -> R (WithDefault' a b))
 -> Word32 -> R (WithDefault' a b))
-> ([Word32] -> R (WithDefault' a b))
-> Word32
-> R (WithDefault' a b)
forall a b. (a -> b) -> a -> b
$ \case
    []  -> WithDefault' a b
-> Arrows
     (Constant Word32 (Domains (WithDefault' a b)))
     (R (CoDomain (WithDefault' a b)))
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 WithDefault' a b
forall a (b :: Bool). WithDefault' a b
Default
    [Word32
a] -> (a -> WithDefault' a b)
-> Arrows
     (Constant Word32 (Domains (a -> WithDefault' a b)))
     (R (CoDomain (a -> WithDefault' a b)))
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 -> WithDefault' a b
forall a (b :: Bool). a -> WithDefault' a b
Value Word32
a
    [Word32]
_ -> R (WithDefault' a b)
forall a. R a
malformed

instance EmbPrj TopLevelModuleName where
  icod_ :: TopLevelModuleName -> S Word32
icod_ (TopLevelModuleName Range
a ModuleNameHash
b TopLevelModuleNameParts
c) = (Range
 -> ModuleNameHash -> TopLevelModuleNameParts -> TopLevelModuleName)
-> Arrows
     (Domains
        (Range
         -> ModuleNameHash
         -> TopLevelModuleNameParts
         -> 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 -> TopLevelModuleName
forall range.
range
-> ModuleNameHash
-> TopLevelModuleNameParts
-> TopLevelModuleName' range
TopLevelModuleName Range
a ModuleNameHash
b TopLevelModuleNameParts
c

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

instance {-# OVERLAPPABLE #-} EmbPrj a => EmbPrj [a] where
  icod_ :: [a] -> S Word32
icod_ [a]
xs = Node -> S Word32
icodeNode (Node -> S Word32) -> ReaderT Dict IO Node -> S Word32
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [a] -> ReaderT Dict IO Node
go [a]
xs where
    go :: [a] -> S Node
    go :: [a] -> ReaderT Dict IO Node
go []     = Node -> ReaderT Dict IO Node
forall a. a -> ReaderT Dict IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Node
Empty
    go (a
a:[a]
as) = do {n <- a -> S Word32
forall a. EmbPrj a => a -> S Word32
icode a
a; ns <- go as; pure $! Cons n ns}

  value :: Word32 -> R [a]
value = ([Word32] -> R [a]) -> Word32 -> R [a]
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase ((Word32 -> StateT St IO a) -> [Word32] -> R [a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Word32 -> StateT St IO a
forall a. EmbPrj a => Word32 -> R a
value)

instance EmbPrj a => EmbPrj (List1 a) where
  icod_ :: List1 a -> S Word32
icod_ = [a] -> S Word32
forall a. EmbPrj a => a -> S Word32
icod_ ([a] -> S Word32) -> (List1 a -> [a]) -> List1 a -> S Word32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. List1 a -> [a]
List1 a -> [Item (List1 a)]
forall l. IsList l => l -> [Item l]
List1.toList
  value :: Word32 -> R (List1 a)
value = R (List1 a)
-> (List1 a -> R (List1 a)) -> Maybe (List1 a) -> R (List1 a)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe R (List1 a)
forall a. R a
malformed List1 a -> R (List1 a)
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (List1 a) -> R (List1 a))
-> ([a] -> Maybe (List1 a)) -> [a] -> R (List1 a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Maybe (List1 a)
forall a. [a] -> Maybe (NonEmpty a)
List1.nonEmpty ([a] -> R (List1 a))
-> (Word32 -> StateT St IO [a]) -> Word32 -> R (List1 a)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Word32 -> StateT St IO [a]
forall a. EmbPrj a => Word32 -> R a
value

instance EmbPrj a => EmbPrj (List2 a) where
  icod_ :: List2 a -> S Word32
icod_ = [a] -> S Word32
forall a. EmbPrj a => a -> S Word32
icod_ ([a] -> S Word32) -> (List2 a -> [a]) -> List2 a -> S Word32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. List2 a -> [a]
List2 a -> [Item (List2 a)]
forall l. IsList l => l -> [Item l]
List2.toList
  value :: Word32 -> R (List2 a)
value = R (List2 a)
-> (List2 a -> R (List2 a)) -> Maybe (List2 a) -> R (List2 a)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe R (List2 a)
forall a. R a
malformed List2 a -> R (List2 a)
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (List2 a) -> R (List2 a))
-> ([a] -> Maybe (List2 a)) -> [a] -> R (List2 a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Maybe (List2 a)
forall a. [a] -> Maybe (List2 a)
List2.fromListMaybe ([a] -> R (List2 a))
-> (Word32 -> StateT St IO [a]) -> Word32 -> R (List2 a)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Word32 -> StateT St IO [a]
forall a. EmbPrj a => Word32 -> R a
value

instance (EmbPrj k, EmbPrj v, EmbPrj (BiMap.Tag v)) =>
         EmbPrj (BiMap k v) where
  icod_ :: BiMap k v -> S Word32
icod_ BiMap k v
m = ([(k, v)], [(Tag v, k)]) -> S Word32
forall a. EmbPrj a => a -> S Word32
icode (BiMap k v -> ([(k, v)], [(Tag v, k)])
forall k v. BiMap k v -> ([(k, v)], [(Tag v, k)])
BiMap.toDistinctAscendingLists BiMap k v
m)
  value :: Word32 -> R (BiMap k v)
value Word32
m = ([(k, v)], [(Tag v, k)]) -> BiMap k v
forall k v. ([(k, v)], [(Tag v, k)]) -> BiMap k v
BiMap.fromDistinctAscendingLists (([(k, v)], [(Tag v, k)]) -> BiMap k v)
-> StateT St IO ([(k, v)], [(Tag v, k)]) -> R (BiMap k v)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> StateT St IO ([(k, v)], [(Tag v, k)])
forall a. EmbPrj a => Word32 -> R a
value Word32
m


-- | Encode a list of key-value pairs as a flat list.
mapPairsIcode :: (EmbPrj k, EmbPrj v) => [(k, v)] -> S Word32
mapPairsIcode :: forall k v. (EmbPrj k, EmbPrj v) => [(k, v)] -> S Word32
mapPairsIcode [(k, v)]
xs = Node -> S Word32
icodeNode (Node -> S Word32) -> ReaderT Dict IO Node -> S Word32
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Node -> [(k, v)] -> ReaderT Dict IO Node
forall {a} {a}.
(EmbPrj a, EmbPrj a) =>
Node -> [(a, a)] -> ReaderT Dict IO Node
convert Node
Empty [(k, v)]
xs where
  -- As we need to call `convert' in the tail position, the resulting list is
  -- written (and read) in reverse order, with the highest pair first in the
  -- resulting list.
  convert :: Node -> [(a, a)] -> ReaderT Dict IO Node
convert !Node
ys [] = Node -> ReaderT Dict IO Node
forall a. a -> ReaderT Dict IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Node
ys
  convert  Node
ys ((a
start, a
entry):[(a, a)]
xs) = do
    start <- a -> S Word32
forall a. EmbPrj a => a -> S Word32
icode a
start
    entry <- icode entry
    convert (Cons start (Cons entry ys)) xs

mapPairsValue :: (EmbPrj k, EmbPrj v) => [Word32] -> R [(k, v)]
mapPairsValue :: forall k v. (EmbPrj k, EmbPrj v) => [Word32] -> R [(k, v)]
mapPairsValue = [(k, v)] -> [Word32] -> StateT St IO [(k, v)]
forall {a} {b}.
(EmbPrj a, EmbPrj b) =>
[(a, b)] -> [Word32] -> StateT St IO [(a, b)]
convert [] where
  convert :: [(a, b)] -> [Word32] -> StateT St IO [(a, b)]
convert [(a, b)]
ys [] = [(a, b)] -> StateT St IO [(a, b)]
forall a. a -> StateT St IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [(a, b)]
ys
  convert [(a, b)]
ys (Word32
start:Word32
entry:[Word32]
xs) = do
    !start <- Word32 -> R a
forall a. EmbPrj a => Word32 -> R a
value Word32
start
    !entry <- value entry
    convert ((start, entry):ys) xs
  convert [(a, b)]
_ [Word32]
_ = StateT St IO [(a, b)]
forall a. R a
malformed

instance (Ord a, EmbPrj a, EmbPrj b) => EmbPrj (Map a b) where
  icod_ :: Map a b -> S Word32
icod_ Map a b
m = [(a, b)] -> S Word32
forall k v. (EmbPrj k, EmbPrj v) => [(k, v)] -> S Word32
mapPairsIcode (Map a b -> [(a, b)]
forall k a. Map k a -> [(k, a)]
Map.toAscList Map a b
m)
  value :: Word32 -> R (Map a b)
value = ([Word32] -> R (Map a b)) -> Word32 -> R (Map a b)
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase (([(a, b)] -> Map a b
forall k a. [(k, a)] -> Map k a
Map.fromDistinctAscList ([(a, b)] -> Map a b) -> StateT St IO [(a, b)] -> R (Map a b)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!>) (StateT St IO [(a, b)] -> R (Map a b))
-> ([Word32] -> StateT St IO [(a, b)]) -> [Word32] -> R (Map a b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word32] -> StateT St IO [(a, b)]
forall k v. (EmbPrj k, EmbPrj v) => [Word32] -> R [(k, v)]
mapPairsValue)

instance (Ord a, EmbPrj a) => EmbPrj (Set a) where
  icod_ :: Set a -> S Word32
icod_ Set a
s = [a] -> S Word32
forall a. EmbPrj a => a -> S Word32
icode (Set a -> [a]
forall a. Set a -> [a]
Set.toAscList Set a
s)
  value :: Word32 -> R (Set a)
value Word32
s = [a] -> Set a
forall a. [a] -> Set a
Set.fromDistinctAscList ([a] -> Set a) -> StateT St IO [a] -> R (Set a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> StateT St IO [a]
forall a. EmbPrj a => Word32 -> R a
value Word32
s

instance (Ord a, EmbPrj a) => EmbPrj (Set1 a) where
  icod_ :: Set1 a -> S Word32
icod_ Set1 a
s = NonEmpty a -> S Word32
forall a. EmbPrj a => a -> S Word32
icode (Set1 a -> NonEmpty a
forall a. NESet a -> NonEmpty a
Set1.toAscList Set1 a
s)
  value :: Word32 -> R (Set1 a)
value Word32
s = NonEmpty a -> Set1 a
forall a. NonEmpty a -> NESet a
Set1.fromDistinctAscList (NonEmpty a -> Set1 a) -> StateT St IO (NonEmpty a) -> R (Set1 a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> StateT St IO (NonEmpty a)
forall a. EmbPrj a => Word32 -> R a
value Word32
s

instance EmbPrj IntSet where
  icod_ :: IntSet -> S Word32
icod_ IntSet
s = [Int] -> S Word32
forall a. EmbPrj a => a -> S Word32
icode (IntSet -> [Int]
IntSet.toAscList IntSet
s)
  value :: Word32 -> R IntSet
value Word32
s = [Int] -> IntSet
IntSet.fromDistinctAscList ([Int] -> IntSet) -> StateT St IO [Int] -> R IntSet
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
s

instance Typeable a => EmbPrj (SmallSet a) where
  icod_ :: SmallSet a -> S Word32
icod_ (SmallSet Word64
a) = (Word64 -> SmallSet Any)
-> Arrows (Domains (Word64 -> SmallSet Any)) (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 -> SmallSet Any
forall a. Word64 -> SmallSet a
SmallSet Word64
a
  value :: Word32 -> R (SmallSet a)
value = (Word64 -> SmallSet a)
-> Word32 -> R (CoDomain (Word64 -> SmallSet a))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Word64 -> SmallSet a
forall a. Word64 -> SmallSet a
SmallSet

instance (Ord a, EmbPrj a, EmbPrj b) => EmbPrj (Trie a b) where
  icod_ :: Trie a b -> S Word32
icod_ (Trie Maybe b
a Map a (Trie a b)
b)= (Maybe b -> Map a (Trie a b) -> Trie a b)
-> Arrows
     (Domains (Maybe b -> Map a (Trie a b) -> Trie a b)) (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 b -> Map a (Trie a b) -> Trie a b
forall k v. Maybe v -> Map k (Trie k v) -> Trie k v
Trie Maybe b
a Map a (Trie a b)
b

  value :: Word32 -> R (Trie a b)
value = (Maybe b -> Map a (Trie a b) -> Trie a b)
-> Word32 -> R (CoDomain (Maybe b -> Map a (Trie a b) -> Trie a b))
forall t.
(VALU t (IsBase t), All EmbPrj (CoDomain t : Domains t)) =>
t -> Word32 -> R (CoDomain t)
valueN Maybe b -> Map a (Trie a b) -> Trie a b
forall k v. Maybe v -> Map k (Trie k v) -> Trie k v
Trie

instance EmbPrj a => EmbPrj (Seq a) where
  icod_ :: Seq a -> S Word32
icod_ Seq a
s = [a] -> S Word32
forall a. EmbPrj a => a -> S Word32
icode (Seq a -> [a]
forall a. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
Fold.toList Seq a
s)
  value :: Word32 -> R (Seq a)
value Word32
s = [a] -> Seq a
forall a. [a] -> Seq a
Seq.fromList ([a] -> Seq a) -> StateT St IO [a] -> R (Seq a)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> StateT St IO [a]
forall a. EmbPrj a => Word32 -> R a
value Word32
s

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' Any b)
-> Arrows (Domains (b -> ImportedName' Any 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' Any b
forall n m. m -> ImportedName' n m
ImportedModule b
a
  icod_ (ImportedName a
a)   = Word32
-> (a -> ImportedName' a Any)
-> Arrows (Domains (a -> ImportedName' a Any)) (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 Any
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 Double
a) = (Double -> FixityLevel)
-> Arrows (Domains (Double -> 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' Double -> FixityLevel
Related Double
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] = (Double -> FixityLevel)
-> Arrows
     (Constant Word32 (Domains (Double -> FixityLevel)))
     (R (CoDomain (Double -> 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 Double -> 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) -> R Int -> R ProblemId
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!> Word32 -> R 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 (Eq k, Hashable k, EmbPrj k, EmbPrj v) => EmbPrj (HashMap k v) where
  icod_ :: HashMap k v -> S Word32
icod_ HashMap k v
m = [(k, v)] -> S Word32
forall k v. (EmbPrj k, EmbPrj v) => [(k, v)] -> S Word32
mapPairsIcode (HashMap k v -> [(k, v)]
forall k v. HashMap k v -> [(k, v)]
HMap.toList HashMap k v
m)
  value :: Word32 -> R (HashMap k v)
value = ([Word32] -> R (HashMap k v)) -> Word32 -> R (HashMap k v)
forall a. EmbPrj a => ([Word32] -> R a) -> Word32 -> R a
vcase (([(k, v)] -> HashMap k v
forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
HMap.fromList ([(k, v)] -> HashMap k v)
-> StateT St IO [(k, v)] -> R (HashMap k v)
forall (m :: * -> *) a b. Monad m => (a -> b) -> m a -> m b
<$!>) (StateT St IO [(k, v)] -> R (HashMap k v))
-> ([Word32] -> StateT St IO [(k, v)])
-> [Word32]
-> R (HashMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word32] -> StateT St IO [(k, v)]
forall k v. (EmbPrj k, EmbPrj v) => [Word32] -> R [(k, v)]
mapPairsValue)

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' Any -> Arrows (Domains (HasEta' Any)) (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' Any
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 IntSet
a) = (IntSet -> FreeVariables)
-> Arrows (Domains (IntSet -> 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' IntSet -> FreeVariables
KnownFVs IntSet
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] = (IntSet -> FreeVariables)
-> Arrows
     (Constant Word32 (Domains (IntSet -> FreeVariables)))
     (R (CoDomain (IntSet -> 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 IntSet -> 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  Double
a)   = Word32
-> (Double -> Literal)
-> Arrows (Domains (Double -> 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 Double -> Literal
LitFloat Double
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]    = (Double -> Literal)
-> Arrows
     (Constant Word32 (Domains (Double -> Literal)))
     (R (CoDomain (Double -> 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 Double -> 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