module Unison.Builtin.Decls where

import Control.Lens (_3)
import Data.List (elemIndex, find)
import Data.Map qualified as Map
import Data.Maybe qualified as Maybe
import Data.Text (unpack)
import Unison.ABT qualified as ABT
import Unison.ConstructorReference (GConstructorReference (..))
import Unison.ConstructorType qualified as CT
import Unison.DataDeclaration (DataDeclaration (..), Modifier (Structural, Unique))
import Unison.DataDeclaration qualified as DD
import Unison.DataDeclaration.ConstructorId (ConstructorId)
import Unison.Hashing.V2.Convert (hashDataDecls, typeToReference)
import Unison.Pattern qualified as Pattern
import Unison.Prelude
import Unison.Reference (Reference)
import Unison.Reference qualified as Reference
import Unison.Referent (Referent)
import Unison.Referent qualified as Referent
import Unison.Symbol (Symbol)
import Unison.Term (Term, Term2)
import Unison.Term qualified as Term
import Unison.Type (Type)
import Unison.Type qualified as Type
import Unison.Var (Var)
import Unison.Var qualified as Var

lookupDeclRef :: Text -> Reference
lookupDeclRef :: Text -> Reference' Text Hash
lookupDeclRef Text
str
  | [(Symbol
_, Id
d)] <- ((Symbol, Id) -> Bool) -> [(Symbol, Id)] -> [(Symbol, Id)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(Symbol
v, Id
_) -> Symbol
v Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Symbol
forall v. Var v => Text -> v
Var.named Text
str) [(Symbol, Id)]
decls = Id -> Reference' Text Hash
forall h t. Id' h -> Reference' t h
Reference.DerivedId Id
d
  | Bool
