@@ -48,3 +48,5 @@ The format for this list: name, GitHub handle, and then optional blurb about wha
 * Jared Forsyth (@jaredly) - Documentation generation
 * Hakim Cassimally (@osfameron) - vim support
 * Will Badart (@wbadart)
+* Sam Roberts (@samgqroberts)
+* Nigel Farrelly (@nini-faroux)
@@ -270,7 +270,7 @@ getTerm' getVar getA = getABT getVar getA go
       8 -> Term.Handle <$> getChild <*> getChild
       9 -> Term.App <$> getChild <*> getChild
       10 -> Term.Ann <$> getChild <*> getType' getVar getA
-      11 -> Term.Sequence . Sequence.fromList <$> getList getChild
+      11 -> Term.List . Sequence.fromList <$> getList getChild
       12 -> Term.If <$> getChild <*> getChild <*> getChild
       13 -> Term.And <$> getChild <*> getChild
       14 -> Term.Or <$> getChild <*> getChild
 
@@ -56,7 +56,7 @@ data F typeVar typeAnn a
   | Handle a a
   | App a a
   | Ann a (Type typeVar typeAnn)
-  | Sequence (Seq a)
+  | List (Seq a)
   | If a a a
   | And a a
   | Or a a
@@ -137,7 +137,7 @@ generalizedDependencies termRef typeRef literalType dataConstructor dataType eff
     f t@(Float _) = Writer.tell [literalType Type.floatRef] $> t
     f t@(Boolean _) = Writer.tell [literalType Type.booleanRef] $> t
     f t@(Text _) = Writer.tell [literalType Type.textRef] $> t
-    f t@(Sequence _) = Writer.tell [literalType Type.vectorRef] $> t
+    f t@(List _) = Writer.tell [literalType Type.listRef] $> t
     f t@(Constructor r cid) =
       Writer.tell [dataType r, dataConstructor r cid] $> t
     f t@(Request r cid) =
 
@@ -82,8 +82,8 @@ generalizedDependencies literalType dataConstructor dataType effectConstructor e
           EffectPure _ -> [effectType Type.effectRef]
           EffectBind r cid _ _ ->
             [effectType Type.effectRef, effectType r, effectConstructor r cid]
-          SequenceLiteral _ -> [literalType Type.vectorRef]
-          SequenceOp {} -> [literalType Type.vectorRef]
+          SequenceLiteral _ -> [literalType Type.listRef]
+          SequenceOp {} -> [literalType Type.listRef]
           Boolean _ -> [literalType Type.booleanRef]
           Int _ -> [literalType Type.intRef]
           Nat _ -> [literalType Type.natRef]
 
@@ -41,14 +41,14 @@ dependencies t = Set.fromList . Writer.execWriter $ ABT.visit' f t
     f t@(Ref r) = Writer.tell [r] $> t
     f t = pure t
 
-intRef, natRef, floatRef, booleanRef, textRef, charRef, vectorRef, bytesRef, effectRef, termLinkRef, typeLinkRef :: Reference
+intRef, natRef, floatRef, booleanRef, textRef, charRef, listRef, bytesRef, effectRef, termLinkRef, typeLinkRef :: Reference
 intRef = Reference.Builtin "Int"
 natRef = Reference.Builtin "Nat"
 floatRef = Reference.Builtin "Float"
 booleanRef = Reference.Builtin "Boolean"
 textRef = Reference.Builtin "Text"
 charRef = Reference.Builtin "Char"
-vectorRef = Reference.Builtin "Sequence"
+listRef = Reference.Builtin "Sequence"
 bytesRef = Reference.Builtin "Bytes"
 effectRef = Reference.Builtin "Effect"
 termLinkRef = Reference.Builtin "Link.Term"
 
