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"

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"

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)
        ] 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
              )
            ]

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)