otherwise = [Char] -> Reference' Text Hash
forall a. HasCallStack => [Char] -> a
error ([Char] -> Reference' Text Hash) -> [Char] -> Reference' Text Hash
forall a b. (a -> b) -> a -> b
$ [Char]
"lookupDeclRef: missing \"" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
str [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\""
  where
    decls :: [(Symbol, Id)]
decls = [(Symbol
a, Id
b) | (Symbol
a, Id
b, DataDeclaration Symbol ()
_) <- [(Symbol, Id, DataDeclaration Symbol ())]
builtinDataDecls]

lookupEffectRef :: Text -> Reference
lookupEffectRef :: Text -> Reference' Text Hash
lookupEffectRef Text
str
  | [(Symbol
_, Id
d)] <- ((Symbol, Id) -> Bool) -> [(Symbol, Id)] -> [(Symbol, Id)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(Symbol
v, Id
_) -> Symbol
v Symbol -> Symbol -> Bool
forall a. Eq a => a -> a -> Bool
== Text -> Symbol
forall v. Var v => Text -> v
Var.named Text
str) [(Symbol, Id)]
decls = Id -> Reference' Text Hash
forall h t. Id' h -> Reference' t h
Reference.DerivedId Id
d
  | Bool
otherwise = [Char] -> Reference' Text Hash
forall a. HasCallStack => [Char] -> a
error ([Char] -> Reference' Text Hash) -> [Char] -> Reference' Text Hash
forall a b. (a -> b) -> a -> b
$ [Char]
"lookupEffectRef: missing \"" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Text -> [Char]
unpack Text
str [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\""
  where
    decls :: [(Symbol, Id)]
decls = [(Symbol
a, Id
b) | (Symbol
a, Id
b, EffectDeclaration Symbol ()
_) <- [(Symbol, Id, EffectDeclaration Symbol ())]
builtinEffectDecls]

unitRef, pairRef, optionalRef, eitherRef :: Reference
unitRef :: Reference' Text Hash
unitRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Unit"
pairRef :: Reference' Text Hash
pairRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Tuple"
optionalRef :: Reference' Text Hash
optionalRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Optional"
eitherRef :: Reference' Text Hash
eitherRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Either"

testResultRef, testResultListRef, linkRef, docRef, ioErrorRef, stdHandleRef :: Reference
failureRef, ioFailureRef, tlsFailureRef, arrayFailureRef :: Reference
cryptoFailureRef :: Reference
exceptionRef, tlsSignedCertRef, tlsPrivateKeyRef :: Reference
isPropagatedRef, isTestRef :: Reference
isPropagatedRef :: Reference' Text Hash
isPropagatedRef = Text -> Reference' Text Hash
lookupDeclRef Text
"IsPropagated"

isTestRef :: Reference' Text Hash
isTestRef = Text -> Reference' Text Hash
lookupDeclRef Text
"IsTest"

testResultRef :: Reference' Text Hash
testResultRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Test.Result"

-- Reference for [Test.Result]
testResultListRef :: Reference' Text Hash
testResultListRef = forall v a. Var v => Type v a -> Reference' Text Hash
typeToReference @Symbol (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
testResultListType ())

linkRef :: Reference' Text Hash
linkRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Link"

docRef :: Reference' Text Hash
docRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Doc"

ioErrorRef :: Reference' Text Hash
ioErrorRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.IOError"

stdHandleRef :: Reference' Text Hash
stdHandleRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.StdHandle"

failureRef :: Reference' Text Hash
failureRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.Failure"

exceptionRef :: Reference' Text Hash
exceptionRef = Text -> Reference' Text Hash
lookupEffectRef Text
"Exception"

ioFailureRef :: Reference' Text Hash
ioFailureRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.IOFailure"

tlsFailureRef :: Reference' Text Hash
tlsFailureRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.TlsFailure"

arrayFailureRef :: Reference' Text Hash
arrayFailureRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.ArrayFailure"

cryptoFailureRef :: Reference' Text Hash
cryptoFailureRef = Text -> Reference' Text Hash
lookupDeclRef Text
"crypto.CryptoFailure"

tlsSignedCertRef :: Reference' Text Hash
tlsSignedCertRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.Tls.SignedCert"

tlsPrivateKeyRef :: Reference' Text Hash
tlsPrivateKeyRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.Tls.PrivateKey"

runtimeFailureRef, arithmeticFailureRef, miscFailureRef, stmFailureRef, threadKilledFailureRef :: Reference
runtimeFailureRef :: Reference' Text Hash
runtimeFailureRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.RuntimeFailure"
arithmeticFailureRef :: Reference' Text Hash
arithmeticFailureRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.ArithmeticFailure"
miscFailureRef :: Reference' Text Hash
miscFailureRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.MiscFailure"
stmFailureRef :: Reference' Text Hash
stmFailureRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.STMFailure"
threadKilledFailureRef :: Reference' Text Hash
threadKilledFailureRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.ThreadKilledFailure"

fileModeRef, filePathRef, bufferModeRef, seekModeRef, seqViewRef :: Reference
fileModeRef :: Reference' Text Hash
fileModeRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.FileMode"
filePathRef :: Reference' Text Hash
filePathRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.FilePath"
bufferModeRef :: Reference' Text Hash
bufferModeRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.BufferMode"
seekModeRef :: Reference' Text Hash
seekModeRef = Text -> Reference' Text Hash
lookupDeclRef Text
"io2.SeekMode"
seqViewRef :: Reference' Text Hash
seqViewRef = Text -> Reference' Text Hash
lookupDeclRef Text
"SeqView"

pairCtorRef, unitCtorRef :: Referent
pairCtorRef :: Referent
pairCtorRef = ConstructorReference -> ConstructorType -> Referent
Referent.Con (Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
pairRef ConstructorId
0) ConstructorType
CT.Data
unitCtorRef :: Referent
unitCtorRef = ConstructorReference -> ConstructorType -> Referent
Referent.Con (Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
unitRef ConstructorId
0) ConstructorType
CT.Data

constructorId :: Reference -> Text -> Maybe ConstructorId
constructorId :: Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
ref Text
name = do
  (Symbol
_, Id
_, DataDeclaration Symbol ()
dd) <- ((Symbol, Id, DataDeclaration Symbol ()) -> Bool)
-> [(Symbol, Id, DataDeclaration Symbol ())]
-> Maybe (Symbol, Id, DataDeclaration Symbol ())
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (\(Symbol
_, Id
r, DataDeclaration Symbol ()
_) -> Id -> Reference' Text Hash
forall h t. Id' h -> Reference' t h
Reference.DerivedId Id
r Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== Reference' Text Hash
ref) [(Symbol, Id, DataDeclaration Symbol ())]
builtinDataDecls
  (Int -> ConstructorId) -> Maybe Int -> Maybe ConstructorId
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> ConstructorId
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Maybe Int -> Maybe ConstructorId)
-> ([Text] -> Maybe Int) -> [Text] -> Maybe ConstructorId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
elemIndex Text
name ([Text] -> Maybe ConstructorId) -> [Text] -> Maybe ConstructorId
forall a b. (a -> b) -> a -> b
$ DataDeclaration Symbol () -> [Text]
forall v a. Var v => DataDeclaration v a -> [Text]
DD.constructorNames DataDeclaration Symbol ()
dd

effectId :: Reference -> Text -> Maybe ConstructorId
effectId :: Reference' Text Hash -> Text -> Maybe ConstructorId
effectId Reference' Text Hash
ref Text
name = do
  (Symbol
_, Id
_, EffectDeclaration Symbol ()
ed) <- ((Symbol, Id, EffectDeclaration Symbol ()) -> Bool)
-> [(Symbol, Id, EffectDeclaration Symbol ())]
-> Maybe (Symbol, Id, EffectDeclaration Symbol ())
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (\(Symbol
_, Id
r, EffectDeclaration Symbol ()
_) -> Id -> Reference' Text Hash
forall h t. Id' h -> Reference' t h
Reference.DerivedId Id
r Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== Reference' Text Hash
ref) [(Symbol, Id, EffectDeclaration Symbol ())]
builtinEffectDecls
  (Int -> ConstructorId) -> Maybe Int -> Maybe ConstructorId
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> ConstructorId
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Maybe Int -> Maybe ConstructorId)
-> (DataDeclaration Symbol () -> Maybe Int)
-> DataDeclaration Symbol ()
-> Maybe ConstructorId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Text] -> Maybe Int
forall a. Eq a => a -> [a] -> Maybe Int
elemIndex Text
name ([Text] -> Maybe Int)
-> (DataDeclaration Symbol () -> [Text])
-> DataDeclaration Symbol ()
-> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataDeclaration Symbol () -> [Text]
forall v a. Var v => DataDeclaration v a -> [Text]
DD.constructorNames (DataDeclaration Symbol () -> Maybe ConstructorId)
-> DataDeclaration Symbol () -> Maybe ConstructorId
forall a b. (a -> b) -> a -> b
$ EffectDeclaration Symbol () -> DataDeclaration Symbol ()
forall v a. EffectDeclaration v a -> DataDeclaration v a
DD.toDataDecl EffectDeclaration Symbol ()
ed

noneId, someId, okConstructorId, failConstructorId, docBlobId, docLinkId, docSignatureId, docSourceId, docEvaluateId, docJoinId, linkTermId, linkTypeId, eitherRightId, eitherLeftId :: ConstructorId
isPropagatedConstructorId, isTestConstructorId, bufferModeNoBufferingId, bufferModeLineBufferingId, bufferModeBlockBufferingId, bufferModeSizedBlockBufferingId :: ConstructorId
seqViewEmpty, seqViewElem :: ConstructorId
noneId :: ConstructorId
noneId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
optionalRef Text
"Optional.None"
someId :: ConstructorId
someId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
optionalRef Text
"Optional.Some"

mapTip, mapBin :: ConstructorId
mapTip :: ConstructorId
mapTip = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
mapRef Text
"Map.Tip"
mapBin :: ConstructorId
mapBin = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
mapRef Text
"Map.Bin"

setWrap :: ConstructorId
setWrap :: ConstructorId
setWrap = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
setRef Text
"Set.Set"

jsonNull, jsonBool, jsonObj, jsonNum, jsonText, jsonArr :: ConstructorId
jsonNull :: ConstructorId
jsonNull = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
jsonRef Text
"Json.Null"
jsonBool :: ConstructorId
jsonBool = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
jsonRef Text
"Json.Boolean"
jsonObj :: ConstructorId
jsonObj = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
jsonRef Text
"Json.Object"
jsonNum :: ConstructorId
jsonNum = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
jsonRef Text
"Json.Number.Unparsed"
jsonText :: ConstructorId
jsonText = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
jsonRef Text
"Json.Text"
jsonArr :: ConstructorId
jsonArr = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
jsonRef Text
"Json.Array"

jsonParseError :: ConstructorId
jsonParseError :: ConstructorId
jsonParseError =
  Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$
    Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
parseErrorRef Text
"Json.ParseError.ParseError"

avroNull, avroRecord, avroBytes, avroFixed, avroArray, avroMap, avroUnion, avroEnum, avroString, avroInt, avroLong, avroFloat, avroDouble, avroBoolean :: ConstructorId
avroNull :: ConstructorId
avroNull = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.NullValue"
avroRecord :: ConstructorId
avroRecord = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.RecordValue"
avroBytes :: ConstructorId
avroBytes = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.BytesValue"
avroFixed :: ConstructorId
avroFixed = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.FixedValue"
avroArray :: ConstructorId
avroArray = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.ArrayValue"
avroMap :: ConstructorId
avroMap = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.MapValue"
avroUnion :: ConstructorId
avroUnion = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.UnionValue"
avroEnum :: ConstructorId
avroEnum = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.EnumValue"
avroString :: ConstructorId
avroString = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.StringValue"
avroInt :: ConstructorId
avroInt = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.IntValue"
avroLong :: ConstructorId
avroLong = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.LongValue"
avroFloat :: ConstructorId
avroFloat = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.FloatValue"
avroDouble :: ConstructorId
avroDouble = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.DoubleValue"
avroBoolean :: ConstructorId
avroBoolean = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroRef Text
"avro.AvroValue.BooleanValue"

avroDefaultNull, avroDefaultBoolean, avroDefaultInt, avroDefaultLong, avroDefaultFloat, avroDefaultDouble, avroDefaultBytes, avroDefaultString, avroDefaultArray, avroDefaultMap, avroDefaultRecord, avroDefaultEnum, avroDefaultUnion, avroDefaultFixed, avroDefaultNamedType :: ConstructorId
avroDefaultNull :: ConstructorId
avroDefaultNull = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Null"
avroDefaultBoolean :: ConstructorId
avroDefaultBoolean = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Boolean"
avroDefaultInt :: ConstructorId
avroDefaultInt = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Int"
avroDefaultLong :: ConstructorId
avroDefaultLong = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Long"
avroDefaultFloat :: ConstructorId
avroDefaultFloat = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Float"
avroDefaultDouble :: ConstructorId
avroDefaultDouble = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Double"
avroDefaultBytes :: ConstructorId
avroDefaultBytes = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Bytes"
avroDefaultString :: ConstructorId
avroDefaultString = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.String"
avroDefaultArray :: ConstructorId
avroDefaultArray = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Array"
avroDefaultMap :: ConstructorId
avroDefaultMap = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Map"
avroDefaultRecord :: ConstructorId
avroDefaultRecord = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Record"
avroDefaultEnum :: ConstructorId
avroDefaultEnum = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Enum"
avroDefaultUnion :: ConstructorId
avroDefaultUnion = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Union"
avroDefaultFixed :: ConstructorId
avroDefaultFixed = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.Fixed"
avroDefaultNamedType :: ConstructorId
avroDefaultNamedType = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultRef Text
"avro.schema.DefaultValue.NamedType"

avroReadSchemaNull, avroReadSchemaBoolean, avroReadSchemaInt, avroReadSchemaLong, avroReadSchemaFloat, avroReadSchemaDouble, avroReadSchemaBytes, avroReadSchemaString, avroReadSchemaArray, avroReadSchemaMap, avroReadSchemaRecord, avroReadSchemaEnum, avroReadSchemaUnion, avroReadSchemaFixed, avroReadSchemaFreeUnion, avroReadSchemaNamedType :: ConstructorId
avroReadSchemaNull :: ConstructorId
avroReadSchemaNull = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Null"
avroReadSchemaBoolean :: ConstructorId
avroReadSchemaBoolean = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Boolean"
avroReadSchemaInt :: ConstructorId
avroReadSchemaInt = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Int"
avroReadSchemaLong :: ConstructorId
avroReadSchemaLong = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Long"
avroReadSchemaFloat :: ConstructorId
avroReadSchemaFloat = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Float"
avroReadSchemaDouble :: ConstructorId
avroReadSchemaDouble = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Double"
avroReadSchemaBytes :: ConstructorId
avroReadSchemaBytes = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Bytes"
avroReadSchemaString :: ConstructorId
avroReadSchemaString = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.String"
avroReadSchemaArray :: ConstructorId
avroReadSchemaArray = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Array"
avroReadSchemaMap :: ConstructorId
avroReadSchemaMap = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Map"
avroReadSchemaRecord :: ConstructorId
avroReadSchemaRecord = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Record"
avroReadSchemaEnum :: ConstructorId
avroReadSchemaEnum = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Enum"
avroReadSchemaUnion :: ConstructorId
avroReadSchemaUnion = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Union"
avroReadSchemaFixed :: ConstructorId
avroReadSchemaFixed = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.Fixed"
avroReadSchemaFreeUnion :: ConstructorId
avroReadSchemaFreeUnion = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.FreeUnion"
avroReadSchemaNamedType :: ConstructorId
avroReadSchemaNamedType = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadSchemaRef Text
"avro.schema.deconflicted.ReadSchema.NamedType"

avroSchemaRef :: Reference
avroSchemaRef :: Reference' Text Hash
avroSchemaRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.Schema"

avroSchemaNull, avroSchemaBoolean, avroSchemaInt, avroSchemaLong, avroSchemaFloat, avroSchemaDouble, avroSchemaBytes, avroSchemaString, avroSchemaArray, avroSchemaMap, avroSchemaNamedType, avroSchemaRecord, avroSchemaEnum, avroSchemaUnion, avroSchemaFixed :: ConstructorId
avroSchemaNull :: ConstructorId
avroSchemaNull = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Null"
avroSchemaBoolean :: ConstructorId
avroSchemaBoolean = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Boolean"
avroSchemaInt :: ConstructorId
avroSchemaInt = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Int"
avroSchemaLong :: ConstructorId
avroSchemaLong = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Long"
avroSchemaFloat :: ConstructorId
avroSchemaFloat = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Float"
avroSchemaDouble :: ConstructorId
avroSchemaDouble = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Double"
avroSchemaBytes :: ConstructorId
avroSchemaBytes = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Bytes"
avroSchemaString :: ConstructorId
avroSchemaString = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.String"
avroSchemaArray :: ConstructorId
avroSchemaArray = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Array"
avroSchemaMap :: ConstructorId
avroSchemaMap = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Map"
avroSchemaNamedType :: ConstructorId
avroSchemaNamedType = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.NamedType"
avroSchemaRecord :: ConstructorId
avroSchemaRecord = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Record"
avroSchemaEnum :: ConstructorId
avroSchemaEnum = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Enum"
avroSchemaUnion :: ConstructorId
avroSchemaUnion = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Union"
avroSchemaFixed :: ConstructorId
avroSchemaFixed = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroSchemaRef Text
"avro.schema.Schema.Fixed"

avroFieldRef :: Reference
avroFieldRef :: Reference' Text Hash
avroFieldRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.AvroField"

avroEnumRef :: Reference
avroEnumRef :: Reference' Text Hash
avroEnumRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.AvroEnum"

avroDecimalRef :: Reference
avroDecimalRef :: Reference' Text Hash
avroDecimalRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.AvroDecimal"

avroLogicalIntRef :: Reference
avroLogicalIntRef :: Reference' Text Hash
avroLogicalIntRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.LogicalIntType"

avroLogicalIntDate, avroLogicalIntTime, avroLogicalIntDecimal :: ConstructorId
avroLogicalIntDate :: ConstructorId
avroLogicalIntDate = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalIntRef Text
"avro.schema.LogicalIntType.Date"
avroLogicalIntTime :: ConstructorId
avroLogicalIntTime = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalIntRef Text
"avro.schema.LogicalIntType.Time"
avroLogicalIntDecimal :: ConstructorId
avroLogicalIntDecimal = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalIntRef Text
"avro.schema.LogicalIntType.Decimal"

avroLogicalLongRef :: Reference
avroLogicalLongRef :: Reference' Text Hash
avroLogicalLongRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.LogicalLongType"

avroLogicalLongTimeMicros, avroLogicalLongTimestampMillis, avroLogicalLongTimestampMicros, avroLogicalLongLocalTimestampMillis, avroLogicalLongLocalTimestampMicros, avroLogicalLongDecimal :: ConstructorId
avroLogicalLongTimeMicros :: ConstructorId
avroLogicalLongTimeMicros = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalLongRef Text
"avro.schema.LogicalLongType.TimeMicros"
avroLogicalLongTimestampMillis :: ConstructorId
avroLogicalLongTimestampMillis = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalLongRef Text
"avro.schema.LogicalLongType.TimestampMillis"
avroLogicalLongTimestampMicros :: ConstructorId
avroLogicalLongTimestampMicros = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalLongRef Text
"avro.schema.LogicalLongType.TimestampMicros"
avroLogicalLongLocalTimestampMillis :: ConstructorId
avroLogicalLongLocalTimestampMillis = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalLongRef Text
"avro.schema.LogicalLongType.LocalTimestampMillis"
avroLogicalLongLocalTimestampMicros :: ConstructorId
avroLogicalLongLocalTimestampMicros = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalLongRef Text
"avro.schema.LogicalLongType.LocalTimestampMicros"
avroLogicalLongDecimal :: ConstructorId
avroLogicalLongDecimal = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalLongRef Text
"avro.schema.LogicalLongType.Decimal"

avroLogicalFixedRef :: Reference
avroLogicalFixedRef :: Reference' Text Hash
avroLogicalFixedRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.LogicalFixedType"

avroLogicalFixedDuration, avroLogicalFixedDecimal :: ConstructorId
avroLogicalFixedDuration :: ConstructorId
avroLogicalFixedDuration = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalFixedRef Text
"avro.schema.LogicalFixedType.Duration"
avroLogicalFixedDecimal :: ConstructorId
avroLogicalFixedDecimal = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalFixedRef Text
"avro.schema.LogicalFixedType.Decimal"

avroLogicalStringRef :: Reference
avroLogicalStringRef :: Reference' Text Hash
avroLogicalStringRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.LogicalStringType"

avroLogicalStringUUID :: ConstructorId
avroLogicalStringUUID :: ConstructorId
avroLogicalStringUUID = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalStringRef Text
"avro.schema.LogicalStringType.UUID"

avroLogicalBytesRef :: Reference
avroLogicalBytesRef :: Reference' Text Hash
avroLogicalBytesRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.LogicalBytesType"

avroLogicalBytesDecimal :: ConstructorId
avroLogicalBytesDecimal :: ConstructorId
avroLogicalBytesDecimal = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroLogicalBytesRef Text
"avro.schema.LogicalBytesType.Decimal"

avroReadFloatInt32, avroReadFloatInt64, avroReadFloat :: ConstructorId
avroReadFloatInt32 :: ConstructorId
avroReadFloatInt32 = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadFloatRef Text
"avro.schema.deconflicted.ReadFloatFromInt32"
avroReadFloatInt64 :: ConstructorId
avroReadFloatInt64 = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadFloatRef Text
"avro.schema.deconflicted.ReadFloatFromInt64"
avroReadFloat :: ConstructorId
avroReadFloat = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadFloatRef Text
"avro.schema.deconflicted.ReadFloat"

avroReadDoubleInt32, avroReadDoubleInt64, avroReadDoubleFromFloat, avroReadDouble :: ConstructorId
avroReadDoubleInt32 :: ConstructorId
avroReadDoubleInt32 = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadDoubleRef Text
"avro.schema.deconflicted.ReadDoubleFromInt32"
avroReadDoubleInt64 :: ConstructorId
avroReadDoubleInt64 = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadDoubleRef Text
"avro.schema.deconflicted.ReadDoubleFromInt64"
avroReadDoubleFromFloat :: ConstructorId
avroReadDoubleFromFloat = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadDoubleRef Text
"avro.schema.deconflicted.ReadDoubleFromFloat"
avroReadDouble :: ConstructorId
avroReadDouble = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadDoubleRef Text
"avro.schema.deconflicted.ReadDouble"

isPropagatedConstructorId :: ConstructorId
isPropagatedConstructorId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
isPropagatedRef Text
"IsPropagated.IsPropagated"

isTestConstructorId :: ConstructorId
isTestConstructorId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
isTestRef Text
"IsTest.IsTest"

okConstructorId :: ConstructorId
okConstructorId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
testResultRef Text
"Test.Result.Ok"

failConstructorId :: ConstructorId
failConstructorId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
testResultRef Text
"Test.Result.Fail"

docBlobId :: ConstructorId
docBlobId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
docRef Text
"Doc.Blob"

docLinkId :: ConstructorId
docLinkId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
docRef Text
"Doc.Link"

docSignatureId :: ConstructorId
docSignatureId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
docRef Text
"Doc.Signature"

docSourceId :: ConstructorId
docSourceId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
docRef Text
"Doc.Source"

docEvaluateId :: ConstructorId
docEvaluateId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
docRef Text
"Doc.Evaluate"

docJoinId :: ConstructorId
docJoinId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
docRef Text
"Doc.Join"

linkTermId :: ConstructorId
linkTermId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
linkRef Text
"Link.Term"

linkTypeId :: ConstructorId
linkTypeId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
linkRef Text
"Link.Type"

eitherRightId :: ConstructorId
eitherRightId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
eitherRef Text
"Either.Right"

eitherLeftId :: ConstructorId
eitherLeftId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
eitherRef Text
"Either.Left"

seqViewEmpty :: ConstructorId
seqViewEmpty = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
seqViewRef Text
"SeqView.VEmpty"

seqViewElem :: ConstructorId
seqViewElem = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
seqViewRef Text
"SeqView.VElem"

bufferModeNoBufferingId :: ConstructorId
bufferModeNoBufferingId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
bufferModeRef Text
"io2.BufferMode.NoBuffering"

bufferModeLineBufferingId :: ConstructorId
bufferModeLineBufferingId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
bufferModeRef Text
"io2.BufferMode.LineBuffering"

bufferModeBlockBufferingId :: ConstructorId
bufferModeBlockBufferingId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
bufferModeRef Text
"io2.BufferMode.BlockBuffering"

bufferModeSizedBlockBufferingId :: ConstructorId
bufferModeSizedBlockBufferingId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
bufferModeRef Text
"io2.BufferMode.SizedBlockBuffering"

fileModeReadId, fileModeWriteId, fileModeAppendId, fileModeReadWriteId :: ConstructorId
fileModeReadId :: ConstructorId
fileModeReadId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
fileModeRef Text
"io2.FileMode.Read"
fileModeWriteId :: ConstructorId
fileModeWriteId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
fileModeRef Text
"io2.FileMode.Write"
fileModeAppendId :: ConstructorId
fileModeAppendId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
fileModeRef Text
"io2.FileMode.Append"
fileModeReadWriteId :: ConstructorId
fileModeReadWriteId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
fileModeRef Text
"io2.FileMode.ReadWrite"

seekModeAbsoluteId, seekModeRelativeId, seekModeEndId :: ConstructorId
seekModeAbsoluteId :: ConstructorId
seekModeAbsoluteId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
seekModeRef Text
"io2.SeekMode.AbsoluteSeek"
seekModeRelativeId :: ConstructorId
seekModeRelativeId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
seekModeRef Text
"io2.SeekMode.RelativeSeek"
seekModeEndId :: ConstructorId
seekModeEndId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
seekModeRef Text
"io2.SeekMode.SeekFromEnd"

stdInId, stdOutId, stdErrId :: ConstructorId
stdInId :: ConstructorId
stdInId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
stdHandleRef Text
"io2.StdHandle.StdIn"
stdOutId :: ConstructorId
stdOutId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
stdHandleRef Text
"io2.StdHandle.StdOut"
stdErrId :: ConstructorId
stdErrId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
stdHandleRef Text
"io2.StdHandle.StdErr"

exceptionRaiseId :: ConstructorId
exceptionRaiseId :: ConstructorId
exceptionRaiseId = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
effectId Reference' Text Hash
exceptionRef Text
"Exception.raise"

okConstructorReferent, failConstructorReferent :: Referent.Referent
okConstructorReferent :: Referent
okConstructorReferent = ConstructorReference -> ConstructorType -> Referent
Referent.Con (Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
testResultRef ConstructorId
okConstructorId) ConstructorType
CT.Data
failConstructorReferent :: Referent
failConstructorReferent = ConstructorReference -> ConstructorType -> Referent
Referent.Con (Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
testResultRef ConstructorId
failConstructorId) ConstructorType
CT.Data

rewriteTermRef :: Reference
rewriteTermRef :: Reference' Text Hash
rewriteTermRef = Text -> Reference' Text Hash
lookupDeclRef Text
"RewriteTerm"

pattern RewriteTerm' :: Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern $mRewriteTerm' :: forall {r} {vt} {at} {ap} {v} {a}.
Term2 vt at ap v a
-> (Term2 vt at ap v a -> Term2 vt at ap v a -> r)
-> ((# #) -> r)
-> r
RewriteTerm' lhs rhs <- (unRewriteTerm -> Just (lhs, rhs))

unRewriteTerm :: Term2 vt at ap v a -> Maybe (Term2 vt at ap v a, Term2 vt at ap v a)
unRewriteTerm :: forall vt at ap v a.
Term2 vt at ap v a
-> Maybe (Term2 vt at ap v a, Term2 vt at ap v a)
unRewriteTerm (Term.Apps' (Term.Constructor' (ConstructorReference Reference' Text Hash
r ConstructorId
_)) [Term2 vt at ap v a
lhs, Term2 vt at ap v a
rhs])
  | Reference' Text Hash
r Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== Reference' Text Hash
rewriteTermRef = (Term2 vt at ap v a, Term2 vt at ap v a)
-> Maybe (Term2 vt at ap v a, Term2 vt at ap v a)
forall a. a -> Maybe a
Just (Term2 vt at ap v a
lhs, Term2 vt at ap v a
rhs)
unRewriteTerm Term2 vt at ap v a
_ = Maybe (Term2 vt at ap v a, Term2 vt at ap v a)
forall a. Maybe a
Nothing

rewriteCaseRef :: Reference
rewriteCaseRef :: Reference' Text Hash
rewriteCaseRef = Text -> Reference' Text Hash
lookupDeclRef Text
"RewriteCase"

pattern RewriteCase' :: Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
pattern $mRewriteCase' :: forall {r} {vt} {at} {ap} {v} {a}.
Term2 vt at ap v a
-> (Term2 vt at ap v a -> Term2 vt at ap v a -> r)
-> ((# #) -> r)
-> r
RewriteCase' lhs rhs <- (unRewriteCase -> Just (lhs, rhs))

rewriteCase :: (Ord v) => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
rewriteCase :: forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
rewriteCase a
a Term2 vt at ap v a
tm1 Term2 vt at ap v a
tm2 = a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.app a
a (a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.app a
a1 (a -> ConstructorReference -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> ConstructorReference -> Term2 vt at ap v a
Term.constructor a
a1 ConstructorReference
r) Term2 vt at ap v a
tm1) Term2 vt at ap v a
tm2
  where
    a1 :: a
a1 = Term2 vt at ap v a -> a
forall (f :: * -> *) v a. Term f v a -> a
ABT.annotation Term2 vt at ap v a
tm1
    r :: ConstructorReference
r = Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
rewriteCaseRef ConstructorId
0

rewriteTerm :: (Ord v) => a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
rewriteTerm :: forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
rewriteTerm a
a Term2 vt at ap v a
tm1 Term2 vt at ap v a
tm2 = a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.app a
a (a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.app a
a1 (a -> ConstructorReference -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> ConstructorReference -> Term2 vt at ap v a
Term.constructor a
a1 ConstructorReference
r) Term2 vt at ap v a
tm1) Term2 vt at ap v a
tm2
  where
    a1 :: a
a1 = Term2 vt at ap v a -> a
forall (f :: * -> *) v a. Term f v a -> a
ABT.annotation Term2 vt at ap v a
tm1
    r :: ConstructorReference
r = Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
rewriteTermRef ConstructorId
0

unRewriteCase :: Term2 vt at ap v a -> Maybe (Term2 vt at ap v a, Term2 vt at ap v a)
unRewriteCase :: forall vt at ap v a.
Term2 vt at ap v a
-> Maybe (Term2 vt at ap v a, Term2 vt at ap v a)
unRewriteCase (Term.Apps' (Term.Constructor' (ConstructorReference Reference' Text Hash
r ConstructorId
_)) [Term2 vt at ap v a
lhs, Term2 vt at ap v a
rhs])
  | Reference' Text Hash
r Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== Reference' Text Hash
rewriteCaseRef = (Term2 vt at ap v a, Term2 vt at ap v a)
-> Maybe (Term2 vt at ap v a, Term2 vt at ap v a)
forall a. a -> Maybe a
Just (Term2 vt at ap v a
lhs, Term2 vt at ap v a
rhs)
unRewriteCase Term2 vt at ap v a
_ = Maybe (Term2 vt at ap v a, Term2 vt at ap v a)
forall a. Maybe a
Nothing

rewriteTypeRef :: Reference
rewriteTypeRef :: Reference' Text Hash
rewriteTypeRef = Text -> Reference' Text Hash
lookupDeclRef Text
"RewriteSignature"

pattern RewriteSignature' :: forall vt at ap v a. [vt] -> Type vt at -> Type vt at -> Term2 vt at ap v a
pattern $mRewriteSignature' :: forall {r} {vt} {at} {ap} {v} {a}.
Term2 vt at ap v a
-> ([vt] -> Type vt at -> Type vt at -> r) -> ((# #) -> r) -> r
RewriteSignature' vs lhs rhs <- (unRewriteSignature -> Just (vs, lhs, rhs))

rewriteType :: (Var v, Semigroup a) => a -> [v] -> Type v a -> Type v a -> Term2 v a a v a
rewriteType :: forall v a.
(Var v, Semigroup a) =>
a -> [v] -> Type v a -> Type v a -> Term2 v a a v a
rewriteType a
a [v]
vs Type v a
lhs Type v a
rhs =
  a -> Term2 v a a v a -> Term2 v a a v a -> Term2 v a a v a
forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.app
    a
a
    (a -> ConstructorReference -> Term2 v a a v a
forall v a vt at ap.
Ord v =>
a -> ConstructorReference -> Term2 vt at ap v a
Term.constructor a
la (Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
rewriteTypeRef ConstructorId
0))
    ( a -> Term2 v a a v a -> Type v a -> Term2 v a a v a
forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Type vt at -> Term2 vt at ap v a
Term.ann
        a
a
        (a -> Term2 v a a v a -> Term2 v a a v a
forall v a vt at ap.
Var v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.delay a
a (a -> Term2 v a a v a -> Term2 v a a v a
forall v a vt at ap.
Var v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.delay a
a (a -> Term2 v a a v a
forall v a vt at ap. Var v => a -> Term2 vt at ap v a
unitTerm a
a)))
        (a -> [v] -> Type v a -> Type v a
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls a
a [v]
vs (a -> Type v a -> Type v a -> Type v a
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.arrow (a
la a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
ra) Type v a
lhs (a -> Type v a -> Type v a -> Type v a
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.arrow a
ra Type v a
rhs (a -> Type v a
forall v a. Ord v => a -> Type v a
unitType a
ra))))
    )
  where
    la :: a
la = Type v a -> a
forall (f :: * -> *) v a. Term f v a -> a
ABT.annotation Type v a
lhs
    ra :: a
ra = Type v a -> a
forall (f :: * -> *) v a. Term f v a -> a
ABT.annotation Type v a
rhs

unRewriteSignature :: Term2 vt at ap v a -> Maybe ([vt], Type vt at, Type vt at)
unRewriteSignature :: forall vt at ap v a.
Term2 vt at ap v a -> Maybe ([vt], Type vt at, Type vt at)
unRewriteSignature
  ( Term.App'
      (Term.Constructor' (ConstructorReference Reference' Text Hash
r ConstructorId
_))
      (Term.Ann' Term (F vt at ap) v a
_ (Type.ForallsNamedOpt' [vt]
vs (Type.Arrow' Type vt at
lhs (Type.Arrow' Type vt at
rhs Type vt at
_unit))))
    )
    | Reference' Text Hash
r Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== Reference' Text Hash
rewriteTypeRef = ([vt], Type vt at, Type vt at)
-> Maybe ([vt], Type vt at, Type vt at)
forall a. a -> Maybe a
Just ([vt]
vs, Type vt at
lhs, Type vt at
rhs)
unRewriteSignature Term (F vt at ap) v a
_ = Maybe ([vt], Type vt at, Type vt at)
forall a. Maybe a
Nothing

rewritesRef :: Reference
rewritesRef :: Reference' Text Hash
rewritesRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Rewrites"

mapRef :: Reference
mapRef :: Reference' Text Hash
mapRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Map"

setRef :: Reference
setRef :: Reference' Text Hash
setRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Set"

jsonRef :: Reference
jsonRef :: Reference' Text Hash
jsonRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Json"

parseErrorRef :: Reference
parseErrorRef :: Reference' Text Hash
parseErrorRef = Text -> Reference' Text Hash
lookupDeclRef Text
"Json.ParseError"

avroRef :: Reference
avroRef :: Reference' Text Hash
avroRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.AvroValue"

avroDefaultRef :: Reference
avroDefaultRef :: Reference' Text Hash
avroDefaultRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.DefaultValue"

avroReadSchemaRef :: Reference
avroReadSchemaRef :: Reference' Text Hash
avroReadSchemaRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.deconflicted.ReadSchema"

avroTypeNameRef :: Reference
avroTypeNameRef :: Reference' Text Hash
avroTypeNameRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.TypeName"

avroReadRecordRef :: Reference
avroReadRecordRef :: Reference' Text Hash
avroReadRecordRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.deconflicted.ReadRecord"

avroRecordRef :: Reference
avroRecordRef :: Reference' Text Hash
avroRecordRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.AvroRecord"

avroReadFieldRef :: Reference
avroReadFieldRef :: Reference' Text Hash
avroReadFieldRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.deconflicted.ReadField"

avroFixedRef :: Reference
avroFixedRef :: Reference' Text Hash
avroFixedRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.AvroFixed"

avroReadFloatRef :: Reference
avroReadFloatRef :: Reference' Text Hash
avroReadFloatRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.deconflicted.ReadFloat"

avroReadDoubleRef :: Reference
avroReadDoubleRef :: Reference' Text Hash
avroReadDoubleRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.deconflicted.ReadDouble"

avroReadLongRef :: Reference
avroReadLongRef :: Reference' Text Hash
avroReadLongRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.deconflicted.ReadLong"

avroFieldStatusRef :: Reference
avroFieldStatusRef :: Reference' Text Hash
avroFieldStatusRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.deconflicted.FieldStatus"

avroOrderRef :: Reference
avroOrderRef :: Reference' Text Hash
avroOrderRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.Order"

avroReadLongInt32, avroReadLong :: ConstructorId
avroReadLongInt32 :: ConstructorId
avroReadLongInt32 = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadLongRef Text
"avro.schema.deconflicted.ReadLong.LongFromInt32"
avroReadLong :: ConstructorId
avroReadLong = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroReadLongRef Text
"avro.schema.deconflicted.ReadLong"

avroFieldStatusAsIs, avroFieldStatusDefaulted, avroFieldStatusIgnored :: ConstructorId
avroFieldStatusAsIs :: ConstructorId
avroFieldStatusAsIs = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroFieldStatusRef Text
"avro.schema.deconflicted.FieldStatus.AsIs"
avroFieldStatusDefaulted :: ConstructorId
avroFieldStatusDefaulted = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroFieldStatusRef Text
"avro.schema.deconflicted.FieldStatus.Defaulted"
avroFieldStatusIgnored :: ConstructorId
avroFieldStatusIgnored = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroFieldStatusRef Text
"avro.schema.deconflicted.FieldStatus.Ignored"

avroOrderAscending, avroOrderDescending, avroOrderIgnore :: ConstructorId
avroOrderAscending :: ConstructorId
avroOrderAscending = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroOrderRef Text
"avro.schema.Order.Ascending"
avroOrderDescending :: ConstructorId
avroOrderDescending = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroOrderRef Text
"avro.schema.Order.Descending"
avroOrderIgnore :: ConstructorId
avroOrderIgnore = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroOrderRef Text
"avro.schema.Order.Ignore"

avroDefaultValueRef :: Reference
avroDefaultValueRef :: Reference' Text Hash
avroDefaultValueRef = Text -> Reference' Text Hash
lookupDeclRef Text
"avro.schema.DefaultValue"

avroDefaultValueBytes, avroDefaultValueFixed, avroDefaultValueArray, avroDefaultValueInt32, avroDefaultValueInt64, avroDefaultValueEnum, avroDefaultValueBoolean, avroDefaultValueNull, avroDefaultValueMap, avroDefaultValueString, avroDefaultValueFloat, avroDefaultValueDouble, avroDefaultValueRecord, avroDefaultValueUnion :: ConstructorId
avroDefaultValueBytes :: ConstructorId
avroDefaultValueBytes = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Bytes"
avroDefaultValueFixed :: ConstructorId
avroDefaultValueFixed = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Fixed"
avroDefaultValueArray :: ConstructorId
avroDefaultValueArray = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Array"
avroDefaultValueInt32 :: ConstructorId
avroDefaultValueInt32 = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Int32"
avroDefaultValueInt64 :: ConstructorId
avroDefaultValueInt64 = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Int64"
avroDefaultValueEnum :: ConstructorId
avroDefaultValueEnum = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Enum"
avroDefaultValueBoolean :: ConstructorId
avroDefaultValueBoolean = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Boolean"
avroDefaultValueNull :: ConstructorId
avroDefaultValueNull = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Null"
avroDefaultValueMap :: ConstructorId
avroDefaultValueMap = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Map"
avroDefaultValueString :: ConstructorId
avroDefaultValueString = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.String"
avroDefaultValueFloat :: ConstructorId
avroDefaultValueFloat = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Float"
avroDefaultValueDouble :: ConstructorId
avroDefaultValueDouble = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Double"
avroDefaultValueRecord :: ConstructorId
avroDefaultValueRecord = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Record"
avroDefaultValueUnion :: ConstructorId
avroDefaultValueUnion = Maybe ConstructorId -> ConstructorId
forall a. HasCallStack => Maybe a -> a
Maybe.fromJust (Maybe ConstructorId -> ConstructorId)
-> Maybe ConstructorId -> ConstructorId
forall a b. (a -> b) -> a -> b
$ Reference' Text Hash -> Text -> Maybe ConstructorId
constructorId Reference' Text Hash
avroDefaultValueRef Text
"avro.schema.DefaultValue.Union"

pattern Rewrites' :: [Term2 vt at ap v a] -> Term2 vt at ap v a
pattern $mRewrites' :: forall {r} {vt} {at} {ap} {v} {a}.
Term2 vt at ap v a
-> ([Term2 vt at ap v a] -> r) -> ((# #) -> r) -> r
Rewrites' ts <- (unRewrites -> Just ts)

rewrites :: (Var v, Monoid a) => a -> [Term2 vt at ap v a] -> Term2 vt at ap v a
rewrites :: forall v a vt at ap.
(Var v, Monoid a) =>
a -> [Term2 vt at ap v a] -> Term2 vt at ap v a
rewrites a
a [] = a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.app a
a (a -> ConstructorReference -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> ConstructorReference -> Term2 vt at ap v a
Term.constructor a
a (Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
rewritesRef ConstructorId
0)) ([Term2 vt at ap v a] -> Term2 vt at ap v a
forall v a vt at ap.
(Var v, Monoid a) =>
[Term2 vt at ap v a] -> Term2 vt at ap v a
tupleTerm [])
rewrites a
a ts :: [Term2 vt at ap v a]
ts@(Term2 vt at ap v a
hd : [Term2 vt at ap v a]
_) = a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.app a
a (a -> ConstructorReference -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> ConstructorReference -> Term2 vt at ap v a
Term.constructor a
a1 (Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
rewritesRef ConstructorId
0)) ([Term2 vt at ap v a] -> Term2 vt at ap v a
forall v a vt at ap.
(Var v, Monoid a) =>
[Term2 vt at ap v a] -> Term2 vt at ap v a
tupleTerm [Term2 vt at ap v a]
ts)
  where
    a1 :: a
a1 = Term2 vt at ap v a -> a
forall (f :: * -> *) v a. Term f v a -> a
ABT.annotation Term2 vt at ap v a
hd

unRewrites :: Term2 vt at ap v a -> Maybe [Term2 vt at ap v a]
unRewrites :: forall vt at ap v a.
Term2 vt at ap v a -> Maybe [Term2 vt at ap v a]
unRewrites (Term.App' (Term.Constructor' (ConstructorReference Reference' Text Hash
r ConstructorId
_)) Term (F vt at ap) v a
tup)
  | Reference' Text Hash
r Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== Reference' Text Hash
rewritesRef, TupleTerm' [Term (F vt at ap) v a]
ts <- Term (F vt at ap) v a
tup = [Term (F vt at ap) v a] -> Maybe [Term (F vt at ap) v a]
forall a. a -> Maybe a
Just [Term (F vt at ap) v a]
ts
unRewrites Term (F vt at ap) v a
_ = Maybe [Term (F vt at ap) v a]
forall a. Maybe a
Nothing

-- | parse some builtin data types, and resolve their free variables using
-- | builtinTypes' and those types defined herein
builtinDataDecls :: [(Symbol, Reference.Id, DataDeclaration Symbol ())]
builtinDataDecls :: [(Symbol, Id, DataDeclaration Symbol ())]
builtinDataDecls = [(Symbol, Id, DataDeclaration Symbol ())]
rs1 [(Symbol, Id, DataDeclaration Symbol ())]
-> [(Symbol, Id, DataDeclaration Symbol ())]
-> [(Symbol, Id, DataDeclaration Symbol ())]
forall a. [a] -> [a] -> [a]
++ [(Symbol, Id, DataDeclaration Symbol ())]
rs
  where
    rs1 :: [(Symbol, Id, DataDeclaration Symbol ())]
rs1 = case Map Symbol (DataDeclaration Symbol ())
-> ResolutionResult () [(Symbol, Id, DataDeclaration Symbol ())]
forall v a.
Var v =>
Map v (DataDeclaration v a)
-> ResolutionResult a [(v, Id, DataDeclaration v a)]
hashDataDecls (Map Symbol (DataDeclaration Symbol ())
 -> ResolutionResult () [(Symbol, Id, DataDeclaration Symbol ())])
-> Map Symbol (DataDeclaration Symbol ())
-> ResolutionResult () [(Symbol, Id, DataDeclaration Symbol ())]
forall a b. (a -> b) -> a -> b
$
      [(Symbol, DataDeclaration Symbol ())]
-> Map Symbol (DataDeclaration Symbol ())
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
        [ (Text -> Symbol
v Text
"Link", DataDeclaration Symbol ()
link)
        ] of
      Right [(Symbol, Id, DataDeclaration Symbol ())]
a -> [(Symbol, Id, DataDeclaration Symbol ())]
a
      Left Seq (ResolutionFailure ())
e -> [Char] -> [(Symbol, Id, DataDeclaration Symbol ())]
forall a. HasCallStack => [Char] -> a
error ([Char] -> [(Symbol, Id, DataDeclaration Symbol ())])
-> [Char] -> [(Symbol, Id, DataDeclaration Symbol ())]
forall a b. (a -> b) -> a -> b
$ [Char]
"builtinDataDecls: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Seq (ResolutionFailure ()) -> [Char]
forall a. Show a => a -> [Char]
show Seq (ResolutionFailure ())
e
    rs :: [(Symbol, Id, DataDeclaration Symbol ())]
rs = case Map Symbol (DataDeclaration Symbol ())
-> ResolutionResult () [(Symbol, Id, DataDeclaration Symbol ())]
forall v a.
Var v =>
Map v (DataDeclaration v a)
-> ResolutionResult a [(v, Id, DataDeclaration v a)]
hashDataDecls (Map Symbol (DataDeclaration Symbol ())
 -> ResolutionResult () [(Symbol, Id, DataDeclaration Symbol ())])
-> Map Symbol (DataDeclaration Symbol ())
-> ResolutionResult () [(Symbol, Id, DataDeclaration Symbol ())]
forall a b. (a -> b) -> a -> b
$
      [(Symbol, DataDeclaration Symbol ())]
-> Map Symbol (DataDeclaration Symbol ())
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList
        [ (Text -> Symbol
v Text
"Unit", DataDeclaration Symbol ()
unit),
          (Text -> Symbol
v Text
"Tuple", DataDeclaration Symbol ()
tuple),
          (Text -> Symbol
v Text
"Optional", DataDeclaration Symbol ()
opt),
          (Text -> Symbol
v Text
"Either", DataDeclaration Symbol ()
eith),
          (Text -> Symbol
v Text
"Test.Result", DataDeclaration Symbol ()
tr),
          (Text -> Symbol
v Text
"IsPropagated", DataDeclaration Symbol ()
isPropagated),
          (Text -> Symbol
v Text
"IsTest", DataDeclaration Symbol ()
isTest),
          (Text -> Symbol
v Text
"Doc", DataDeclaration Symbol ()
doc),
          (Text -> Symbol
v Text
"io2.FileMode", DataDeclaration Symbol ()
fmode),
          (Text -> Symbol
v Text
"io2.BufferMode", DataDeclaration Symbol ()
bmode),
          (Text -> Symbol
v Text
"io2.SeekMode", DataDeclaration Symbol ()
smode),
          (Text -> Symbol
v Text
"SeqView", DataDeclaration Symbol ()
seqview),
          (Text -> Symbol
v Text
"io2.IOError", DataDeclaration Symbol ()
ioerr),
          (Text -> Symbol
v Text
"io2.StdHandle", DataDeclaration Symbol ()
stdhnd),
          (Text -> Symbol
v Text
"io2.Failure", DataDeclaration Symbol ()
failure),
          (Text -> Symbol
v Text
"io2.TlsFailure", DataDeclaration Symbol ()
forall {v}. DataDeclaration v ()
tlsFailure),
          (Text -> Symbol
v Text
"io2.IOFailure", DataDeclaration Symbol ()
forall {v}. DataDeclaration v ()
ioFailure),
          (Text -> Symbol
v Text
"io2.ArrayFailure", DataDeclaration Symbol ()
forall {v}. DataDeclaration v ()
arrayFailure),
          (Text -> Symbol
v Text
"io2.RuntimeFailure", DataDeclaration Symbol ()
forall {v}. DataDeclaration v ()
runtimeFailure),
          (Text -> Symbol
v Text
"io2.ArithmeticFailure", DataDeclaration Symbol ()
forall {v}. DataDeclaration v ()
arithmeticFailure),
          (Text -> Symbol
v Text
"io2.MiscFailure", DataDeclaration Symbol ()
forall {v}. DataDeclaration v ()
miscFailure),
          (Text -> Symbol
v Text
"io2.STMFailure", DataDeclaration Symbol ()
forall {v}. DataDeclaration v ()
stmFailure),
          (Text -> Symbol
v Text
"io2.ThreadKilledFailure", DataDeclaration Symbol ()
forall {v}. DataDeclaration v ()
threadKilledFailure),
          (Text -> Symbol
v Text
"crypto.CryptoFailure", DataDeclaration Symbol ()
forall {v}. DataDeclaration v ()
cryptoFailure),
          (Text -> Symbol
v Text
"RewriteTerm", DataDeclaration Symbol ()
rewriteTerm),
          (Text -> Symbol
v Text
"RewriteSignature", DataDeclaration Symbol ()
rewriteType),
          (Text -> Symbol
v Text
"RewriteCase", DataDeclaration Symbol ()
rewriteCase),
          (Text -> Symbol
v Text
"Rewrites", DataDeclaration Symbol ()
rewrites),
          (Text -> Symbol
v Text
"Map", DataDeclaration Symbol ()
map),
          (Text -> Symbol
v Text
"Set", DataDeclaration Symbol ()
set),
          (Text -> Symbol
v Text
"Json", DataDeclaration Symbol ()
json),
          (Text -> Symbol
v Text
"Json.ParseError", DataDeclaration Symbol ()
jsonParseError),
          (Text -> Symbol
v Text
"avro.AvroValue", DataDeclaration Symbol ()
avro),
          (Text -> Symbol
v Text
"avro.schema.Schema", DataDeclaration Symbol ()
avroSchema),
          (Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema", DataDeclaration Symbol ()
avroReadSchema),
          (Text -> Symbol
v Text
"avro.schema.deconflicted.ReadFloat", DataDeclaration Symbol ()
avroReadFloat),
          (Text -> Symbol
v Text
"avro.schema.deconflicted.ReadDouble", DataDeclaration Symbol ()
avroReadDouble),
          (Text -> Symbol
v Text
"avro.schema.deconflicted.ReadLong", DataDeclaration Symbol ()
avroReadLong),
          (Text -> Symbol
v Text
"avro.schema.deconflicted.ReadRecord", DataDeclaration Symbol ()
avroReadRecord),
          (Text -> Symbol
v Text
"avro.schema.AvroRecord", DataDeclaration Symbol ()
avroRecord),
          (Text -> Symbol
v Text
"avro.schema.deconflicted.ReadField", DataDeclaration Symbol ()
avroReadField),
          (Text -> Symbol
v Text
"avro.schema.Order", DataDeclaration Symbol ()
avroOrder),
          (Text -> Symbol
v Text
"avro.schema.deconflicted.FieldStatus", DataDeclaration Symbol ()
avroFieldStatus),
          (Text -> Symbol
v Text
"avro.schema.AvroField", DataDeclaration Symbol ()
avroField),
          (Text -> Symbol
v Text
"avro.schema.AvroEnum", DataDeclaration Symbol ()
avroEnum),
          (Text -> Symbol
v Text
"avro.schema.DefaultValue", DataDeclaration Symbol ()
avroDefaultValue),
          (Text -> Symbol
v Text
"avro.schema.TypeName", DataDeclaration Symbol ()
avroTypeName),
          (Text -> Symbol
v Text
"avro.schema.AvroFixed", DataDeclaration Symbol ()
avroFixed),
          (Text -> Symbol
v Text
"avro.schema.LogicalFixedType", DataDeclaration Symbol ()
avroLogicalFixedType),
          (Text -> Symbol
v Text
"avro.schema.LogicalStringType", DataDeclaration Symbol ()
avroLogicalStringType),
          (Text -> Symbol
v Text
"avro.schema.LogicalBytesType", DataDeclaration Symbol ()
avroLogicalBytesType),
          (Text -> Symbol
v Text
"avro.schema.LogicalIntType", DataDeclaration Symbol ()
avroLogicalIntType),
          (Text -> Symbol
v Text
"avro.schema.LogicalLongType", DataDeclaration Symbol ()
avroLogicalLongType),
          (Text -> Symbol
v Text
"avro.schema.Decimal", DataDeclaration Symbol ()
avroDecimal)
        ] of
      Right [(Symbol, Id, DataDeclaration Symbol ())]
a -> [(Symbol, Id, DataDeclaration Symbol ())]
a
      Left Seq (ResolutionFailure ())
e -> [Char] -> [(Symbol, Id, DataDeclaration Symbol ())]
forall a. HasCallStack => [Char] -> a
error ([Char] -> [(Symbol, Id, DataDeclaration Symbol ())])
-> [Char] -> [(Symbol, Id, DataDeclaration Symbol ())]
forall a b. (a -> b) -> a -> b
$ [Char]
"builtinDataDecls: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Seq (ResolutionFailure ()) -> [Char]
forall a. Show a => a -> [Char]
show Seq (ResolutionFailure ())
e
    linkRef :: Id
linkRef = case [(Symbol, Id, DataDeclaration Symbol ())]
rs1 of
      [(Symbol
_, Id
linkRef, DataDeclaration Symbol ()
_)] -> Id
linkRef
      [(Symbol, Id, DataDeclaration Symbol ())]
_ -> [Char] -> Id
forall a. HasCallStack => [Char] -> a
error [Char]
"builtinDataDecls: Expected a single linkRef"
    v :: Text -> Symbol
v = Text -> Symbol
forall v. Var v => Text -> v
Var.named
    var :: Text -> Type Symbol ()
var Text
name = () -> Symbol -> Type Symbol ()
forall v a. Ord v => a -> v -> Type v a
Type.var () (Text -> Symbol
v Text
name)
    infixr 7 `arr`
    arr :: Type Symbol () -> Type Symbol () -> Type Symbol ()
arr = Type Symbol () -> Type Symbol () -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> Type v a -> Type v a
Type.arrow'
    -- see note on `hashDecls` above for why ctor must be called `Unit.Unit`.
    unit :: DataDeclaration Symbol ()
unit = Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration Modifier
Structural () [] [((), Text -> Symbol
v Text
"Unit.Unit", Text -> Type Symbol ()
var Text
"Unit")]
    tuple :: DataDeclaration Symbol ()
tuple =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        Modifier
Structural
        ()
        [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
        [ ( (),
            Text -> Symbol
v Text
"Tuple.Cons",
            () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls
              ()
              [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
              ( Text -> Type Symbol ()
var Text
"a"
                  Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` (Text -> Type Symbol ()
var Text
"b" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Tuple") [Text -> Type Symbol ()
var Text
"a", Text -> Type Symbol ()
var Text
"b"])
              )
          )
        ]
    opt :: DataDeclaration Symbol ()
opt =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        Modifier
Structural
        ()
        [Text -> Symbol
v Text
"a"]
        [ ( (),
            Text -> Symbol
v Text
"Optional.None",
            () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls () [Text -> Symbol
v Text
"a"] (Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a.
(Ord v, Semigroup a) =>
Type v a -> Type v a -> Type v a
Type.app' (Text -> Type Symbol ()
var Text
"Optional") (Text -> Type Symbol ()
var Text
"a"))
          ),
          ( (),
            Text -> Symbol
v Text
"Optional.Some",
            () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls
              ()
              [Text -> Symbol
v Text
"a"]
              (Text -> Type Symbol ()
var Text
"a" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a.
(Ord v, Semigroup a) =>
Type v a -> Type v a -> Type v a
Type.app' (Text -> Type Symbol ()
var Text
"Optional") (Text -> Type Symbol ()
var Text
"a"))
          )
        ]
    eith :: DataDeclaration Symbol ()
eith =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        Modifier
Structural
        ()
        [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
        [ ( (),
            Text -> Symbol
v Text
"Either.Left",
            () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls
              ()
              [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
              (Text -> Type Symbol ()
var Text
"a" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Either") [Text -> Type Symbol ()
var Text
"a", Text -> Type Symbol ()
var Text
"b"])
          ),
          ( (),
            Text -> Symbol
v Text
"Either.Right",
            () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls
              ()
              [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
              (Text -> Type Symbol ()
var Text
"b" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Either") [Text -> Type Symbol ()
var Text
"a", Text -> Type Symbol ()
var Text
"b"])
          )
        ]
    rewriteCase :: DataDeclaration Symbol ()
rewriteCase =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"a116f0f1a8d16aba115b7790b09c56820be48798d9fef64fda3ec2325388f769")
        ()
        [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
        [ ( (),
            Text -> Symbol
v Text
"RewriteCase.RewriteCase",
            () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls
              ()
              [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
              (Text -> Type Symbol ()
var Text
"a" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` (Text -> Type Symbol ()
var Text
"b" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"RewriteCase") [Text -> Type Symbol ()
var Text
"a", Text -> Type Symbol ()
var Text
"b"]))
          )
        ]
    rewriteTerm :: DataDeclaration Symbol ()
rewriteTerm =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"d577219dc862f148bbdbeb78ae977f6a7da22eb44a1b43d484cabd3e4d7e76a1")
        ()
        [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
        [ ( (),
            Text -> Symbol
v Text
"RewriteTerm.RewriteTerm",
            () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls
              ()
              [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
              (Text -> Type Symbol ()
var Text
"a" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` (Text -> Type Symbol ()
var Text
"b" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"RewriteTerm") [Text -> Type Symbol ()
var Text
"a", Text -> Type Symbol ()
var Text
"b"]))
          )
        ]
    rewriteType :: DataDeclaration Symbol ()
rewriteType =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"f9ae4c4263c2f173deeb550dc1f798147c301ea3a6b306810988e4634834507b")
        ()
        [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
        [ ( (),
            Text -> Symbol
v Text
"RewriteSignature.RewriteSignature",
            () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls
              ()
              [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
              ((Text -> Type Symbol ()
var Text
"a" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` (Text -> Type Symbol ()
var Text
"b" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Unit")) Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"RewriteSignature") [Text -> Type Symbol ()
var Text
"a", Text -> Type Symbol ()
var Text
"b"])
          )
        ]
    rewrites :: DataDeclaration Symbol ()
rewrites =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"f64795bf31f7eb41e59b31379d6576a4abaca5b4c1bfc0b8c211e608906aff1a")
        ()
        [Text -> Symbol
v Text
"a"]
        [ ( (),
            Text -> Symbol
v Text
"Rewrites.Rewrites",
            () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls
              ()
              [Text -> Symbol
v Text
"a"]
              (Text -> Type Symbol ()
var Text
"a" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Rewrites") [Text -> Type Symbol ()
var Text
"a"])
          )
        ]
    isTest :: DataDeclaration Symbol ()
isTest =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"e6dca08b40458b03ca1660cfbdaecaa7279b42d18257898b5fd1c34596aac36f")
        ()
        []
        [((), Text -> Symbol
v Text
"IsTest.IsTest", Text -> Type Symbol ()
var Text
"IsTest")]
    isPropagated :: DataDeclaration Symbol ()
isPropagated =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"b28d929d0a73d2c18eac86341a3bb9399f8550c11b5f35eabb2751e6803ccc20")
        ()
        []
        [((), Text -> Symbol
v Text
"IsPropagated.IsPropagated", Text -> Type Symbol ()
var Text
"IsPropagated")]
    fmode :: DataDeclaration Symbol ()
fmode =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"3c11ba4f0a5d8fedd427b476cdd2d7673197d11e")
        ()
        []
        [ ((), Text -> Symbol
v Text
"io2.FileMode.Read", Text -> Type Symbol ()
var Text
"io2.FileMode"),
          ((), Text -> Symbol
v Text
"io2.FileMode.Write", Text -> Type Symbol ()
var Text
"io2.FileMode"),
          ((), Text -> Symbol
v Text
"io2.FileMode.Append", Text -> Type Symbol ()
var Text
"io2.FileMode"),
          ((), Text -> Symbol
v Text
"io2.FileMode.ReadWrite", Text -> Type Symbol ()
var Text
"io2.FileMode")
        ]
    bmode :: DataDeclaration Symbol ()
bmode =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"7dd9560d3826c21e5e6a7e08f575b61adcddf849")
        ()
        []
        [ ((), Text -> Symbol
v Text
"io2.BufferMode.NoBuffering", Text -> Type Symbol ()
var Text
"io2.BufferMode"),
          ((), Text -> Symbol
v Text
"io2.BufferMode.LineBuffering", Text -> Type Symbol ()
var Text
"io2.BufferMode"),
          ((), Text -> Symbol
v Text
"io2.BufferMode.BlockBuffering", Text -> Type Symbol ()
var Text
"io2.BufferMode"),
          ( (),
            Text -> Symbol
v Text
"io2.BufferMode.SizedBlockBuffering",
            () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.nat () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"io2.BufferMode"
          )
        ]
    smode :: DataDeclaration Symbol ()
smode =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"453a764f73cb4c7371d9af23b2d5ed646bf9e57c")
        ()
        []
        [ ((), Text -> Symbol
v Text
"io2.SeekMode.AbsoluteSeek", Text -> Type Symbol ()
var Text
"io2.SeekMode"),
          ((), Text -> Symbol
v Text
"io2.SeekMode.RelativeSeek", Text -> Type Symbol ()
var Text
"io2.SeekMode"),
          ((), Text -> Symbol
v Text
"io2.SeekMode.SeekFromEnd", Text -> Type Symbol ()
var Text
"io2.SeekMode")
        ]
    ioerr :: DataDeclaration Symbol ()