@@ -14,8 +14,8 @@ module U.Codebase.Sqlite.Operations where
 
 import Control.Lens (Lens')
 import qualified Control.Lens as Lens
-import Control.Monad.Except (ExceptT, MonadError, runExceptT, throwError)
 import Control.Monad (MonadPlus (mzero), join, when, (<=<))
+import Control.Monad.Except (ExceptT, MonadError, runExceptT, throwError)
 import Control.Monad.State (MonadState, StateT, evalStateT)
 import Control.Monad.Trans (MonadTrans (lift))
 import Control.Monad.Trans.Maybe (MaybeT (MaybeT), runMaybeT)
@@ -46,6 +46,7 @@ import Data.Tuple.Extra (uncurry3)
 import qualified Data.Vector as Vector
 import Data.Word (Word64)
 import Debug.Trace
+import GHC.Stack (HasCallStack)
 import qualified U.Codebase.Branch as C.Branch
 import qualified U.Codebase.Causal as C
 import U.Codebase.Decl (ConstructorId)
@@ -121,7 +122,6 @@ import qualified U.Util.Type as TypeUtil
 
 -- * Error handling
 
-type Err m = MonadError Error m
 debug :: Bool
 debug = False
 
@@ -498,7 +498,7 @@ c2xTerm saveText saveDefn tm tp =
       C.Term.Handle a a2 -> pure $ C.Term.Handle a a2
       C.Term.App a a2 -> pure $ C.Term.App a a2
       C.Term.Ann a typ -> C.Term.Ann a <$> ABT.transformM goType typ
-      C.Term.Sequence as -> pure $ C.Term.Sequence as
+      C.Term.List as -> pure $ C.Term.List as
       C.Term.If c t f -> pure $ C.Term.If c t f
       C.Term.And a a2 -> pure $ C.Term.And a a2
       C.Term.Or a a2 -> pure $ C.Term.Or a a2
 
@@ -202,7 +202,7 @@ putTerm t = putABT putSymbol putUnit putF t
         putWord8 9 *> putChild f *> putChild arg
       Term.Ann e t ->
         putWord8 10 *> putChild e *> putTType t
-      Term.Sequence vs ->
+      Term.List vs ->
         putWord8 11 *> putFoldable putChild vs
       Term.If cond t f ->
         putWord8 12 *> putChild cond *> putChild t *> putChild f
@@ -284,7 +284,7 @@ getTerm = getABT getSymbol getUnit getF
         8 -> Term.Handle <$> getChild <*> getChild
         9 -> Term.App <$> getChild <*> getChild
         10 -> Term.Ann <$> getChild <*> getType getReference
-        11 -> Term.Sequence <$> getSequence getChild
+        11 -> Term.List <$> getSequence getChild
         12 -> Term.If <$> getChild <*> getChild <*> getChild
         13 -> Term.And <$> getChild <*> getChild
         14 -> Term.Or <$> getChild <*> getChild
 
@@ -106,7 +106,7 @@ trySync ::
   Generation ->
   Entity ->
   m (TrySyncResult Entity)
-trySync tCache hCache oCache gc = \case
+trySync tCache hCache oCache _gc = \case
   -- for causals, we need to get the value_hash_id of the thingo
   -- - maybe enqueue their parents
   -- - enqueue the self_ and value_ hashes
 
@@ -75,7 +75,7 @@ data F' text termRef typeRef termLink typeLink vt a
   | Handle a a
   | App a a
   | Ann a (TypeR typeRef vt)
-  | Sequence (Seq a)
+  | List (Seq a)
   | If a a a
   | And a a
   | Or a a
@@ -169,7 +169,7 @@ extraMap ftext ftermRef ftypeRef ftermLink ftypeLink fvt = go'
       Handle e h -> Handle e h
       App f a -> App f a
       Ann a typ -> Ann a (Type.rmap ftypeRef $ ABT.vmap fvt typ)
-      Sequence s -> Sequence s
+      List s -> List s
       If c t f -> If c t f
       And p q -> And p q
       Or p q -> Or p q
@@ -292,7 +292,7 @@ instance (Eq v, Show v) => H.Hashable1 (F v) where
                   error "handled above, but GHC can't figure this out"
                 App a a2 -> [tag 3, hashed (hash a), hashed (hash a2)]
                 Ann a t -> [tag 4, hashed (hash a), hashed (ABT.hash t)]
-                Sequence as ->
+                List as ->
                   tag 5 :
                   varint (fromIntegral (length as)) :
                   map
 
@@ -1,4 +1,3 @@
-{-# LANGUAGE ExplicitForAll #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE Rank2Types #-}
 
@@ -170,8 +169,6 @@ builtinTypesSrc =
   , B' "Value" CT.Data
   , B' "Any" CT.Data
   , B' "crypto.HashAlgorithm" CT.Data
-  , B' "IOFailure" CT.Data, Rename' "IOFailure" "io2.IOFailure"
-  , B' "TlsFailure" CT.Data, Rename' "TlsFailure" "io2.TlsFailure"
   , B' "Tls" CT.Data, Rename' "Tls" "io2.Tls"
   , B' "Tls.ClientConfig" CT.Data, Rename' "Tls.ClientConfig" "io2.Tls.ClientConfig"
   , B' "Tls.ServerConfig" CT.Data, Rename' "Tls.ServerConfig" "io2.Tls.ServerConfig"
@@ -395,7 +392,7 @@ builtinsSrc =
   , B "Text.toCharList" $ text --> list char
   , B "Text.fromCharList" $ list char --> text
   , B "Text.toUtf8" $ text --> bytes
-  , B "Text.fromUtf8.v3" $ bytes --> eithert failure text
+  , B "Text.fromUtf8.impl.v3" $ bytes --> eithert failure text
   , B "Char.toNat" $ char --> nat
   , B "Char.fromNat" $ nat --> char
 
@@ -509,55 +506,54 @@ hashBuiltins =
 
 ioBuiltins :: Var v => [(Text, Type v)]
 ioBuiltins =
-  [ ("IO.openFile.v3", text --> fmode --> iof handle)
-  , ("IO.closeFile.v3", handle --> iof unit)
-  , ("IO.isFileEOF.v3", handle --> iof boolean)
-  , ("IO.isFileOpen.v3", handle --> iof boolean)
-  , ("IO.isSeekable.v3", handle --> iof boolean)
-  , ("IO.seekHandle.v3", handle --> smode --> int --> iof unit)
-  , ("IO.handlePosition.v3", handle --> iof nat)
-  , ("IO.getBuffering.v3", handle --> iof bmode)
-  , ("IO.setBuffering.v3", handle --> bmode --> iof unit)
-  , ("IO.getBytes.v3", handle --> nat --> iof bytes)
-  , ("IO.putBytes.v3", handle --> bytes --> iof unit)
-  , ("IO.systemTime.v3", unit --> iof nat)
-  , ("IO.getTempDirectory.v3", unit --> iof text)
-  , ("IO.createTempDirectory", text --> iof text)
-  , ("IO.getCurrentDirectory.v3", unit --> iof text)
-  , ("IO.setCurrentDirectory.v3", text --> iof unit)
-  , ("IO.fileExists.v3", text --> iof boolean)
-  , ("IO.isDirectory.v3", text --> iof boolean)
-  , ("IO.createDirectory.v3", text --> iof unit)
-  , ("IO.removeDirectory.v3", text --> iof unit)
-  , ("IO.renameDirectory.v3", text --> text --> iof unit)
-  , ("IO.removeFile.v3", text --> iof unit)
-  , ("IO.renameFile.v3", text --> text --> iof unit)
-  , ("IO.getFileTimestamp.v3", text --> iof nat)
-  , ("IO.getFileSize.v3", text --> iof nat)
-  , ("IO.serverSocket.v3", optionalt text --> text --> iof socket)
-  , ("IO.listen.v3", socket --> iof unit)
-  , ("IO.clientSocket.v3", text --> text --> iof socket)
-  , ("IO.closeSocket.v3", socket --> iof unit)
-  , ("IO.socketPort", socket --> iof nat)
-  , ("IO.socketAccept.v3", socket --> iof socket)
-  , ("IO.socketSend.v3", socket --> bytes --> iof unit)
-  , ("IO.socketReceive.v3", socket --> nat --> iof bytes)
-  , ("IO.forkComp.v2"
-    , forall1 "a" $ \a -> (unit --> io a) --> io threadId)
+  [ ("IO.openFile.impl.v3", text --> fmode --> iof handle)
+  , ("IO.closeFile.impl.v3", handle --> iof unit)
+  , ("IO.isFileEOF.impl.v3", handle --> iof boolean)
+  , ("IO.isFileOpen.impl.v3", handle --> iof boolean)
+  , ("IO.isSeekable.impl.v3", handle --> iof boolean)
+  , ("IO.seekHandle.impl.v3", handle --> smode --> int --> iof unit)
+  , ("IO.handlePosition.impl.v3", handle --> iof nat)
+  , ("IO.getBuffering.impl.v3", handle --> iof bmode)
+  , ("IO.setBuffering.impl.v3", handle --> bmode --> iof unit)
+  , ("IO.getBytes.impl.v3", handle --> nat --> iof bytes)
+  , ("IO.putBytes.impl.v3", handle --> bytes --> iof unit)
+  , ("IO.systemTime.impl.v3", unit --> iof nat)
+  , ("IO.getTempDirectory.impl.v3", unit --> iof text)
+  , ("IO.createTempDirectory.impl.v3", text --> iof text)
+  , ("IO.getCurrentDirectory.impl.v3", unit --> iof text)
+  , ("IO.setCurrentDirectory.impl.v3", text --> iof unit)
+  , ("IO.fileExists.impl.v3", text --> iof boolean)
+  , ("IO.isDirectory.impl.v3", text --> iof boolean)
+  , ("IO.createDirectory.impl.v3", text --> iof unit)
+  , ("IO.removeDirectory.impl.v3", text --> iof unit)
+  , ("IO.renameDirectory.impl.v3", text --> text --> iof unit)
+  , ("IO.removeFile.impl.v3", text --> iof unit)
+  , ("IO.renameFile.impl.v3", text --> text --> iof unit)
+  , ("IO.getFileTimestamp.impl.v3", text --> iof nat)
+  , ("IO.getFileSize.impl.v3", text --> iof nat)
+  , ("IO.serverSocket.impl.v3", optionalt text --> text --> iof socket)
+  , ("IO.listen.impl.v3", socket --> iof unit)
+  , ("IO.clientSocket.impl.v3", text --> text --> iof socket)
+  , ("IO.closeSocket.impl.v3", socket --> iof unit)
+  , ("IO.socketPort.impl.v3", socket --> iof nat)
+  , ("IO.socketAccept.impl.v3", socket --> iof socket)
+  , ("IO.socketSend.impl.v3", socket --> bytes --> iof unit)
+  , ("IO.socketReceive.impl.v3", socket --> nat --> iof bytes)
+  , ("IO.forkComp.v2", forall1 "a" $ \a -> (unit --> io a) --> io threadId)
   , ("IO.stdHandle", stdhandle --> handle)
 
-  , ("IO.delay.v3", nat --> iof unit)
-  , ("IO.kill.v3", threadId --> iof unit)
-  , ("Tls.newClient", tlsClientConfig --> socket --> iof tls)
-  , ("Tls.newServer", tlsServerConfig --> socket --> iof tls)
-  , ("Tls.handshake", tls --> iof unit)
-  , ("Tls.send", tls --> bytes --> iof unit)
-  , ("Tls.decodeCert", bytes --> eithert failure tlsSignedCert)
+  , ("IO.delay.impl.v3", nat --> iof unit)
+  , ("IO.kill.impl.v3", threadId --> iof unit)
+  , ("Tls.newClient.impl.v3", tlsClientConfig --> socket --> iof tls)
+  , ("Tls.newServer.impl.v3", tlsServerConfig --> socket --> iof tls)
+  , ("Tls.handshake.impl.v3", tls --> iof unit)
+  , ("Tls.send.impl.v3", tls --> bytes --> iof unit)
+  , ("Tls.decodeCert.impl.v3", bytes --> eithert failure tlsSignedCert)
   , ("Tls.encodeCert", tlsSignedCert --> bytes)
   , ("Tls.decodePrivateKey", bytes --> list tlsPrivateKey)
   , ("Tls.encodePrivateKey", tlsPrivateKey --> bytes)
-  , ("Tls.receive", tls --> iof bytes)
-  , ("Tls.terminate", tls --> iof unit)
+  , ("Tls.receive.impl.v3", tls --> iof bytes)
+  , ("Tls.terminate.impl.v3", tls --> iof unit)
   , ("Tls.ClientConfig.default", text --> bytes --> tlsClientConfig)
   , ("Tls.ServerConfig.default", list tlsSignedCert --> tlsPrivateKey --> tlsServerConfig)
   , ("TLS.ClientConfig.ciphers.set", list tlsCipher --> tlsClientConfig --> tlsClientConfig)
@@ -573,14 +569,14 @@ mvarBuiltins :: forall v. Var v => [(Text, Type v)]
 mvarBuiltins =
   [ ("MVar.new", forall1 "a" $ \a -> a --> io (mvar a))
   , ("MVar.newEmpty.v2", forall1 "a" $ \a -> unit --> io (mvar a))
-  , ("MVar.take.v3", forall1 "a" $ \a -> mvar a --> iof a)
+  , ("MVar.take.impl.v3", forall1 "a" $ \a -> mvar a --> iof a)
   , ("MVar.tryTake", forall1 "a" $ \a -> mvar a --> io (optionalt a))
-  , ("MVar.put.v3", forall1 "a" $ \a -> mvar a --> a --> iof unit)
-  , ("MVar.tryPut", forall1 "a" $ \a -> mvar a --> a --> io boolean)
-  , ("MVar.swap.v3", forall1 "a" $ \a -> mvar a --> a --> iof a)
+  , ("MVar.put.impl.v3", forall1 "a" $ \a -> mvar a --> a --> iof unit)
+  , ("MVar.tryPut.impl.v3", forall1 "a" $ \a -> mvar a --> a --> iof boolean)
+  , ("MVar.swap.impl.v3", forall1 "a" $ \a -> mvar a --> a --> iof a)
   , ("MVar.isEmpty", forall1 "a" $ \a -> mvar a --> io boolean)
-  , ("MVar.read.v3", forall1 "a" $ \a -> mvar a --> iof a)
-  , ("MVar.tryRead", forall1 "a" $ \a -> mvar a --> io (optionalt a))
+  , ("MVar.read.impl.v3", forall1 "a" $ \a -> mvar a --> iof a)
+  , ("MVar.tryRead.impl.v3", forall1 "a" $ \a -> mvar a --> iof (optionalt a))
   ]
   where
   mvar :: Type v -> Type v
@@ -624,7 +620,7 @@ app :: Ord v => Type v -> Type v -> Type v
 app = Type.app ()
 
 list :: Ord v => Type v -> Type v
-list arg = Type.vector () `app` arg
+list arg = Type.list () `app` arg
 
 optionalt :: Ord v => Type v -> Type v
 optionalt arg = DD.optionalType () `app` arg