ioerr =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"5915e25ac83205f7885395cc6c6c988bc5ec69a1")
        ()
        []
        [ ((), Text -> Symbol
v Text
"io2.IOError.AlreadyExists", Text -> Type Symbol ()
var Text
"io2.IOError"),
          ((), Text -> Symbol
v Text
"io2.IOError.NoSuchThing", Text -> Type Symbol ()
var Text
"io2.IOError"),
          ((), Text -> Symbol
v Text
"io2.IOError.ResourceBusy", Text -> Type Symbol ()
var Text
"io2.IOError"),
          ((), Text -> Symbol
v Text
"io2.IOError.ResourceExhausted", Text -> Type Symbol ()
var Text
"io2.IOError"),
          ((), Text -> Symbol
v Text
"io2.IOError.EOF", Text -> Type Symbol ()
var Text
"io2.IOError"),
          ((), Text -> Symbol
v Text
"io2.IOError.IllegalOperation", Text -> Type Symbol ()
var Text
"io2.IOError"),
          ((), Text -> Symbol
v Text
"io2.IOError.PermissionDenied", Text -> Type Symbol ()
var Text
"io2.IOError"),
          ((), Text -> Symbol
v Text
"io2.IOError.UserError", Text -> Type Symbol ()
var Text
"io2.IOError")
        ]
    failure :: DataDeclaration Symbol ()
failure =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"52ad89274a358b9c802792aa05915e25ac83205f7885395cc6c6c988bc5ec69a1")
        ()
        []
        [ ((), Text -> Symbol
v Text
"io2.Failure.Failure", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.typeLink () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.any () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"io2.Failure")))
        ]

    tlsFailure :: DataDeclaration v ()
tlsFailure =
      Modifier
-> () -> [v] -> [((), v, Type v ())] -> DataDeclaration v ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"df5ba835130b227ab83d02d1feff5402455a732d613b51dee32230d2f2d067c6")
        ()
        []
        []

    ioFailure :: DataDeclaration v ()
ioFailure =
      Modifier
-> () -> [v] -> [((), v, Type v ())] -> DataDeclaration v ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"009cb00e78cac9e47485cc3633c7a363939f63866ea07ab330346a2121d69a83")
        ()
        []
        []

    arrayFailure :: DataDeclaration v ()
arrayFailure =
      Modifier
-> () -> [v] -> [((), v, Type v ())] -> DataDeclaration v ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"8e877b3a45a3029904dbca9cbd8dda0ec0d147d67bd5b89027a90632c9e927fb")
        ()
        []
        []

    runtimeFailure :: DataDeclaration v ()
runtimeFailure =
      Modifier
-> () -> [v] -> [((), v, Type v ())] -> DataDeclaration v ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"1061ebd9e1b8f99fafecdf02966898fd19151cc14759a7f192e12c5071fb8986")
        ()
        []
        []

    arithmeticFailure :: DataDeclaration v ()
arithmeticFailure =
      Modifier
-> () -> [v] -> [((), v, Type v ())] -> DataDeclaration v ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"57eebfd5958d4b07c460293760f241d3e14285740bca78e2149d166e951efc07")
        ()
        []
        []

    miscFailure :: DataDeclaration v ()
miscFailure =
      Modifier
-> () -> [v] -> [((), v, Type v ())] -> DataDeclaration v ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"4bd8b3a187c5426d17c30f19efd2851fe6dcfceb302b1dec5df6dfb4214841d9")
        ()
        []
        []

    stmFailure :: DataDeclaration v ()
stmFailure =
      Modifier
-> () -> [v] -> [((), v, Type v ())] -> DataDeclaration v ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"0dd9991d6c88424007bfa0b6e55a5211d1a9b6f473ed542dad3b6ecaf94c6941")
        ()
        []
        []

    threadKilledFailure :: DataDeclaration v ()
threadKilledFailure =
      Modifier
-> () -> [v] -> [((), v, Type v ())] -> DataDeclaration v ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"e7e479ebb757edcd5acff958b00aa228ac75b0c53638d44cf9d62fca045c33cf")
        ()
        []
        []

    cryptoFailure :: DataDeclaration v ()
cryptoFailure =
      Modifier
-> () -> [v] -> [((), v, Type v ())] -> DataDeclaration v ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"09132bf0cc3f07db75be127d141da91fdd545adcff88866268dfd428e9879742")
        ()
        []
        []

    stdhnd :: DataDeclaration Symbol ()
stdhnd =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"67bf7a8e517cbb1e9f42bc078e35498212d3be3c")
        ()
        []
        [ ((), Text -> Symbol
v Text
"io2.StdHandle.StdIn", Text -> Type Symbol ()
var Text
"io2.StdHandle"),
          ((), Text -> Symbol
v Text
"io2.StdHandle.StdOut", Text -> Type Symbol ()
var Text
"io2.StdHandle"),
          ((), Text -> Symbol
v Text
"io2.StdHandle.StdErr", Text -> Type Symbol ()
var Text
"io2.StdHandle")
        ]
    seqview :: DataDeclaration Symbol ()
seqview =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        Modifier
Structural
        ()
        [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
        [ ( (),
            Text -> Symbol
v Text
"SeqView.VEmpty",
            () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls
              ()
              [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
              (Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"SeqView") [Text -> Type Symbol ()
var Text
"a", Text -> Type Symbol ()
var Text
"b"])
          ),
          ( (),
            Text -> Symbol
v Text
"SeqView.VElem",
            let sv :: Type Symbol ()
sv = Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"SeqView") [Text -> Type Symbol ()
var Text
"a", Text -> Type Symbol ()
var Text
"b"]
             in () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls
                  ()
                  [Text -> Symbol
v Text
"a", Text -> Symbol
v Text
"b"]
                  (Text -> Type Symbol ()
var Text
"a" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` (Text -> Type Symbol ()
var Text
"b" Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
sv))
          )
        ]
    tr :: DataDeclaration Symbol ()
tr =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"70621e539cd802b2ad53105697800930411a3ebc")
        ()
        []
        [ ((), Text -> Symbol
v Text
"Test.Result.Fail", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Test.Result"),
          ((), Text -> Symbol
v Text
"Test.Result.Ok", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Test.Result")
        ]
    doc :: DataDeclaration Symbol ()
doc =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"c63a75b845e4f7d01107d852e4c2485c51a50aaaa94fc61995e71bbee983a2ac3713831264adb47fb6bd1e058d5f004")
        ()
        []
        [ ((), Text -> Symbol
v Text
"Doc.Blob", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Doc"),
          ((), Text -> Symbol
v Text
"Doc.Link", () -> Id -> Type Symbol ()
forall v a. Ord v => a -> Id -> Type v a
Type.refId () Id
linkRef Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Doc"),
          ((), Text -> Symbol
v Text
"Doc.Signature", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.termLink () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Doc"),
          ((), Text -> Symbol
v Text
"Doc.Source", () -> Id -> Type Symbol ()
forall v a. Ord v => a -> Id -> Type v a
Type.refId () Id
linkRef Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Doc"),
          ((), Text -> Symbol
v Text
"Doc.Evaluate", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.termLink () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Doc"),
          ((), Text -> Symbol
v Text
"Doc.Join", () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ()) (Text -> Type Symbol ()
var Text
"Doc") Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Doc")
        ]
    link :: DataDeclaration Symbol ()
link =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"a5803524366ead2d7f3780871d48771e8142a3b48802f34a96120e230939c46bd5e182fcbe1fa64e9bff9bf741f3c04")
        ()
        []
        [ ((), Text -> Symbol
v Text
"Link.Term", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.termLink () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Link"),
          ((), Text -> Symbol
v Text
"Link.Type", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.typeLink () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Text -> Type Symbol ()
var Text
"Link")
        ]
    map :: DataDeclaration Symbol ()
map =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"s9drbo3urtmpecjn6ivkj5mn0vr11gfn")
        ()
        [Text -> Symbol
v Text
"k", Text -> Symbol
v Text
"v"]
        let forke :: Type Symbol () -> Type Symbol ()
forke = () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls () [Text -> Symbol
v Text
"k", Text -> Symbol
v Text
"v"]
            k :: Type Symbol ()
k = Text -> Type Symbol ()
var Text
"k"
            e :: Type Symbol ()
e = Text -> Type Symbol ()
var Text
"v"
            mapke :: Type Symbol ()
mapke = Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Map") [Type Symbol ()
k, Type Symbol ()
e]
         in [ ( (),
                Text -> Symbol
v Text
"Map.Bin",
                Type Symbol () -> Type Symbol ()
forke (Type Symbol () -> Type Symbol ())
-> Type Symbol () -> Type Symbol ()
forall a b. (a -> b) -> a -> b
$ () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.nat () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
k Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
e Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
mapke Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
mapke Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
mapke
              ),
              ((), Text -> Symbol
v Text
"Map.Tip", Type Symbol () -> Type Symbol ()
forke Type Symbol ()
mapke)
            ]
    set :: DataDeclaration Symbol ()
set =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        Modifier
Structural
        ()
        [Text -> Symbol
v Text
"a"]
        let va :: Type Symbol ()
va = Text -> Type Symbol ()
var Text
"a"
            mapau :: Type Symbol ()
mapau = Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Map") [Type Symbol ()
va, Text -> Type Symbol ()
var Text
"Unit"]
            seta :: Type Symbol ()
seta = Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Set") [Type Symbol ()
va]
         in [ ( (),
                Text -> Symbol
v Text
"Set.Set",
                () -> [Symbol] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [v] -> Type v a -> Type v a
Type.foralls () [Text -> Symbol
v Text
"a"] (Type Symbol () -> Type Symbol ())
-> Type Symbol () -> Type Symbol ()
forall a b. (a -> b) -> a -> b
$ Type Symbol ()
mapau Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
seta
              )
            ]

    json :: DataDeclaration Symbol ()
json =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"oml0j9g6bb2tij2s75k4v7n1nftj199i")
        ()
        []
        let json :: Type Symbol ()
json = Text -> Type Symbol ()
var Text
"Json"
            tup :: Type Symbol () -> Type Symbol () -> Type Symbol ()
tup Type Symbol ()
x Type Symbol ()
y = Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Tuple") [Type Symbol ()
x, Type Symbol ()
y]
            pair :: Type Symbol () -> Type Symbol () -> Type Symbol ()
pair Type Symbol ()
x Type Symbol ()
y = Type Symbol () -> Type Symbol () -> Type Symbol ()
tup Type Symbol ()
x (Type Symbol () -> Type Symbol () -> Type Symbol ()
tup Type Symbol ()
y (Text -> Type Symbol ()
var Text
"Unit"))
         in [ ((), Text -> Symbol
v Text
"Json.Null", Text -> Type Symbol ()
var Text
"Json"),
              ((), Text -> Symbol
v Text
"Json.Boolean", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.boolean () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
json),
              ( (),
                Text -> Symbol
v Text
"Json.Object",
                () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ()) (Type Symbol () -> Type Symbol () -> Type Symbol ()
pair (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()) Type Symbol ()
json)
                  Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
json
              ),
              ((), Text -> Symbol
v Text
"Json.Number.Unparsed", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
json),
              ((), Text -> Symbol
v Text
"Json.Text", () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
json),
              ( (),
                Text -> Symbol
v Text
"Json.Array",
                () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ()) Type Symbol ()
json Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
json
              )
            ]
    jsonParseError :: DataDeclaration Symbol ()
jsonParseError =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"u3j6g9j6daejijc5e0rcujjj3sd6j3gq")
        ()
        []
        let jpe :: Type Symbol ()
jpe = Text -> Type Symbol ()
var Text
"Json.ParseError"
         in [ ( (),
                Text -> Symbol
v Text
"Json.ParseError.ParseError",
                () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.nat () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
jpe
              )
            ]

    avro :: DataDeclaration Symbol ()
avro =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"qvcc7sqhpv38ttfjq2f2r8k88sl8euku")
        ()
        []
        let avro :: Type Symbol ()
avro = Text -> Type Symbol ()
var Text
"avro.AvroValue"
            schema :: Type Symbol ()
schema = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadSchema"
            nat :: Type Symbol ()
nat = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.nat ()
            map :: Type Symbol () -> Type Symbol () -> Type Symbol ()
map Type Symbol ()
x Type Symbol ()
y = Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Map") [Type Symbol ()
x, Type Symbol ()
y]
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
            bytes :: Type Symbol ()
bytes = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.bytes ()
            int :: Type Symbol ()
int = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.int ()
            float :: Type Symbol ()
float = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.float ()
            boolean :: Type Symbol ()
boolean = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.boolean ()
         in [ ((), Text -> Symbol
v Text
"avro.AvroValue.RecordValue", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
avro Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.BytesValue", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
bytes Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.FixedValue", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
bytes Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.ArrayValue", Type Symbol () -> Type Symbol ()
list Type Symbol ()
avro Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.MapValue", Type Symbol () -> Type Symbol () -> Type Symbol ()
map Type Symbol ()
text Type Symbol ()
avro Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.NullValue", Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.StringValue", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.EnumValue", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
nat Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.FloatValue", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
float Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.DoubleValue", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
float Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.IntValue", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
int Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.LongValue", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
int Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.BooleanValue", Type Symbol ()
boolean Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro),
              ((), Text -> Symbol
v Text
"avro.AvroValue.UnionValue", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
nat Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avro)
            ]

    avroLogicalStringType :: DataDeclaration Symbol ()
avroLogicalStringType =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"h0pekchk286pkvo3kj97ci4v94h0vgh9")
        ()
        []
        let logicalString :: Type Symbol ()
logicalString = Text -> Type Symbol ()
var Text
"avro.schema.LogicalStringType"
         in [((), Text -> Symbol
v Text
"avro.schema.LogicalStringType.UUID", Type Symbol ()
logicalString)]

    avroLogicalBytesType :: DataDeclaration Symbol ()
avroLogicalBytesType =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"iqgd92f4icrrnaij4cggq39vhtq17inl")
        ()
        []
        let decimal :: Type Symbol ()
decimal = Text -> Type Symbol ()
var Text
"avro.schema.Decimal"
            logicalBytes :: Type Symbol ()
logicalBytes = Text -> Type Symbol ()
var Text
"avro.schema.LogicalBytesType"
         in [((), Text -> Symbol
v Text
"avro.schema.LogicalBytesType.DecimalB", Type Symbol ()
decimal Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
logicalBytes)]

    avroLogicalFixedType :: DataDeclaration Symbol ()
avroLogicalFixedType =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"rnmp14qn1ugce77g9d88par2ns1eua3i")
        ()
        []
        let decimal :: Type Symbol ()
decimal = Text -> Type Symbol ()
var Text
"avro.schema.Decimal"
            logicalFixed :: Type Symbol ()
logicalFixed = Text -> Type Symbol ()
var Text
"avro.schema.LogicalFixedType"
         in [ ((), Text -> Symbol
v Text
"avro.schema.LogicalFixedType.Duration", Type Symbol ()
logicalFixed),
              ((), Text -> Symbol
v Text
"avro.schema.LogicalFixedType.DecimalF", Type Symbol ()
decimal Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
logicalFixed)
            ]

    avroDecimal :: DataDeclaration Symbol ()
avroDecimal =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"kar29s8peeugk9igfghjdrv7ngp0e8jl")
        ()
        []
        let decimal :: Type Symbol ()
decimal = Text -> Type Symbol ()
var Text
"avro.schema.Decimal"
            nat :: Type Symbol ()
nat = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.nat ()
         in [((), Text -> Symbol
v Text
"avro.schema.Decimal.Decimal", Type Symbol ()
nat Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
nat Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
decimal)]

    avroLogicalIntType :: DataDeclaration Symbol ()
avroLogicalIntType =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"kdfbu044nv0okj667o0vkjcdbu7fs576")
        ()
        []
        let logicalInt :: Type Symbol ()
logicalInt = Text -> Type Symbol ()
var Text
"avro.schema.LogicalIntType"
            avroDecimal :: Type Symbol ()
avroDecimal = Text -> Type Symbol ()
var Text
"avro.schema.Decimal"
         in [ ((), Text -> Symbol
v Text
"avro.schema.LogicalIntType.Date", Type Symbol ()
logicalInt),
              ((), Text -> Symbol
v Text
"avro.schema.LogicalIntType.TimeMillis", Type Symbol ()
logicalInt),
              ((), Text -> Symbol
v Text
"avro.schema.LogicalIntType.DecimalI", Type Symbol ()
avroDecimal Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
logicalInt)
            ]

    avroLogicalLongType :: DataDeclaration Symbol ()
avroLogicalLongType =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"baf0kq3njc0o87a1n97svg5qk4350tn8")
        ()
        []
        let logicalLong :: Type Symbol ()
logicalLong = Text -> Type Symbol ()
var Text
"avro.schema.LogicalLongType"
            avroDecimal :: Type Symbol ()
avroDecimal = Text -> Type Symbol ()
var Text
"avro.schema.Decimal"
         in [ ((), Text -> Symbol
v Text
"avro.schema.LogicalLongType.TimeMicros", Type Symbol ()
logicalLong),
              ((), Text -> Symbol
v Text
"avro.schema.LogicalLongType.TimestampMillis", Type Symbol ()
logicalLong),
              ((), Text -> Symbol
v Text
"avro.schema.LogicalLongType.TimestampMicros", Type Symbol ()
logicalLong),
              ((), Text -> Symbol
v Text
"avro.schema.LogicalLongType.LocalTimestampMillis", Type Symbol ()
logicalLong),
              ((), Text -> Symbol
v Text
"avro.schema.LogicalLongType.LocalTimestampMicros", Type Symbol ()
logicalLong),
              ((), Text -> Symbol
v Text
"avro.schema.LogicalLongType.DecimalL", Type Symbol ()
avroDecimal Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
logicalLong)
            ]

    avroDefaultValue :: DataDeclaration Symbol ()
avroDefaultValue =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"vg0ijfhcnpes0q3m64a972n8btdhp43q")
        ()
        []
        let defaultValue :: Type Symbol ()
defaultValue = Text -> Type Symbol ()
var Text
"avro.schema.DefaultValue"
            schema :: Type Symbol ()
schema = Text -> Type Symbol ()
var Text
"avro.schema.Schema"
            bytes :: Type Symbol ()
bytes = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.bytes ()
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            int :: Type Symbol ()
int = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.int ()
            boolean :: Type Symbol ()
boolean = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.boolean ()
            map :: Type Symbol () -> Type Symbol () -> Type Symbol ()
map Type Symbol ()
x Type Symbol ()
y = Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Map") [Type Symbol ()
x, Type Symbol ()
y]
            nat :: Type Symbol ()
nat = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.nat ()
            float :: Type Symbol ()
float = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.float ()
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
         in [ ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultBytes", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
bytes Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultFixed", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
bytes Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultArray", Type Symbol () -> Type Symbol ()
list Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultInt32", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
int Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultInt64", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
int Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultEnum", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
nat Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultBoolean", Type Symbol ()
boolean Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultNull", Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultMap", Type Symbol () -> Type Symbol () -> Type Symbol ()
map Type Symbol ()
text Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultString", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultFloat", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
float Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultDouble", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
float Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultRecord", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol () -> Type Symbol ()
map Type Symbol ()
text Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue),
              ((), Text -> Symbol
v Text
"avro.schema.DefaultValue.DefaultUnion", Type Symbol () -> Type Symbol ()
list Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue)
            ]

    avroSchema :: DataDeclaration Symbol ()
avroSchema =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"i3t59pro14podvneaqa6775kdt7j10h0")
        ()
        []
        let schema :: Type Symbol ()
schema = Text -> Type Symbol ()
var Text
"avro.schema.Schema"
            fixed :: Type Symbol ()
fixed = Text -> Type Symbol ()
var Text
"avro.schema.AvroFixed"
            enum :: Type Symbol ()
enum = Text -> Type Symbol ()
var Text
"avro.schema.AvroEnum"
            defaultValue :: Type Symbol ()
defaultValue = Text -> Type Symbol ()
var Text
"avro.schema.DefaultValue"
            logicalString :: Type Symbol ()
logicalString = Text -> Type Symbol ()
var Text
"avro.schema.LogicalStringType"
            logicalInt :: Type Symbol ()
logicalInt = Text -> Type Symbol ()
var Text
"avro.schema.LogicalIntType"
            logicalLong :: Type Symbol ()
logicalLong = Text -> Type Symbol ()
var Text
"avro.schema.LogicalLongType"
            logicalBytes :: Type Symbol ()
logicalBytes = Text -> Type Symbol ()
var Text
"avro.schema.LogicalBytesType"
            typeName :: Type Symbol ()
typeName = Text -> Type Symbol ()
var Text
"avro.schema.TypeName"
            avroRecord :: Type Symbol ()
avroRecord = Text -> Type Symbol ()
var Text
"avro.schema.AvroRecord"
            opt :: Type Symbol () -> Type Symbol ()
opt = Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a.
(Ord v, Semigroup a) =>
Type v a -> Type v a -> Type v a
Type.app' (Text -> Type Symbol ()
var Text
"Optional")
            map :: Type Symbol () -> Type Symbol () -> Type Symbol ()
map Type Symbol ()
x Type Symbol ()
y = Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Map") [Type Symbol ()
x, Type Symbol ()
y]
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
         in [ ((), Text -> Symbol
v Text
"avro.schema.Schema.Fixed", Type Symbol ()
fixed Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Enum", Type Symbol ()
enum Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Map", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol () -> Type Symbol ()
map Type Symbol ()
text Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Int", Type Symbol () -> Type Symbol ()
opt Type Symbol ()
logicalInt Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Union", Type Symbol () -> Type Symbol ()
list Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Long", Type Symbol () -> Type Symbol ()
opt Type Symbol ()
logicalLong Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.NamedType", Type Symbol ()
typeName Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Bytes", Type Symbol () -> Type Symbol ()
opt Type Symbol ()
logicalBytes Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Array", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Null", Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Boolean", Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Float", Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Double", Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.String", Type Symbol () -> Type Symbol ()
opt Type Symbol ()
logicalString Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.Schema.Record", Type Symbol ()
avroRecord Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema)
            ]

    avroReadFloat :: DataDeclaration Symbol ()
avroReadFloat =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"j9mrc4pakmmu0onnf886qmvporqki488")
        ()
        []
        let readFloat :: Type Symbol ()
readFloat = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadFloat"
         in [ ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadFloat.FloatFromInt32", Type Symbol ()
readFloat),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadFloat.FloatFromInt64", Type Symbol ()
readFloat),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadFloat.ReadFloat", Type Symbol ()
readFloat)
            ]

    avroFixed :: DataDeclaration Symbol ()
avroFixed =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"kh3gqke6sgjumbug1fmnlbq19gobs4b4")
        ()
        []
        let fixed :: Type Symbol ()
fixed = Text -> Type Symbol ()
var Text
"avro.schema.AvroFixed"
            typeName :: Type Symbol ()
typeName = Text -> Type Symbol ()
var Text
"avro.schema.TypeName"
            logicalFixed :: Type Symbol ()
logicalFixed = Text -> Type Symbol ()
var Text
"avro.schema.LogicalFixedType"
            opt :: Type Symbol () -> Type Symbol ()
opt = Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a.
(Ord v, Semigroup a) =>
Type v a -> Type v a -> Type v a
Type.app' (Text -> Type Symbol ()
var Text
"Optional")
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
            nat :: Type Symbol ()
nat = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.nat ()
         in [((), Text -> Symbol
v Text
"avro.schema.AvroFixed.AvroFixed", Type Symbol ()
typeName Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
typeName Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
nat Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
logicalFixed Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
fixed)]

    avroReadDouble :: DataDeclaration Symbol ()
avroReadDouble =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"od9j87j4ga5nss8vtqjii34l4fajkji8")
        ()
        []
        let readDouble :: Type Symbol ()
readDouble = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadDouble"
         in [ ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadDouble.DoubleFromInt32", Type Symbol ()
readDouble),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadDouble.DoubleFromInt64", Type Symbol ()
readDouble),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadDouble.DoubleFromFloat", Type Symbol ()
readDouble),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadDouble.ReadDouble", Type Symbol ()
readDouble)
            ]

    avroTypeName :: DataDeclaration Symbol ()
avroTypeName =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"pbiqt5r9j4dmctk9kafv1ta3okd3nt24")
        ()
        []
        let typeName :: Type Symbol ()
typeName = Text -> Type Symbol ()
var Text
"avro.schema.TypeName"
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
         in [((), Text -> Symbol
v Text
"avro.schema.TypeName.TypeName", Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
typeName)]

    avroReadRecord :: DataDeclaration Symbol ()
avroReadRecord =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"iinf3n46okum42uqpgdcob58ngjrbile")
        ()
        []
        let readRecord :: Type Symbol ()
readRecord = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadRecord"
            typeName :: Type Symbol ()
typeName = Text -> Type Symbol ()
var Text
"avro.schema.TypeName"
            readField :: Type Symbol ()
readField = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadField"
            opt :: Type Symbol () -> Type Symbol ()
opt = Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a.
(Ord v, Semigroup a) =>
Type v a -> Type v a -> Type v a
Type.app' (Text -> Type Symbol ()
var Text
"Optional")
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
         in [((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadRecord.ReadRecord", Type Symbol ()
typeName Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
typeName Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
readField Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
readRecord)]

    avroReadField :: DataDeclaration Symbol ()
avroReadField =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"nrdvcs03lkqbm5j8f6qcg77eu9vqs1b1")
        ()
        []
        let readField :: Type Symbol ()
readField = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadField"
            fieldStatus :: Type Symbol ()
fieldStatus = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.FieldStatus"
            readSchema :: Type Symbol ()
readSchema = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadSchema"
            order :: Type Symbol ()
order = Text -> Type Symbol ()
var Text
"avro.schema.Order"
            defaultValue :: Type Symbol ()
defaultValue = Text -> Type Symbol ()
var Text
"avro.schema.DefaultValue"
            opt :: Type Symbol () -> Type Symbol ()
opt = Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a.
(Ord v, Semigroup a) =>
Type v a -> Type v a -> Type v a
Type.app' (Text -> Type Symbol ()
var Text
"Optional")
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
         in [((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadField.ReadField", Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
readSchema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
fieldStatus Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
order Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
readField)]

    avroOrder :: DataDeclaration Symbol ()
avroOrder =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"f2lv9b1fdffaouhepfu1g02s7dbi804e")
        ()
        []
        let avroOrder :: Type Symbol ()
avroOrder = Text -> Type Symbol ()
var Text
"avro.schema.Order"
         in [ ((), Text -> Symbol
v Text
"avro.schema.Order.Ascending", Type Symbol ()
avroOrder),
              ((), Text -> Symbol
v Text
"avro.schema.Order.Descending", Type Symbol ()
avroOrder),
              ((), Text -> Symbol
v Text
"avro.schema.Order.Ignore", Type Symbol ()
avroOrder)
            ]

    avroFieldStatus :: DataDeclaration Symbol ()
avroFieldStatus =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"o0hrihuckkskb90jvob2mpiclv8ocj1a")
        ()
        []
        let fieldStatus :: Type Symbol ()
fieldStatus = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.FieldStatus"
            defaultValue :: Type Symbol ()
defaultValue = Text -> Type Symbol ()
var Text
"avro.schema.DefaultValue"
            nat :: Type Symbol ()
nat = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.nat ()
         in [ ((), Text -> Symbol
v Text
"avro.schema.deconflicted.FieldStatus.AsIs", Type Symbol ()
nat Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
fieldStatus),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.FieldStatus.Ignored", Type Symbol ()
fieldStatus),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.FieldStatus.Defaulted", Type Symbol ()
nat Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
fieldStatus)
            ]

    avroField :: DataDeclaration Symbol ()
avroField =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"hdtsj889pvvvhmn482d9ipnlchjl16ua")
        ()
        []
        let avroField :: Type Symbol ()
avroField = Text -> Type Symbol ()
var Text
"avro.schema.AvroField"
            avroSchema :: Type Symbol ()
avroSchema = Text -> Type Symbol ()
var Text
"avro.schema.Schema"
            avroOrder :: Type Symbol ()
avroOrder = Text -> Type Symbol ()
var Text
"avro.schema.Order"
            defaultValue :: Type Symbol ()
defaultValue = Text -> Type Symbol ()
var Text
"avro.schema.DefaultValue"
            opt :: Type Symbol () -> Type Symbol ()
opt = Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a.
(Ord v, Semigroup a) =>
Type v a -> Type v a -> Type v a
Type.app' (Text -> Type Symbol ()
var Text
"Optional")
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
         in [((), Text -> Symbol
v Text
"avro.schema.AvroField.AvroField", Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avroSchema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
avroOrder Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avroField)]

    avroEnum :: DataDeclaration Symbol ()
avroEnum =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"h3c1uc2gnhv0q2k0sqnsc28m3vvpdf0b")
        ()
        []
        let avroEnum :: Type Symbol ()
avroEnum = Text -> Type Symbol ()
var Text
"avro.schema.AvroEnum"
            typeName :: Type Symbol ()
typeName = Text -> Type Symbol ()
var Text
"avro.schema.TypeName"
            opt :: Type Symbol () -> Type Symbol ()
opt = Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a.
(Ord v, Semigroup a) =>
Type v a -> Type v a -> Type v a
Type.app' (Text -> Type Symbol ()
var Text
"Optional")
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
         in [((), Text -> Symbol
v Text
"avro.schema.AvroEnum.AvroEnum", Type Symbol ()
typeName Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
typeName Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avroEnum)]

    avroRecord :: DataDeclaration Symbol ()
avroRecord =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"caboag889sudpeepia4436ae50346077")
        ()
        []
        let avroRecord :: Type Symbol ()
avroRecord = Text -> Type Symbol ()
var Text
"avro.schema.AvroRecord"
            typeName :: Type Symbol ()
typeName = Text -> Type Symbol ()
var Text
"avro.schema.TypeName"
            avroField :: Type Symbol ()
avroField = Text -> Type Symbol ()
var Text
"avro.schema.AvroField"
            opt :: Type Symbol () -> Type Symbol ()
opt = Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a.
(Ord v, Semigroup a) =>
Type v a -> Type v a -> Type v a
Type.app' (Text -> Type Symbol ()
var Text
"Optional")
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
         in [((), Text -> Symbol
v Text
"avro.schema.AvroRecord.AvroRecord", Type Symbol ()
typeName Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
text Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
typeName Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
avroField Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
avroRecord)]

    avroReadLong :: DataDeclaration Symbol ()
avroReadLong =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"bm61dmnipg0geplp9g3avrd64fshqofk")
        ()
        []
        let readLong :: Type Symbol ()
readLong = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadLong"
         in [ ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadLong.LongFromInt32", Type Symbol ()
readLong),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadLong.ReadLong", Type Symbol ()
readLong)
            ]

    avroReadSchema :: DataDeclaration Symbol ()
avroReadSchema =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        (Text -> Modifier
Unique Text
"h7uslccb5g625skvdq6mpp8hjvl645kt")
        ()
        []
        let schema :: Type Symbol ()
schema = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadSchema"
            logicalString :: Type Symbol ()
logicalString = Text -> Type Symbol ()
var Text
"avro.schema.LogicalStringType"
            logicalBytes :: Type Symbol ()
logicalBytes = Text -> Type Symbol ()
var Text
"avro.schema.LogicalBytesType"
            logicalInt :: Type Symbol ()
logicalInt = Text -> Type Symbol ()
var Text
"avro.schema.LogicalIntType"
            logicalLong :: Type Symbol ()
logicalLong = Text -> Type Symbol ()
var Text
"avro.schema.LogicalLongType"
            defaultValue :: Type Symbol ()
defaultValue = Text -> Type Symbol ()
var Text
"avro.schema.DefaultValue"
            readFloat :: Type Symbol ()
readFloat = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadFloat"
            avroFixed :: Type Symbol ()
avroFixed = Text -> Type Symbol ()
var Text
"avro.schema.AvroFixed"
            readDouble :: Type Symbol ()
readDouble = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadDouble"
            typeName :: Type Symbol ()
typeName = Text -> Type Symbol ()
var Text
"avro.schema.TypeName"
            readRecord :: Type Symbol ()
readRecord = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadRecord"
            avroEnum :: Type Symbol ()
avroEnum = Text -> Type Symbol ()
var Text
"avro.schema.AvroEnum"
            readLong :: Type Symbol ()
readLong = Text -> Type Symbol ()
var Text
"avro.schema.deconflicted.ReadLong"
            tup :: Type Symbol () -> Type Symbol () -> Type Symbol ()
tup Type Symbol ()
x Type Symbol ()
y = Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Tuple") [Type Symbol ()
x, Type Symbol ()
y]
            pair :: Type Symbol () -> Type Symbol () -> Type Symbol ()
pair Type Symbol ()
x Type Symbol ()
y = Type Symbol () -> Type Symbol () -> Type Symbol ()
tup Type Symbol ()
x (Type Symbol () -> Type Symbol () -> Type Symbol ()
tup Type Symbol ()
y (Text -> Type Symbol ()
var Text
"Unit"))
            opt :: Type Symbol () -> Type Symbol ()
opt = Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a.
(Ord v, Semigroup a) =>
Type v a -> Type v a -> Type v a
Type.app' (Text -> Type Symbol ()
var Text
"Optional")
            map :: Type Symbol () -> Type Symbol () -> Type Symbol ()
map Type Symbol ()
x Type Symbol ()
y = Type Symbol () -> [Type Symbol ()] -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> [Type v a] -> Type v a
Type.apps' (Text -> Type Symbol ()
var Text
"Map") [Type Symbol ()
x, Type Symbol ()
y]
            list :: Type Symbol () -> Type Symbol ()
list = () -> Type Symbol () -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app () (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.list ())
            text :: Type Symbol ()
text = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.text ()
            nat :: Type Symbol ()
nat = () -> Type Symbol ()
forall v a. Ord v => a -> Type v a
Type.nat ()
         in [ ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Null", Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Boolean", Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.String", Type Symbol () -> Type Symbol ()
opt Type Symbol ()
logicalString Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Float", Type Symbol ()
readFloat Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Fixed", Type Symbol ()
avroFixed Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Double", Type Symbol ()
readDouble Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Bytes", Type Symbol () -> Type Symbol ()
opt Type Symbol ()
logicalBytes Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.NamedType", Type Symbol ()
typeName Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Int", Type Symbol () -> Type Symbol ()
opt Type Symbol ()
logicalInt Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Long", Type Symbol ()
readLong Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
opt Type Symbol ()
logicalLong Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Map", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol () -> Type Symbol ()
map Type Symbol ()
text Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Record", Type Symbol ()
readRecord Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.FreeUnion", Type Symbol ()
nat Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Enum", Type Symbol ()
avroEnum Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Union", Type Symbol () -> Type Symbol ()
list (Type Symbol () -> Type Symbol () -> Type Symbol ()
pair Type Symbol ()
nat Type Symbol ()
schema) Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema),
              ((), Text -> Symbol
v Text
"avro.schema.deconflicted.ReadSchema.Array", Type Symbol ()
schema Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
list Type Symbol ()
defaultValue Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol ()
schema)
            ]

builtinEffectDecls :: [(Symbol, Reference.Id, DD.EffectDeclaration Symbol ())]
builtinEffectDecls :: [(Symbol, Id, EffectDeclaration Symbol ())]
builtinEffectDecls =
  case Map Symbol (DataDeclaration Symbol ())
-> ResolutionResult () [(Symbol, Id, DataDeclaration Symbol ())]
forall v a.
Var v =>
Map v (DataDeclaration v a)
-> ResolutionResult a [(v, Id, DataDeclaration v a)]
hashDataDecls (Map Symbol (DataDeclaration Symbol ())
 -> ResolutionResult () [(Symbol, Id, DataDeclaration Symbol ())])
-> Map Symbol (DataDeclaration Symbol ())
-> ResolutionResult () [(Symbol, Id, DataDeclaration Symbol ())]
forall a b. (a -> b) -> a -> b
$ [(Symbol, DataDeclaration Symbol ())]
-> Map Symbol (DataDeclaration Symbol ())
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text -> Symbol
v Text
"Exception", DataDeclaration Symbol ()
exception)] of
    Right [(Symbol, Id, DataDeclaration Symbol ())]
a -> ASetter
  (Symbol, Id, DataDeclaration Symbol ())
  (Symbol, Id, EffectDeclaration Symbol ())
  (DataDeclaration Symbol ())
  (EffectDeclaration Symbol ())
-> (DataDeclaration Symbol () -> EffectDeclaration Symbol ())
-> (Symbol, Id, DataDeclaration Symbol ())
-> (Symbol, Id, EffectDeclaration Symbol ())
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter
  (Symbol, Id, DataDeclaration Symbol ())
  (Symbol, Id, EffectDeclaration Symbol ())
  (DataDeclaration Symbol ())
  (EffectDeclaration Symbol ())
forall s t a b. Field3 s t a b => Lens s t a b
Lens
  (Symbol, Id, DataDeclaration Symbol ())
  (Symbol, Id, EffectDeclaration Symbol ())
  (DataDeclaration Symbol ())
  (EffectDeclaration Symbol ())
_3 DataDeclaration Symbol () -> EffectDeclaration Symbol ()
forall v a. DataDeclaration v a -> EffectDeclaration v a
DD.EffectDeclaration ((Symbol, Id, DataDeclaration Symbol ())
 -> (Symbol, Id, EffectDeclaration Symbol ()))
-> [(Symbol, Id, DataDeclaration Symbol ())]
-> [(Symbol, Id, EffectDeclaration Symbol ())]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Symbol, Id, DataDeclaration Symbol ())]
a
    Left Seq (ResolutionFailure ())
e -> [Char] -> [(Symbol, Id, EffectDeclaration Symbol ())]
forall a. HasCallStack => [Char] -> a
error ([Char] -> [(Symbol, Id, EffectDeclaration Symbol ())])
-> [Char] -> [(Symbol, Id, EffectDeclaration Symbol ())]
forall a b. (a -> b) -> a -> b
$ [Char]
"builtinEffectDecls: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Seq (ResolutionFailure ()) -> [Char]
forall a. Show a => a -> [Char]
show Seq (ResolutionFailure ())
e
  where
    v :: Text -> Symbol
v = Text -> Symbol
forall v. Var v => Text -> v
Var.named
    var :: Text -> Type Symbol ()
var Text
name = () -> Symbol -> Type Symbol ()
forall v a. Ord v => a -> v -> Type v a
Type.var () (Text -> Symbol
v Text
name)
    arr :: Type Symbol () -> Type Symbol () -> Type Symbol ()
arr = Type Symbol () -> Type Symbol () -> Type Symbol ()
forall a v.
(Semigroup a, Ord v) =>
Type v a -> Type v a -> Type v a
Type.arrow'
    self :: Type Symbol () -> Type Symbol ()
self Type Symbol ()
t = Type Symbol () -> Type Symbol ()
forall v a. Var v => Type v a -> Type v a
Type.cleanupAbilityLists (Type Symbol () -> Type Symbol ())
-> Type Symbol () -> Type Symbol ()
forall a b. (a -> b) -> a -> b
$ () -> [Type Symbol ()] -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> [Type v a] -> Type v a -> Type v a
Type.effect () [Text -> Type Symbol ()
var Text
"Exception"] Type Symbol ()
t
    exception :: DataDeclaration Symbol ()
exception =
      Modifier
-> ()
-> [Symbol]
-> [((), Symbol, Type Symbol ())]
-> DataDeclaration Symbol ()
forall v a.
Modifier -> a -> [v] -> [(a, v, Type v a)] -> DataDeclaration v a
DataDeclaration
        Modifier
Structural
        ()
        []
        [ ((), Text -> Symbol
v Text
"Exception.raise", () -> Symbol -> Type Symbol () -> Type Symbol ()
forall v a. Ord v => a -> v -> Type v a -> Type v a
Type.forAll () (Text -> Symbol
v Text
"x") (() -> Type Symbol ()
forall v a. Ord v => a -> Type v a
failureType () Type Symbol () -> Type Symbol () -> Type Symbol ()
`arr` Type Symbol () -> Type Symbol ()
self (Text -> Type Symbol ()
var Text
"x")))
        ]

pattern UnitRef :: Reference
pattern $mUnitRef :: forall {r}.
Reference' Text Hash -> ((# #) -> r) -> ((# #) -> r) -> r
UnitRef <- (unUnitRef -> True)

pattern PairRef :: Reference
pattern $mPairRef :: forall {r}.
Reference' Text Hash -> ((# #) -> r) -> ((# #) -> r) -> r
PairRef <- (unPairRef -> True)

pattern EitherRef :: Reference
pattern $mEitherRef :: forall {r}.
Reference' Text Hash -> ((# #) -> r) -> ((# #) -> r) -> r
EitherRef <- ((==) eitherRef -> True)

pattern OptionalRef :: Reference
pattern $mOptionalRef :: forall {r}.
Reference' Text Hash -> ((# #) -> r) -> ((# #) -> r) -> r
OptionalRef <- (unOptionalRef -> True)

pattern OptionalNone' :: ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mOptionalNone' :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> ((# #) -> r) -> ((# #) -> r) -> r
OptionalNone' <- Term.Constructor' (ConstructorReference OptionalRef ((==) noneId -> True))

pattern OptionalSome' ::
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a ->
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mOptionalSome' :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Term (F typeVar typeAnn patternAnn) v a -> r)
-> ((# #) -> r)
-> r
OptionalSome' d <- Term.App' (Term.Constructor' (ConstructorReference OptionalRef ((==) someId -> True))) d

pattern TupleType' :: (Var v) => [Type v a] -> Type v a
pattern $mTupleType' :: forall {r} {v} {a}.
Var v =>
Type v a -> ([Type v a] -> r) -> ((# #) -> r) -> r
TupleType' ts <- (unTupleType -> Just ts)

pattern TupleTerm' :: [Term2 vt at ap v a] -> Term2 vt at ap v a
pattern $mTupleTerm' :: forall {r} {vt} {at} {ap} {v} {a}.
Term2 vt at ap v a
-> ([Term2 vt at ap v a] -> r) -> ((# #) -> r) -> r
TupleTerm' xs <- (unTupleTerm -> Just xs)

pattern TuplePattern :: [Pattern.Pattern loc] -> Pattern.Pattern loc
pattern $mTuplePattern :: forall {r} {loc}.
Pattern loc -> ([Pattern loc] -> r) -> ((# #) -> r) -> r
TuplePattern ps <- (unTuplePattern -> Just ps)

pattern EitherLeft' :: Term2 vt at ap v a -> Term2 vt at ap v a
pattern $mEitherLeft' :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Term (F typeVar typeAnn patternAnn) v a -> r)
-> ((# #) -> r)
-> r
EitherLeft' tm <- (unLeftTerm -> Just tm)

pattern EitherRight' :: Term2 vt at ap v a -> Term2 vt at ap v a
pattern $mEitherRight' :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Term (F typeVar typeAnn patternAnn) v a -> r)
-> ((# #) -> r)
-> r
EitherRight' tm <- (unRightTerm -> Just tm)

pattern EitherLeftId :: ConstructorId
pattern $mEitherLeftId :: forall {r}. ConstructorId -> ((# #) -> r) -> ((# #) -> r) -> r
EitherLeftId <- ((==) eitherLeftId -> True)

pattern EitherRightId :: ConstructorId
pattern $mEitherRightId :: forall {r}. ConstructorId -> ((# #) -> r) -> ((# #) -> r) -> r
EitherRightId <- ((==) eitherRightId -> True)

unLeftTerm,
  unRightTerm ::
    Term.Term2 vt at ap v a ->
    Maybe (Term.Term2 vt at ap v a)
unRightTerm :: forall vt at ap v a.
Term2 vt at ap v a -> Maybe (Term2 vt at ap v a)
unRightTerm Term2 vt at ap v a
t = case Term2 vt at ap v a
t of
  Term.App' (Term.Constructor' (ConstructorReference Reference' Text Hash
EitherRef ConstructorId
EitherRightId)) Term2 vt at ap v a
tm ->
    Term2 vt at ap v a -> Maybe (Term2 vt at ap v a)
forall a. a -> Maybe a
Just Term2 vt at ap v a
tm
  Term2 vt at ap v a
_ -> Maybe (Term2 vt at ap v a)
forall a. Maybe a
Nothing
unLeftTerm :: forall vt at ap v a.
Term2 vt at ap v a -> Maybe (Term2 vt at ap v a)
unLeftTerm Term2 vt at ap v a
t = case Term2 vt at ap v a
t of
  Term.App' (Term.Constructor' (ConstructorReference Reference' Text Hash
EitherRef ConstructorId
EitherLeftId)) Term2 vt at ap v a
tm ->
    Term2 vt at ap v a -> Maybe (Term2 vt at ap v a)
forall a. a -> Maybe a
Just Term2 vt at ap v a
tm
  Term2 vt at ap v a
_ -> Maybe (Term2 vt at ap v a)
forall a. Maybe a
Nothing

-- some pattern synonyms to make pattern matching on some of these constants more pleasant
pattern DocRef :: Reference
pattern $mDocRef :: forall {r}.
Reference' Text Hash -> ((# #) -> r) -> ((# #) -> r) -> r
DocRef <- ((== docRef) -> True)

pattern DocJoin ::
  Seq (ABT.Term (Term.F typeVar typeAnn patternAnn) v a) ->
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mDocJoin :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Seq (Term (F typeVar typeAnn patternAnn) v a) -> r)
-> ((# #) -> r)
-> r
DocJoin segs <- Term.App' (Term.Constructor' (ConstructorReference DocRef DocJoinId)) (Term.List' segs)

pattern DocBlob :: Text -> ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mDocBlob :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Text -> r) -> ((# #) -> r) -> r
DocBlob txt <- Term.App' (Term.Constructor' (ConstructorReference DocRef DocBlobId)) (Term.Text' txt)

pattern DocLink ::
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a ->
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mDocLink :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Term (F typeVar typeAnn patternAnn) v a -> r)
-> ((# #) -> r)
-> r
DocLink link <- Term.App' (Term.Constructor' (ConstructorReference DocRef DocLinkId)) link

pattern DocSource ::
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a ->
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mDocSource :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Term (F typeVar typeAnn patternAnn) v a -> r)
-> ((# #) -> r)
-> r
DocSource link <- Term.App' (Term.Constructor' (ConstructorReference DocRef DocSourceId)) link

pattern DocSignature ::
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a ->
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mDocSignature :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Term (F typeVar typeAnn patternAnn) v a -> r)
-> ((# #) -> r)
-> r
DocSignature link <- Term.App' (Term.Constructor' (ConstructorReference DocRef DocSignatureId)) link

pattern DocEvaluate ::
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a ->
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mDocEvaluate :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Term (F typeVar typeAnn patternAnn) v a -> r)
-> ((# #) -> r)
-> r
DocEvaluate link <- Term.App' (Term.Constructor' (ConstructorReference DocRef DocEvaluateId)) link

pattern Doc :: ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mDoc :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> ((# #) -> r) -> ((# #) -> r) -> r
Doc <- Term.App' (Term.Constructor' (ConstructorReference DocRef _)) _

pattern DocSignatureId :: ConstructorId
pattern $mDocSignatureId :: forall {r}. ConstructorId -> ((# #) -> r) -> ((# #) -> r) -> r
DocSignatureId <- ((== docSignatureId) -> True)

pattern DocBlobId :: ConstructorId
pattern $mDocBlobId :: forall {r}. ConstructorId -> ((# #) -> r) -> ((# #) -> r) -> r
DocBlobId <- ((== docBlobId) -> True)

pattern DocLinkId :: ConstructorId
pattern $mDocLinkId :: forall {r}. ConstructorId -> ((# #) -> r) -> ((# #) -> r) -> r
DocLinkId <- ((== docLinkId) -> True)

pattern DocSourceId :: ConstructorId
pattern $mDocSourceId :: forall {r}. ConstructorId -> ((# #) -> r) -> ((# #) -> r) -> r
DocSourceId <- ((== docSourceId) -> True)

pattern DocEvaluateId :: ConstructorId
pattern $mDocEvaluateId :: forall {r}. ConstructorId -> ((# #) -> r) -> ((# #) -> r) -> r
DocEvaluateId <- ((== docEvaluateId) -> True)

pattern DocJoinId :: ConstructorId
pattern $mDocJoinId :: forall {r}. ConstructorId -> ((# #) -> r) -> ((# #) -> r) -> r
DocJoinId <- ((== docJoinId) -> True)

pattern LinkTermId :: ConstructorId
pattern $mLinkTermId :: forall {r}. ConstructorId -> ((# #) -> r) -> ((# #) -> r) -> r
LinkTermId <- ((== linkTermId) -> True)

pattern LinkTypeId :: ConstructorId
pattern $mLinkTypeId :: forall {r}. ConstructorId -> ((# #) -> r) -> ((# #) -> r) -> r
LinkTypeId <- ((== linkTypeId) -> True)

pattern LinkRef :: Reference
pattern $mLinkRef :: forall {r}.
Reference' Text Hash -> ((# #) -> r) -> ((# #) -> r) -> r
LinkRef <- ((== linkRef) -> True)

pattern LinkTerm :: ABT.Term (Term.F typeVar typeAnn patternAnn) v a -> ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mLinkTerm :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Term (F typeVar typeAnn patternAnn) v a -> r)
-> ((# #) -> r)
-> r
LinkTerm tm <- Term.App' (Term.Constructor' (ConstructorReference LinkRef LinkTermId)) tm

pattern LinkType ::
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a ->
  ABT.Term (Term.F typeVar typeAnn patternAnn) v a
pattern $mLinkType :: forall {r} {typeVar} {typeAnn} {patternAnn} {v} {a}.
Term (F typeVar typeAnn patternAnn) v a
-> (Term (F typeVar typeAnn patternAnn) v a -> r)
-> ((# #) -> r)
-> r
LinkType ty <- Term.App' (Term.Constructor' (ConstructorReference LinkRef LinkTypeId)) ty

unitType,
  pairType,
  optionalType,
  testResultListType,
  eitherType,
  ioErrorType,
  fileModeType,
  filePathType,
  bufferModeType,
  seekModeType,
  stdHandleType,
  failureType,
  thunkArgType,
  exceptionType ::
    (Ord v) => a -> Type v a
unitType :: forall v a. Ord v => a -> Type v a
unitType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
unitRef
-- used for the type of the argument to force a thunk
thunkArgType :: forall v a. Ord v => a -> Type v a
thunkArgType = a -> Type v a
forall v a. Ord v => a -> Type v a
unitType
pairType :: forall v a. Ord v => a -> Type v a
pairType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
pairRef
testResultListType :: forall v a. Ord v => a -> Type v a
testResultListType a
a = a -> Type v a -> Type v a -> Type v a
forall v a. Ord v => a -> Type v a -> Type v a -> Type v a
Type.app a
a (a -> Type v a
forall v a. Ord v => a -> Type v a
Type.list a
a) (a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
testResultRef)
optionalType :: forall v a. Ord v => a -> Type v a
optionalType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
optionalRef
eitherType :: forall v a. Ord v => a -> Type v a
eitherType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
eitherRef
ioErrorType :: forall v a. Ord v => a -> Type v a
ioErrorType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
ioErrorRef
fileModeType :: forall v a. Ord v => a -> Type v a
fileModeType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
fileModeRef
filePathType :: forall v a. Ord v => a -> Type v a
filePathType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
filePathRef
bufferModeType :: forall v a. Ord v => a -> Type v a
bufferModeType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
bufferModeRef
seekModeType :: forall v a. Ord v => a -> Type v a
seekModeType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
seekModeRef
stdHandleType :: forall v a. Ord v => a -> Type v a
stdHandleType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
stdHandleRef
failureType :: forall v a. Ord v => a -> Type v a
failureType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
failureRef
exceptionType :: forall v a. Ord v => a -> Type v a
exceptionType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
exceptionRef

tlsSignedCertType :: (Var v) => a -> Type v a
tlsSignedCertType :: forall v a. Var v => a -> Type v a
tlsSignedCertType a
a = a -> Reference' Text Hash -> Type v a
forall v a. Ord v => a -> Reference' Text Hash -> Type v a
Type.ref a
a Reference' Text Hash
tlsSignedCertRef

unitTerm :: (Var v) => a -> Term2 vt at ap v a
unitTerm :: forall v a vt at ap. Var v => a -> Term2 vt at ap v a
unitTerm a
ann = a -> ConstructorReference -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> ConstructorReference -> Term2 vt at ap v a
Term.constructor a
ann (Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
unitRef ConstructorId
0)

tupleConsTerm ::
  (Ord v, Semigroup a) =>
  Term2 vt at ap v a ->
  Term2 vt at ap v a ->
  Term2 vt at ap v a
tupleConsTerm :: forall v a vt at ap.
(Ord v, Semigroup a) =>
Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
tupleConsTerm Term2 vt at ap v a
hd Term2 vt at ap v a
tl =
  Term2 vt at ap v a -> [Term2 vt at ap v a] -> Term2 vt at ap v a
forall v a vt at ap.
(Ord v, Semigroup a) =>
Term2 vt at ap v a -> [Term2 vt at ap v a] -> Term2 vt at ap v a
Term.apps' (a -> ConstructorReference -> Term2 vt at ap v a
forall v a vt at ap.
Ord v =>
a -> ConstructorReference -> Term2 vt at ap v a
Term.constructor (Term2 vt at ap v a -> a
forall (f :: * -> *) v a. Term f v a -> a
ABT.annotation Term2 vt at ap v a
hd) (Reference' Text Hash -> ConstructorId -> ConstructorReference
forall r. r -> ConstructorId -> GConstructorReference r
ConstructorReference Reference' Text Hash
pairRef ConstructorId
0)) [Term2 vt at ap v a
hd, Term2 vt at ap v a
tl]

tupleTerm :: (Var v, Monoid a) => [Term2 vt at ap v a] -> Term2 vt at ap v a
tupleTerm :: forall v a vt at ap.
(Var v, Monoid a) =>
[Term2 vt at ap v a] -> Term2 vt at ap v a
tupleTerm = (Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a)
-> Term2 vt at ap v a -> [Term2 vt at ap v a] -> Term2 vt at ap v a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
forall v a vt at ap.
(Ord v, Semigroup a) =>
Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
tupleConsTerm (a -> Term2 vt at ap v a
forall v a vt at ap. Var v => a -> Term2 vt at ap v a
unitTerm a
forall a. Monoid a => a
mempty)

-- delayed terms are just lambdas that take a single `()` arg
-- `force` calls the function
forceTerm :: (Var v) => a -> a -> Term v a -> Term v a
forceTerm :: forall v a. Var v => a -> a -> Term v a -> Term v a
forceTerm a
a a
au Term v a
e = a -> Term v a -> Term v a -> Term v a
forall v a vt at ap.
Ord v =>
a -> Term2 vt at ap v a -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.app a
a Term v a
e (a -> Term v a
forall v a vt at ap. Var v => a -> Term2 vt at ap v a
unitTerm a
au)

delayTerm :: (Var v) => a -> a -> Term v a -> Term v a
delayTerm :: forall v a. Var v => a -> a -> Term v a -> Term v a
delayTerm a
spanAnn a
argAnn = a -> (a, v) -> Term2 v a a v a -> Term2 v a a v a
forall v a vt at ap.
Ord v =>
a -> (a, v) -> Term2 vt at ap v a -> Term2 vt at ap v a
Term.lam a
spanAnn (a
argAnn, Type -> v
forall v. Var v => Type -> v
Var.typed Type
Var.Delay)

unTupleTerm ::
  Term.Term2 vt at ap v a ->
  Maybe [Term.Term2 vt at ap v a]
unTupleTerm :: forall vt at ap v a.
Term2 vt at ap v a -> Maybe [Term2 vt at ap v a]
unTupleTerm Term2 vt at ap v a
t = case Term2 vt at ap v a
t of
  Term.Apps' (Term.Constructor' (ConstructorReference Reference' Text Hash
PairRef ConstructorId
0)) [Term2 vt at ap v a
fst, Term2 vt at ap v a
snd] ->
    (Term2 vt at ap v a
fst Term2 vt at ap v a -> [Term2 vt at ap v a] -> [Term2 vt at ap v a]
forall a. a -> [a] -> [a]
:) ([Term2 vt at ap v a] -> [Term2 vt at ap v a])
-> Maybe [Term2 vt at ap v a] -> Maybe [Term2 vt at ap v a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Term2 vt at ap v a -> Maybe [Term2 vt at ap v a]
forall vt at ap v a.
Term2 vt at ap v a -> Maybe [Term2 vt at ap v a]
unTupleTerm Term2 vt at ap v a
snd
  Term.Constructor' (ConstructorReference Reference' Text Hash
UnitRef ConstructorId
0) -> [Term2 vt at ap v a] -> Maybe [Term2 vt at ap v a]
forall a. a -> Maybe a
Just []
  Term2 vt at ap v a
_ -> Maybe [Term2 vt at ap v a]
forall a. Maybe a
Nothing

unTupleType :: (Var v) => Type v a -> Maybe [Type v a]
unTupleType :: forall v a. Var v => Type v a -> Maybe [Type v a]
unTupleType Type v a
t = case Type v a
t of
  Type.Apps' (Type.Ref' Reference' Text Hash
PairRef) [Type v a
fst, Type v a
snd] -> (Type v a
fst Type v a -> [Type v a] -> [Type v a]
forall a. a -> [a] -> [a]
:) ([Type v a] -> [Type v a]) -> Maybe [Type v a] -> Maybe [Type v a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Type v a -> Maybe [Type v a]
forall v a. Var v => Type v a -> Maybe [Type v a]
unTupleType Type v a
snd
  Type.Ref' Reference' Text Hash
UnitRef -> [Type v a] -> Maybe [Type v a]
forall a. a -> Maybe a
Just []
  Type v a
_ -> Maybe [Type v a]
forall a. Maybe a
Nothing

unTuplePattern :: Pattern.Pattern loc -> Maybe [Pattern.Pattern loc]
unTuplePattern :: forall loc. Pattern loc -> Maybe [Pattern loc]
unTuplePattern Pattern loc
p = case Pattern loc
p of
  Pattern.Constructor loc
_ (ConstructorReference Reference' Text Hash
PairRef ConstructorId
0) [Pattern loc
fst, Pattern loc
snd] -> (Pattern loc
fst Pattern loc -> [Pattern loc] -> [Pattern loc]
forall a. a -> [a] -> [a]
:) ([Pattern loc] -> [Pattern loc])
-> Maybe [Pattern loc] -> Maybe [Pattern loc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Pattern loc -> Maybe [Pattern loc]
forall loc. Pattern loc -> Maybe [Pattern loc]
unTuplePattern Pattern loc
snd
  Pattern.Constructor loc
_ (ConstructorReference Reference' Text Hash
UnitRef ConstructorId
0) [] -> [Pattern loc] -> Maybe [Pattern loc]
forall a. a -> Maybe a
Just []
  Pattern loc
_ -> Maybe [Pattern loc]
forall a. Maybe a
Nothing

unUnitRef, unPairRef, unOptionalRef :: Reference -> Bool
unUnitRef :: Reference' Text Hash -> Bool
unUnitRef = (Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== Reference' Text Hash
unitRef)
unPairRef :: Reference' Text Hash -> Bool
unPairRef = (Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== Reference' Text Hash
pairRef)
unOptionalRef :: Reference' Text Hash -> Bool
unOptionalRef = (Reference' Text Hash -> Reference' Text Hash -> Bool
forall a. Eq a => a -> a -> Bool
== Reference' Text Hash
optionalRef)