@helios-lang/effect 0.1.14 → 0.2.0

package/dist/{Cbor.js → Codecs/Cbor.js}

@@ -1,8 +1,8 @@
-import { Data, Effect, Either } from "effect";
-import * as BigEndian from "./internal/BigEndian.js";
-import * as Bytes from "./internal/Bytes.js";
-import * as Float from "./internal/Float.js";
-import * as Utf8 from "./internal/Utf8.js";
+import { Data, Either } from "effect";
+import * as BigEndian from "./BigEndian.js";
+import * as Bytes from "./Bytes.js";
+import * as Float from "./Float.js";
+import * as Utf8 from "./Utf8.js";
 const FALSE_BYTE = 244; // m = 7, n = 20
 const TRUE_BYTE = 245; // m = 7, n = 21
 export class DecodeError extends Data.TaggedError("Cbor.DecodeError") {
@@ -16,19 +16,20 @@ export class DecodeError extends Data.TaggedError("Cbor.DecodeError") {
  * @param bytes
  * @returns
  */
-export const decodeBool = (bytes) => Effect.gen(function* () {
+export const decodeBool = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const b = yield* stream.shiftOne();
-    if (b == TRUE_BYTE) {
-        return true;
-    }
-    else if (b == FALSE_BYTE) {
-        return false;
-    }
-    else {
-        return yield* new DecodeError(stream, "unexpected non-boolean cbor object");
-    }
-});
+    return stream.shiftOne().pipe(Either.flatMap((b) => {
+        if (b == TRUE_BYTE) {
+            return Either.right(true);
+        }
+        else if (b == FALSE_BYTE) {
+            return Either.right(false);
+        }
+        else {
+            return Either.left(new DecodeError(stream, "unexpected non-boolean cbor object"));
+        }
+    }));
+};
 /**
  * Encodes a `boolean` into its CBOR representation.
  * @param b
@@ -46,41 +47,54 @@ export function encodeBool(b) {
  * @param bytes
  * @returns
  */
-export const isBool = (bytes) => Bytes.makeStream(bytes)
-    .peekOne()
-    .pipe(Effect.map((head) => head == FALSE_BYTE || head == TRUE_BYTE));
+export const isBool = (bytes) => {
+    const head = Bytes.makeStream(bytes).peekOne();
+    if (Either.isLeft(head)) {
+        return false;
+    }
+    return head.right == FALSE_BYTE || head.right == TRUE_BYTE;
+};
+const decodeIndefBytes = (stream) => Either.gen(function* () {
+    yield* stream.shiftOne();
+    // multiple chunks
+    let res = [];
+    let next = yield* stream.peekOne();
+    while (next != 255) {
+        const [, n] = yield* decodeDefHead(stream);
+        if (n > 64n) {
+            return yield* Either.left(new DecodeError(stream, "Bytearray chunk too large"));
+        }
+        const chunk = yield* stream.shiftMany(Number(n));
+        res = res.concat(chunk);
+        next = yield* stream.peekOne();
+    }
+    const last = yield* stream.shiftOne();
+    if (last != 255) {
+        return yield* Either.left(new DecodeError(stream, "invalid indef bytes termination byte"));
+    }
+    return res;
+});
+const decodeDefBytes = (stream) => decodeDefHead(stream).pipe(Either.flatMap(([m, n]) => {
+    if (m != 2) {
+        return Either.left(new DecodeError(stream, "Invalid def bytes"));
+    }
+    return stream.shiftMany(Number(n));
+}));
 /**
  * Unwraps a CBOR encoded list of bytes
  * @param bytes
  * cborbytes, mutated to form remaining
  * @returns byteArray
  */
-export const decodeBytes = (bytes) => Effect.gen(function* () {
+export const decodeBytes = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    if (yield* isIndefBytes(bytes)) {
-        yield* stream.shiftOne();
-        // multiple chunks
-        let res = [];
-        while ((yield* stream.peekOne()) != 255) {
-            const [, n] = yield* decodeDefHead(stream);
-            if (n > 64n) {
-                return yield* new DecodeError(stream, "Bytearray chunk too large");
-            }
-            res = res.concat(yield* stream.shiftMany(Number(n)));
-        }
-        if ((yield* stream.shiftOne()) != 255) {
-            throw new Error("invalid indef bytes termination byte");
-        }
-        return res;
+    if (isIndefBytes(bytes)) {
+        return decodeIndefBytes(stream);
     }
     else {
-        const [m, n] = yield* decodeDefHead(stream);
-        if (m != 2) {
-            return yield* new DecodeError(stream, "Invalid def bytes");
-        }
-        return yield* stream.shiftMany(Number(n));
+        return decodeDefBytes(stream);
     }
-});
+};
 /**
  * Wraps a list of bytes using CBOR. Optionally splits the bytes into chunks.
  * @example
@@ -90,8 +104,8 @@ export const decodeBytes = (bytes) => Effect.gen(function* () {
  * @returns
  * cbor bytes
  */
-export function encodeBytes(bytes, splitIntoChunks = false) {
-    bytes = Bytes.toArray(bytes).slice();
+export function encodeBytes(bs, splitIntoChunks = false) {
+    const bytes = Bytes.toArray(bs).slice();
     if (bytes.length <= 64 || !splitIntoChunks) {
         const head = encodeDefHead(2, BigInt(bytes.length));
         return head.concat(bytes);
@@ -110,23 +124,40 @@ export function encodeBytes(bytes, splitIntoChunks = false) {
  * @param bytes
  * @returns
  */
-export const isBytes = (bytes) => peekMajorType(bytes).pipe(Effect.map((m) => m == 2));
+export const isBytes = (bytes) => {
+    const m = peekMajorType(bytes);
+    if (Either.isLeft(m)) {
+        return false;
+    }
+    return m.right == 2;
+};
 /**
  * @param bytes
  * @returns
  */
-export const isDefBytes = (bytes) => Effect.gen(function* () {
+export const isDefBytes = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const m = yield* peekMajorType(stream);
-    return m == 2 && (yield* stream.peekOne()) != 2 * 32 + 31;
-});
+    const m = peekMajorType(stream);
+    if (Either.isLeft(m)) {
+        return false;
+    }
+    const n = stream.peekOne();
+    if (Either.isLeft(n)) {
+        return false;
+    }
+    return m.right == 2 && n.right != 2 * 32 + 31;
+};
 /**
  * @param bytes
  * @returns
  */
-export const isIndefBytes = (bytes) => Bytes.makeStream(bytes)
-    .peekOne()
-    .pipe(Effect.map((head) => head == 2 * 32 + 31));
+export const isIndefBytes = (bytes) => {
+    const head = Bytes.makeStream(bytes).peekOne();
+    if (Either.isLeft(head)) {
+        return false;
+    }
+    return head.right == 2 * 32 + 31;
+};
 /**
  * The homogenous field type case is used by the uplc ConstrData (undetermined number of UplcData items)
  * @template Decoders
@@ -135,26 +166,24 @@ export const isIndefBytes = (bytes) => Bytes.makeStream(bytes)
  * Array for heterogenous item types, single function for homogenous item types
  * @returns
  */
-export const decodeConstr = (fieldDecoder) => (bytes) => Effect.gen(function* () {
+export const decodeConstr = (fieldDecoder) => (bytes) => Either.gen(function* () {
     const stream = Bytes.makeStream(bytes);
     const tag = yield* decodeConstrTag(stream);
-    const res = yield* decodeList((itemStream, i) => Effect.gen(function* () {
+    const res = yield* decodeList((itemStream, i) => {
         if (Array.isArray(fieldDecoder)) {
             const decoder = fieldDecoder[i];
             if (decoder === undefined) {
-                return yield* new DecodeError(stream, `expected ${fieldDecoder.length} fields, got more than ${i}`);
+                return Either.left(new DecodeError(stream, `expected ${fieldDecoder.length} fields, got more than ${i}`));
             }
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return yield* decoder(itemStream);
+            return decoder(itemStream);
         }
         else {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            return yield* fieldDecoder(itemStream);
+            return fieldDecoder(itemStream);
         }
-    }))(stream);
+    })(stream);
     if (Array.isArray(fieldDecoder)) {
         if (res.length < fieldDecoder.length) {
-            return yield* new DecodeError(stream, `expected ${fieldDecoder.length} fields, only got ${res.length}`);
+            return yield* Either.left(new DecodeError(stream, `expected ${fieldDecoder.length} fields, only got ${res.length}`));
         }
     }
     return [tag, res];
@@ -163,49 +192,55 @@ export const decodeConstr = (fieldDecoder) => (bytes) => Effect.gen(function* ()
  * @param bytes
  * @returns
  */
-export const decodeConstrLazy = (bytes) => Effect.gen(function* () {
+export const decodeConstrLazy = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const tag = yield* decodeConstrTag(stream);
-    const decodeField = yield* decodeListLazy(bytes);
-    return [tag, decodeField];
-});
+    return Either.zipWith(decodeConstrTag(stream), decodeListLazy(bytes), (tag, decodeField) => [tag, decodeField]);
+};
 /**
  * @param bytes
  * @returns
  */
-const decodeConstrTag = (bytes) => Effect.gen(function* () {
+const decodeConstrTag = (bytes) => {
     const stream = Bytes.makeStream(bytes);
     // constr
-    const [m, n] = yield* decodeDefHead(stream);
+    const head = decodeDefHead(stream);
+    if (Either.isLeft(head)) {
+        return Either.left(head.left);
+    }
+    const [m, n] = head.right;
     if (m != 6) {
-        return yield* new DecodeError(stream, "Unexpected constr tag head");
+        return Either.left(new DecodeError(stream, "Unexpected constr tag head"));
     }
     if (n < 102n) {
-        return yield* new DecodeError(stream, `unexpected encoded constr tag ${n}`);
+        return Either.left(new DecodeError(stream, `unexpected encoded constr tag ${n}`));
     }
     else if (n == 102n) {
-        const [mCheck, nCheck] = yield* decodeDefHead(stream);
+        const check = decodeDefHead(stream);
+        if (Either.isLeft(check)) {
+            return Either.left(check.left);
+        }
+        const [mCheck, nCheck] = check.right;
         if (mCheck != 4 || nCheck != 2n) {
-            return yield* new DecodeError(stream, "Unexpected constr tag nested head");
+            return Either.left(new DecodeError(stream, "Unexpected constr tag nested head"));
         }
-        return Number(yield* decodeInt(stream));
+        return decodeInt(stream).pipe(Either.map(Number));
     }
     else if (n < 121n) {
-        return yield* new DecodeError(stream, `unexpected encoded constr tag ${n}`);
+        return Either.left(new DecodeError(stream, `unexpected encoded constr tag ${n}`));
     }
     else if (n <= 127n) {
-        return Number(n - 121n);
+        return Either.right(Number(n - 121n));
     }
     else if (n < 1280n) {
-        return yield* new DecodeError(stream, `unexpected encoded constr tag ${n}`);
+        return Either.left(new DecodeError(stream, `unexpected encoded constr tag ${n}`));
     }
     else if (n <= 1400n) {
-        return Number(n - 1280n + 7n);
+        return Either.right(Number(n - 1280n + 7n));
     }
     else {
-        return yield* new DecodeError(stream, `unexpected encoded constr tag ${n}`);
+        return Either.left(new DecodeError(stream, `unexpected encoded constr tag ${n}`));
     }
-});
+};
 /**
  * Note: internally the indef list format is used if the number of fields is > 0, if the number of fields is 0 the def list format is used
  *   see [well-typed/cborg/serialise/src/Codec/Serialise/Class.hs](https://github.com/well-typed/cborg/blob/4bdc818a1f0b35f38bc118a87944630043b58384/serialise/src/Codec/Serialise/Class.hs#L181).
@@ -243,73 +278,93 @@ function encodeConstrTag(tag) {
  * @param bytes
  * @returns
  */
-export const isConstr = (bytes) => decodeDefHead(Bytes.makeStream(bytes).copy()).pipe(Effect.map(([m, n]) => {
-    if (m == 6) {
-        return (n == 102n || (n >= 121n && n <= 127n) || (n >= 1280n && n <= 1400n));
+export const isConstr = (bytes) => {
+    const head = decodeDefHead(Bytes.makeStream(bytes).copy());
+    if (Either.isLeft(head)) {
+        return false;
     }
-    else {
+    const [m, n] = head.right;
+    if (m != 6) {
         return false;
     }
-}), Effect.catchTag("Cbor.DecodeError", () => {
-    return Effect.succeed(false);
-}));
+    return n == 102n || (n >= 121n && n <= 127n) || (n >= 1280n && n <= 1400n);
+};
 const FLOAT16_HEAD = 249;
 const FLOAT32_HEAD = 250;
 const FLOAT64_HEAD = 251;
+const decodeFloat16Body = (stream) => stream.shiftMany(2).pipe(Either.flatMap(Float.decodeFloat16), Either.mapLeft((e) => {
+    return e._tag == "DecodeException"
+        ? new DecodeError(stream, `failed to decode float16 (${e.message})`)
+        : e;
+}));
+const decodeFloat32Body = (stream) => stream.shiftMany(4).pipe(Either.flatMap(Float.decodeFloat32), Either.mapLeft((e) => {
+    return e._tag == "DecodeException"
+        ? new DecodeError(stream, `failed to decode float32 (${e.message})`)
+        : e;
+}));
+const decodeFloat64Body = (stream) => stream.shiftMany(8).pipe(Either.flatMap(Float.decodeFloat64), Either.mapLeft((e) => {
+    return e._tag == "DecodeException"
+        ? new DecodeError(stream, `failed to decode float64 (${e.message})`)
+        : e;
+}));
 /**
  * @param bytes
  * @returns
  */
-export const decodeFloat = (bytes) => Effect.gen(function* () {
+export const decodeFloat = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const head = yield* stream.shiftOne();
-    switch (head) {
-        case FLOAT16_HEAD:
-            return yield* Either.mapLeft(Float.decodeFloat16(yield* stream.shiftMany(2)), (e) => new DecodeError(stream, `failed to decode float16 (${e.message})`));
-        case FLOAT32_HEAD:
-            return yield* Either.mapLeft(Float.decodeFloat32(yield* stream.shiftMany(4)), (e) => new DecodeError(stream, `failed to decode float32 (${e.message})`));
-        case FLOAT64_HEAD:
-            return yield* Either.mapLeft(Float.decodeFloat64(yield* stream.shiftMany(8)), (e) => new DecodeError(stream, `faild to decode float64 (${e.message})`));
-        default:
-            return yield* new DecodeError(stream, "invalid float header");
-    }
-});
+    return stream.shiftOne().pipe(Either.flatMap((head) => {
+        switch (head) {
+            case FLOAT16_HEAD:
+                return decodeFloat16Body(stream);
+            case FLOAT32_HEAD:
+                return decodeFloat32Body(stream);
+            case FLOAT64_HEAD:
+                return decodeFloat64Body(stream);
+            default:
+                return Either.left(new DecodeError(stream, "invalid float header"));
+        }
+    }));
+};
 /**
  * @param bytes
  * @returns
  */
-export const decodeFloat16 = (bytes) => Effect.gen(function* () {
+export const decodeFloat16 = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const head = yield* stream.shiftOne();
-    if (head != FLOAT16_HEAD) {
-        return yield* new DecodeError(stream, "invalid Float16 header");
-    }
-    return yield* Either.mapLeft(Float.decodeFloat16(yield* stream.shiftMany(2)), (e) => new DecodeError(stream, `failed to decode float16 (${e.message})`));
-});
+    return stream.shiftOne().pipe(Either.flatMap((head) => {
+        if (head != FLOAT16_HEAD) {
+            return Either.left(new DecodeError(stream, "invalid Float16 header"));
+        }
+        return decodeFloat16Body(stream);
+    }));
+};
 /**
  * @param bytes
  * @returns
  */
-export const decodeFloat32 = (bytes) => Effect.gen(function* () {
+export const decodeFloat32 = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const head = yield* stream.shiftOne();
-    if (head != FLOAT32_HEAD) {
-        return yield* new DecodeError(stream, "invalid Float32 header");
-    }
-    return yield* Either.mapLeft(Float.decodeFloat32(yield* stream.shiftMany(4)), (e) => new DecodeError(stream, `failed to decode float32 (${e.message})`));
-});
+    return stream.shiftOne().pipe(Either.flatMap((head) => {
+        if (head != FLOAT32_HEAD) {
+            return Either.left(new DecodeError(stream, "invalid Float32 header"));
+        }
+        return decodeFloat32Body(stream);
+    }));
+};
 /**
  * @param bytes
  * @returns
  */
-export const decodeFloat64 = (bytes) => Effect.gen(function* () {
+export const decodeFloat64 = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const head = yield* stream.shiftOne();
-    if (head != FLOAT64_HEAD) {
-        return yield* new DecodeError(stream, "invalid Float64 header");
-    }
-    return yield* Either.mapLeft(Float.decodeFloat64(yield* stream.shiftMany(8)), (e) => new DecodeError(stream, `failed to decode float32 (${e.message})`));
-});
+    return stream.shiftOne().pipe(Either.flatMap((head) => {
+        if (head != FLOAT64_HEAD) {
+            return Either.left(new DecodeError(stream, "invalid Float64 header"));
+        }
+        return decodeFloat64Body(stream);
+    }));
+};
 /**
  * @param f
  * @returns
@@ -335,30 +390,48 @@ export function encodeFloat64(f) {
  * @param bytes
  * @returns
  */
-export const isFloat = (bytes) => Bytes.makeStream(bytes)
-    .peekOne()
-    .pipe(Effect.map((head) => head == FLOAT16_HEAD || head == FLOAT32_HEAD || head == FLOAT64_HEAD));
+export const isFloat = (bytes) => {
+    const head = Bytes.makeStream(bytes).peekOne();
+    if (Either.isLeft(head)) {
+        return false;
+    }
+    return (head.right == FLOAT16_HEAD ||
+        head.right == FLOAT32_HEAD ||
+        head.right == FLOAT64_HEAD);
+};
 /**
  * @param bytes
  * @returns
  */
-export const isFloat16 = (bytes) => Bytes.makeStream(bytes)
-    .peekOne()
-    .pipe(Effect.map((head) => head == FLOAT16_HEAD));
+export const isFloat16 = (bytes) => {
+    const head = Bytes.makeStream(bytes).peekOne();
+    if (Either.isLeft(head)) {
+        return false;
+    }
+    return head.right == FLOAT16_HEAD;
+};
 /**
  * @param bytes
  * @returns
  */
-export const isFloat32 = (bytes) => Bytes.makeStream(bytes)
-    .peekOne()
-    .pipe(Effect.map((head) => head == FLOAT32_HEAD));
+export const isFloat32 = (bytes) => {
+    const head = Bytes.makeStream(bytes).peekOne();
+    if (Either.isLeft(head)) {
+        return false;
+    }
+    return head.right == FLOAT32_HEAD;
+};
 /**
  * @param bytes
  * @returns
  */
-export const isFloat64 = (bytes) => Bytes.makeStream(bytes)
-    .peekOne()
-    .pipe(Effect.map((head) => head == FLOAT64_HEAD));
+export const isFloat64 = (bytes) => {
+    const head = Bytes.makeStream(bytes).peekOne();
+    if (Either.isLeft(head)) {
+        return false;
+    }
+    return head.right == FLOAT64_HEAD;
+};
 /**
  * @param b0
  * @returns
@@ -373,47 +446,64 @@ function decodeFirstHeadByte(b0) {
  * @returns
  * [majorType, n]
  */
-export const decodeDefHead = (bytes) => Effect.gen(function* () {
+export const decodeDefHead = (bytes) => {
     const stream = Bytes.makeStream(bytes);
     if (stream.isAtEnd()) {
-        return yield* new DecodeError(stream, "Empty CBOR head");
+        return Either.left(new DecodeError(stream, "Empty CBOR head"));
+    }
+    const first = stream.shiftOne();
+    if (Either.isLeft(first)) {
+        return Either.left(first.left);
     }
-    const first = yield* stream.shiftOne();
-    const [m, n0] = decodeFirstHeadByte(first);
+    const [m, n0] = decodeFirstHeadByte(first.right);
     if (n0 <= 23) {
-        return [m, BigInt(n0)];
+        return Either.right([m, BigInt(n0)]);
     }
     else if (n0 == 24) {
-        const l = yield* decodeIntInternal(stream, 1);
-        return [m, l];
+        const l = decodeIntInternal(stream, 1);
+        if (Either.isLeft(l)) {
+            return Either.left(l.left);
+        }
+        return Either.right([m, l.right]);
     }
     else if (n0 == 25) {
         if (m == 7) {
-            return yield* new DecodeError(stream, "Unexpected float16 (hint: decode float16 by calling decodeFloat16 directly)");
+            return Either.left(new DecodeError(stream, "Unexpected float16 (hint: decode float16 by calling decodeFloat16 directly)"));
+        }
+        const n = decodeIntInternal(stream, 2);
+        if (Either.isLeft(n)) {
+            return Either.left(n.left);
         }
-        const n = yield* decodeIntInternal(stream, 2);
-        return [m, n];
+        return Either.right([m, n.right]);
     }
     else if (n0 == 26) {
         if (m == 7) {
-            return yield* new DecodeError(stream, "Unexpected float32 (hint: decode float32 by calling decodeFloat32 directly)");
+            return Either.left(new DecodeError(stream, "Unexpected float32 (hint: decode float32 by calling decodeFloat32 directly)"));
+        }
+        const n = decodeIntInternal(stream, 4);
+        if (Either.isLeft(n)) {
+            return Either.left(n.left);
         }
-        return [m, yield* decodeIntInternal(stream, 4)];
+        return Either.right([m, n.right]);
     }
     else if (n0 == 27) {
         if (m == 7) {
-            return yield* new DecodeError(stream, "Unexpected float64 (hint: decode float64 by calling decodeFloat64 directly)");
+            return Either.left(new DecodeError(stream, "Unexpected float64 (hint: decode float64 by calling decodeFloat64 directly)"));
         }
-        return [m, yield* decodeIntInternal(stream, 8)];
+        const n = decodeIntInternal(stream, 8);
+        if (Either.isLeft(n)) {
+            return Either.left(n.left);
+        }
+        return Either.right([m, n.right]);
     }
     else if ((m == 2 || m == 3 || m == 4 || m == 5 || m == 7) && n0 == 31) {
         // head value 31 is used an indefinite length marker for 2,3,4,5,7 (never for 0,1,6)
-        return yield* new DecodeError(stream, `Unexpected header m=${m} n0=${n0} (expected def instead of indef)`);
+        return Either.left(new DecodeError(stream, `Unexpected header m=${m} n0=${n0} (expected def instead of indef)`));
     }
     else {
-        return yield* new DecodeError(stream, "Bad CBOR header");
+        return Either.left(new DecodeError(stream, "Bad CBOR header"));
     }
-});
+};
 /**
  * @param m major type
  * @param n size parameter
@@ -467,51 +557,48 @@ export function encodeIndefHead(m) {
  */
 export const peekMajorType = (bytes) => Bytes.makeStream(bytes)
     .peekOne()
-    .pipe(Effect.map((head) => Math.trunc(head / 32)));
+    .pipe(Either.map((head) => Math.trunc(head / 32)));
 /**
  * @param bytes
  * @returns
  */
-export const peekMajorAndSimpleMinorType = (bytes) => Bytes.makeStream(bytes).peekOne().pipe(Effect.map(decodeFirstHeadByte));
+export const peekMajorAndSimpleMinorType = (bytes) => Bytes.makeStream(bytes).peekOne().pipe(Either.map(decodeFirstHeadByte));
 /**
  * Decodes a CBOR encoded bigint integer.
  * @param bytes
  * @returns
  */
-export const decodeInt = (bytes) => Effect.gen(function* () {
+export const decodeInt = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const [m, n] = yield* decodeDefHead(stream);
-    if (m == 0) {
-        return n;
-    }
-    else if (m == 1) {
-        return -n - 1n;
-    }
-    else if (m == 6) {
-        if (n == 2n) {
-            return yield* decodeIntInternal(stream);
-        }
-        else if (n == 3n) {
-            return -(yield* decodeIntInternal(stream)) - 1n;
+    return decodeDefHead(stream).pipe(Either.flatMap(([m, n]) => {
+        if (m == 0) {
+            return Either.right(n);
         }
-        else {
-            return yield* new DecodeError(stream, `Unexpected tag m:${m}`);
+        else if (m == 1) {
+            return Either.right(-n - 1n);
         }
-    }
-    else {
-        return yield* new DecodeError(stream, `Unexpected tag m:${m}`);
-    }
-});
-const decodeIntInternal = (stream, nBytes = undefined) => {
-    return (nBytes === undefined ? decodeBytes(stream) : stream.shiftMany(nBytes)).pipe(Effect.map(BigEndian.decode), Effect.flatMap((result) => {
-        if (result._tag == "Left") {
-            return Effect.fail(new DecodeError(stream, `failed to decode BigEndian int (${result.left.message})`));
+        else if (m == 6) {
+            if (n == 2n) {
+                return decodeIntInternal(stream);
+            }
+            else if (n == 3n) {
+                return decodeIntInternal(stream).pipe(Either.map((x) => -x - 1n));
+            }
+            else {
+                return Either.left(new DecodeError(stream, `Unexpected tag m:${m}`));
+            }
         }
         else {
-            return Effect.succeed(result.right);
+            return Either.left(new DecodeError(stream, `Unexpected tag m:${m}`));
         }
     }));
 };
+export const decodeIntAsNumber = (bytes) => decodeInt(bytes).pipe(Either.map(Number));
+const decodeIntInternal = (stream, nBytes = undefined) => {
+    return (nBytes === undefined ? decodeBytes(stream) : stream.shiftMany(nBytes)).pipe(Either.flatMap(BigEndian.decode), Either.mapLeft((e) => e._tag == "DecodeException"
+        ? new DecodeError(stream, `failed to decode BigEndian int (${e.message})`)
+        : e));
+};
 /**
  * Encodes a bigint integer using CBOR.
  * @param n
@@ -538,7 +625,12 @@ export function encodeInt(n) {
  * @param bytes
  * @returns
  */
-export const isInt = (bytes) => peekMajorAndSimpleMinorType(bytes).pipe(Effect.map(([m, n0]) => {
+export const isInt = (bytes) => {
+    const mn0 = peekMajorAndSimpleMinorType(bytes);
+    if (Either.isLeft(mn0)) {
+        return false;
+    }
+    const [m, n0] = mn0.right;
     if (m == 0 || m == 1) {
         return true;
     }
@@ -548,7 +640,32 @@ export const isInt = (bytes) => peekMajorAndSimpleMinorType(bytes).pipe(Effect.m
     else {
         return false;
     }
-}));
+};
+const decodeIndefList = (stream, itemDecoder) => Either.gen(function* () {
+    const res = [];
+    yield* stream.shiftOne();
+    let i = 0;
+    while ((yield* stream.peekOne()) != 255) {
+        res.push(yield* itemDecoder(stream, i));
+        i++;
+    }
+    const last = yield* stream.shiftOne();
+    if (last != 255) {
+        return yield* Either.left(new DecodeError(stream, "Invalid def list head byte"));
+    }
+    return res;
+});
+const decodeDefList = (stream, itemDecoder) => Either.gen(function* () {
+    const res = [];
+    const [m, n] = yield* decodeDefHead(stream);
+    if (m != 4) {
+        return yield* Either.left(new DecodeError(stream, "invalid def list head byte"));
+    }
+    for (let i = 0; i < Number(n); i++) {
+        res.push(yield* itemDecoder(stream, i));
+    }
+    return res;
+});
 /**
  * Decodes a CBOR encoded list.
  * A decoder function is called with the bytes of every contained item (nothing is returning directly).
@@ -556,72 +673,56 @@ export const isInt = (bytes) => peekMajorAndSimpleMinorType(bytes).pipe(Effect.m
  * @param itemDecoder
  * @returns
  */
-export const decodeList = (itemDecoder) => (bytes) => Effect.gen(function* () {
+export const decodeList = (itemDecoder) => (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const res = [];
-    if (yield* isIndefList(stream)) {
-        yield* stream.shiftOne();
-        let i = 0;
-        while ((yield* stream.peekOne()) != 255) {
-            res.push(yield* itemDecoder(stream, i));
-            i++;
-        }
-        const last = yield* stream.shiftOne();
-        if (last != 255) {
-            return yield* new DecodeError(stream, "Invalid def list head byte");
-        }
+    if (isIndefList(stream)) {
+        return decodeIndefList(stream, itemDecoder);
     }
     else {
-        const [m, n] = yield* decodeDefHead(stream);
-        if (m != 4) {
-            return yield* new DecodeError(stream, "invalid def list head byte");
-        }
-        for (let i = 0; i < Number(n); i++) {
-            res.push(yield* itemDecoder(stream, i));
-        }
+        return decodeDefList(stream, itemDecoder);
     }
-    return res;
-});
-/**
- * @param bytes
- * @returns
- *
- *
- */
-export const decodeListLazy = (bytes) => Effect.gen(function* () {
-    const stream = Bytes.makeStream(bytes);
+};
+const decodeIndefListLazy = (stream) => Either.gen(function* () {
     let i = 0;
     let done = false;
-    let checkDone;
-    if (yield* isIndefList(stream)) {
+    yield* stream.shiftOne();
+    if ((yield* stream.peekOne()) == 255) {
         yield* stream.shiftOne();
-        checkDone = () => Effect.gen(function* () {
-            if ((yield* stream.peekOne()) == 255) {
-                yield* stream.shiftOne();
-                done = true;
-            }
-        });
+        done = true;
     }
-    else {
-        const [m, n] = yield* decodeDefHead(stream);
-        if (m != 4) {
-            return yield* new DecodeError(stream, "Unexpected header major type");
+    const decodeItem = (itemDecoder) => Either.gen(function* () {
+        if (done) {
+            return yield* Either.left(new DecodeError(stream, "end-of-list"));
         }
-        checkDone = () => {
-            if (i >= n) {
-                done = true;
-            }
-            return Effect.void;
-        };
+        const res = yield* itemDecoder(stream, i);
+        i++;
+        if ((yield* stream.peekOne()) == 255) {
+            yield* stream.shiftOne();
+            done = true;
+        }
+        return res;
+    });
+    return decodeItem;
+});
+const decodeDefListLazy = (stream) => Either.gen(function* () {
+    let i = 0;
+    let done = false;
+    const [m, n] = yield* decodeDefHead(stream);
+    if (m != 4) {
+        return yield* Either.left(new DecodeError(stream, "Unexpected header major type"));
+    }
+    if (i >= n) {
+        done = true;
     }
-    yield* checkDone();
-    const decodeItem = (itemDecoder) => Effect.gen(function* () {
+    const decodeItem = (itemDecoder) => Either.gen(function* () {
         if (done) {
-            return yield* new DecodeError(stream, "end-of-list");
+            return yield* Either.left(new DecodeError(stream, "end-of-list"));
         }
         const res = yield* itemDecoder(stream, i);
         i++;
-        yield* checkDone();
+        if (i >= n) {
+            done = true;
+        }
         return res;
     });
     return decodeItem;
@@ -630,44 +731,73 @@ export const decodeListLazy = (bytes) => Effect.gen(function* () {
  * @param bytes
  * @returns
  */
-export const decodeListLazyOption = (bytes) => Effect.gen(function* () {
+export const decodeListLazy = (bytes) => {
     const stream = Bytes.makeStream(bytes);
+    if (isIndefList(stream)) {
+        return decodeIndefListLazy(stream);
+    }
+    else {
+        return decodeDefListLazy(stream);
+    }
+};
+const decodeIndefListLazyOption = (stream) => Either.gen(function* () {
     let i = 0;
     let done = false;
-    let checkDone;
-    if (yield* isIndefList(stream)) {
+    yield* stream.shiftOne();
+    if ((yield* stream.peekOne()) == 255) {
         yield* stream.shiftOne();
-        checkDone = () => Effect.gen(function* () {
-            if ((yield* stream.peekOne()) == 255) {
-                yield* stream.shiftOne();
-                done = true;
-            }
-        });
+        done = true;
     }
-    else {
-        const [m, n] = yield* decodeDefHead(stream);
-        if (m != 4) {
-            return yield* new DecodeError(stream, "Unexpected major type for list");
+    const decodeItem = (itemDecoder) => Either.gen(function* () {
+        if (done) {
+            return undefined;
         }
-        checkDone = () => {
-            if (i >= n) {
-                done = true;
-            }
-            return Effect.void;
-        };
+        const res = yield* itemDecoder(stream, i);
+        i++;
+        if ((yield* stream.peekOne()) == 255) {
+            yield* stream.shiftOne();
+            done = true;
+        }
+        return res;
+    });
+    return decodeItem;
+});
+const decodeDefListLazyOption = (stream) => Either.gen(function* () {
+    let i = 0;
+    let done = false;
+    const [m, n] = yield* decodeDefHead(stream);
+    if (m != 4) {
+        return yield* Either.left(new DecodeError(stream, "Unexpected major type for list"));
     }
-    yield* checkDone();
-    const decodeItem = (itemDecoder) => Effect.gen(function* () {
+    if (i >= n) {
+        done = true;
+    }
+    const decodeItem = (itemDecoder) => Either.gen(function* () {
         if (done) {
             return undefined;
         }
         const res = yield* itemDecoder(stream, i);
         i++;
-        yield* checkDone();
+        if (i >= n) {
+            done = true;
+        }
         return res;
     });
     return decodeItem;
 });
+/**
+ * @param bytes
+ * @returns
+ */
+export const decodeListLazyOption = (bytes) => {
+    const stream = Bytes.makeStream(bytes);
+    if (isIndefList(stream)) {
+        return decodeIndefListLazyOption(stream);
+    }
+    else {
+        return decodeDefListLazyOption(stream);
+    }
+};
 /**
  * This follows the serialization format that the Haskell input-output-hk/plutus UPLC evaluator (i.e. empty lists use `encodeDefList`, non-empty lists use `encodeIndefList`).
  * See [well-typed/cborg/serialise/src/Codec/Serialise/Class.hs](https://github.com/well-typed/cborg/blob/4bdc818a1f0b35f38bc118a87944630043b58384/serialise/src/Codec/Serialise/Class.hs#L181).
@@ -728,23 +858,40 @@ export function encodeDefList(items) {
  * @param bytes
  * @returns
  */
-export const isList = (bytes) => peekMajorType(bytes).pipe(Effect.map((m) => m == 4));
+export const isList = (bytes) => {
+    const m = peekMajorType(bytes);
+    if (Either.isLeft(m)) {
+        return false;
+    }
+    return m.right == 4;
+};
 /**
  * @param bytes
  * @returns
  */
-export const isDefList = (bytes) => Effect.gen(function* () {
+export const isDefList = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    return ((yield* peekMajorType(stream)) == 4 &&
-        (yield* stream.peekOne()) != 4 * 32 + 31);
-});
+    const m = peekMajorType(stream);
+    if (Either.isLeft(m)) {
+        return false;
+    }
+    const n = stream.peekOne();
+    if (Either.isLeft(n)) {
+        return false;
+    }
+    return m.right == 4 && n.right != 4 * 32 + 31;
+};
 /**
  * @param bytes
  * @returns
  */
-export const isIndefList = (bytes) => Bytes.makeStream(bytes)
-    .peekOne()
-    .pipe(Effect.map((head) => head == 4 * 32 + 31));
+export const isIndefList = (bytes) => {
+    const head = Bytes.makeStream(bytes).peekOne();
+    if (Either.isLeft(head)) {
+        return false;
+    }
+    return head.right == 4 * 32 + 31;
+};
 /**
  * Decodes a CBOR encoded map.
  * Calls a decoder function for each key-value pair (nothing is returned directly).
@@ -755,16 +902,16 @@ export const isIndefList = (bytes) => Bytes.makeStream(bytes)
  * @param valueDecoder
  * @returns
  */
-export const decodeMap = (keyDecoder, valueDecoder) => (bytes) => Effect.gen(function* () {
+export const decodeMap = (keyDecoder, valueDecoder) => (bytes) => Either.gen(function* () {
     const stream = Bytes.makeStream(bytes);
-    if (yield* isIndefMap(stream)) {
+    if (isIndefMap(stream)) {
         yield* stream.shiftOne();
         return yield* decodeIndefMap(stream, keyDecoder, valueDecoder);
     }
     else {
         const [m, n] = yield* decodeDefHead(stream);
         if (m != 5) {
-            return yield* new DecodeError(stream, "invalid def map");
+            return yield* Either.left(new DecodeError(stream, "invalid def map"));
         }
         return yield* decodeDefMap(stream, Number(n), keyDecoder, valueDecoder);
     }
@@ -777,7 +924,7 @@ export const decodeMap = (keyDecoder, valueDecoder) => (bytes) => Effect.gen(fun
  * @param valueDecoder
  * @returns
  */
-const decodeDefMap = (stream, n, keyDecoder, valueDecoder) => Effect.gen(function* () {
+const decodeDefMap = (stream, n, keyDecoder, valueDecoder) => Either.gen(function* () {
     const res = [];
     for (let i = 0; i < n; i++) {
         res.push([yield* keyDecoder(stream), yield* valueDecoder(stream)]);
@@ -793,7 +940,7 @@ const decodeDefMap = (stream, n, keyDecoder, valueDecoder) => Effect.gen(functio
  * @param valueDecoder
  * @returns
  */
-const decodeIndefMap = (stream, keyDecoder, valueDecoder) => Effect.gen(function* () {
+const decodeIndefMap = (stream, keyDecoder, valueDecoder) => Either.gen(function* () {
     const res = [];
     while ((yield* stream.peekOne()) != 255) {
         res.push([yield* keyDecoder(stream), yield* valueDecoder(stream)]);
@@ -845,14 +992,24 @@ function encodeMapInternal(pairs) {
  * @param bytes
  * @returns
  */
-export const isMap = (bytes) => peekMajorType(bytes).pipe(Effect.map((m) => m == 5));
+export const isMap = (bytes) => {
+    const m = peekMajorType(bytes);
+    if (Either.isLeft(m)) {
+        return false;
+    }
+    return m.right == 5;
+};
 /**
  * @param bytes
  * @returns
  */
-const isIndefMap = (bytes) => Bytes.makeStream(bytes)
-    .peekOne()
-    .pipe(Effect.map((head) => head == 5 * 32 + 31));
+const isIndefMap = (bytes) => {
+    const head = Bytes.makeStream(bytes).peekOne();
+    if (Either.isLeft(head)) {
+        return false;
+    }
+    return head.right == 5 * 32 + 31;
+};
 const NULL_BYTE = 246; // m = 7, n = 22
 /**
  * Checks if next element in `bytes` is a `null`.
@@ -860,14 +1017,15 @@ const NULL_BYTE = 246; // m = 7, n = 22
  * @param bytes
  * @returns
  */
-export const decodeNull = (bytes) => Effect.gen(function* () {
+export const decodeNull = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const b = yield* stream.shiftOne();
-    if (b != NULL_BYTE) {
-        return yield* new DecodeError(stream, "not null");
-    }
-    return null;
-});
+    return stream.shiftOne().pipe(Either.flatMap((b) => {
+        if (b != NULL_BYTE) {
+            return Either.left(new DecodeError(stream, "not null"));
+        }
+        return Either.right(null);
+    }));
+};
 /**
  * Encode `null` into its CBOR representation.
  * @param _null ignored
@@ -880,9 +1038,48 @@ export function encodeNull(_null = null) {
  * @param bytes
  * @returns
  */
-export const isNull = (bytes) => Bytes.makeStream(bytes)
-    .peekOne()
-    .pipe(Effect.map((head) => head == NULL_BYTE));
+export const isNull = (bytes) => {
+    const head = Bytes.makeStream(bytes).peekOne();
+    if (Either.isLeft(head)) {
+        return false;
+    }
+    return head.right == NULL_BYTE;
+};
+/**
+ * @template T
+ * @param decodeSome
+ * @returns
+ */
+export const decodeNullOption = (decodeSome) => (bytes) => {
+    const stream = Bytes.makeStream(bytes);
+    if (isNull(stream)) {
+        return decodeNull(stream).pipe(Either.map(() => undefined));
+    }
+    else {
+        return decodeSome(stream);
+    }
+};
+/**
+ * @param option
+ * @returns
+ */
+export function encodeNullOption(option) {
+    return option ?? encodeNull();
+}
+/**
+ * @template T
+ * @param bytes
+ * @param decodeSome
+ * @returns
+ */
+export const decodeListOption = (decodeSome) => (bytes) => decodeListLazyOption(bytes).pipe(Either.flatMap((decodeItem) => decodeItem(decodeSome)));
+/**
+ * @param option
+ * @returns
+ */
+export function encodeListOption(option) {
+    return encodeList(option ? [option] : []);
+}
 /**
  * Decodes a CBOR encoded object with integer keys.
  * For each field a decoder is called which takes the field index and the field bytes as arguments.
@@ -893,16 +1090,15 @@ export const isNull = (bytes) => Bytes.makeStream(bytes)
 export const decodeObjectIKey = (fieldDecoders) => (bytes) => {
     const stream = Bytes.makeStream(bytes);
     const res = {};
-    return decodeMap(() => Effect.succeed(null), (pairStream) => Effect.gen(function* () {
+    return decodeMap(() => Either.right(null), (pairStream) => Either.gen(function* () {
         const key = Number(yield* decodeInt(pairStream));
         const decoder = fieldDecoders[key];
         if (decoder === undefined) {
-            return yield* new DecodeError(pairStream, `unhandled object field ${key}`);
+            return yield* Either.left(new DecodeError(pairStream, `unhandled object field ${key}`));
         }
         /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment */
         res[key] = yield* decoder(pairStream);
-        return Effect.void;
-    }))(stream).pipe(Effect.map(() => {
+    }))(stream).pipe(Either.map(() => {
         return res;
     }));
 };
@@ -916,16 +1112,15 @@ export const decodeObjectIKey = (fieldDecoders) => (bytes) => {
 export const decodeObjectSKey = (fieldDecoders) => (bytes) => {
     const stream = Bytes.makeStream(bytes);
     const res = {};
-    return decodeMap(() => Effect.succeed(null), (pairStream) => Effect.gen(function* () {
+    return decodeMap(() => Either.right(null), (pairStream) => Either.gen(function* () {
         const key = yield* decodeString(pairStream);
         const decoder = fieldDecoders[key];
         if (decoder === undefined) {
-            return yield* new DecodeError(pairStream, `unhandled object field ${key}`);
+            return yield* Either.left(new DecodeError(pairStream, `unhandled object field ${key}`));
         }
         /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment */
         res[key] = yield* decoder(pairStream);
-        return Effect.void;
-    }))(stream).pipe(Effect.map(() => {
+    }))(stream).pipe(Either.map(() => {
         return res;
     }));
 };
@@ -975,16 +1170,19 @@ const SET_TAG = 258n;
  * @param itemDecoder
  * @returns
  */
-export const decodeSet = (itemDecoder) => (bytes) => Effect.gen(function* () {
+export const decodeSet = (itemDecoder) => (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    if (yield* isTag(stream)) {
-        const tag = yield* decodeTag(stream);
-        if (tag != SET_TAG) {
-            return yield* new DecodeError(stream, `expected tag ${SET_TAG} for set, got tag ${tag}`);
+    if (isTag(stream)) {
+        const tag = decodeTag(stream);
+        if (Either.isLeft(tag)) {
+            return Either.left(tag.left);
+        }
+        if (tag.right != SET_TAG) {
+            return Either.left(new DecodeError(stream, `expected tag ${SET_TAG} for set, got tag ${tag.right}`));
         }
     }
-    return yield* decodeList(itemDecoder)(stream);
-});
+    return decodeList(itemDecoder)(stream);
+};
 /**
  * A tagged def list (tag 258n)
  * @param items
@@ -997,36 +1195,45 @@ export function encodeSet(items) {
  * @param bytes
  * @returns
  */
-export const isSet = (bytes) => peekTag(bytes).pipe(Effect.map((t) => t == SET_TAG));
+export const isSet = (bytes) => {
+    const t = peekTag(bytes);
+    if (Either.isLeft(t)) {
+        return false;
+    }
+    return t.right == SET_TAG;
+};
+const decodeSplitString = (stream) => decodeList((itemBytes) => decodeStringInternal(itemBytes))(stream).pipe(Either.map((parts) => parts.join("")));
 /**
  * @param bytes
  * @returns
  */
-export const decodeString = (bytes) => Effect.gen(function* () {
+export const decodeString = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    if (yield* isDefList(stream)) {
-        let result = "";
-        yield* decodeList((itemBytes) => decodeStringInternal(itemBytes).pipe(Effect.tap((s) => {
-            result += s;
-        })))(stream);
-        return result;
+    if (isDefList(stream)) {
+        return decodeSplitString(stream);
     }
     else {
-        return yield* decodeStringInternal(stream);
+        return decodeStringInternal(stream);
     }
-});
+};
 /**
  * @param bytes
  * @returns
  */
-const decodeStringInternal = (bytes) => Effect.gen(function* () {
+const decodeStringInternal = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const [m, n] = yield* decodeDefHead(stream);
-    if (m !== 3) {
-        return yield* new DecodeError(stream, "unexpected");
-    }
-    return yield* Utf8.decode(yield* stream.shiftMany(Number(n))).pipe(Effect.mapError((e) => new DecodeError(stream, `invalid utf8 (${e.message})`)));
-});
+    return decodeDefHead(stream).pipe(Either.flatMap(([m, n]) => {
+        if (m != 3) {
+            return Either.left(new DecodeError(stream, "unexpected"));
+        }
+        return stream.shiftMany(Number(n));
+    }), Either.flatMap(Utf8.decode), Either.mapLeft((e) => {
+        if (e._tag == "DecodeException") {
+            return new DecodeError(stream, `invalid utf8 (${e.message})`);
+        }
+        return e;
+    }));
+};
 /**
  * Encodes a Utf8 string into Cbor bytes.
  * Strings can be split into lists with chunks of up to 64 bytes
@@ -1065,19 +1272,26 @@ export function encodeString(str, split = false) {
  * @param bytes
  * @returns
  */
-export const isString = (bytes) => peekMajorType(bytes).pipe(Effect.map((m) => m == 3));
+export const isString = (bytes) => {
+    const m = peekMajorType(bytes);
+    if (Either.isLeft(m)) {
+        return false;
+    }
+    return m.right == 3;
+};
 /**
  * @param bytes
  * @returns
  */
-export const decodeTag = (bytes) => Effect.gen(function* () {
+export const decodeTag = (bytes) => {
     const stream = Bytes.makeStream(bytes);
-    const [m, n] = yield* decodeDefHead(stream);
-    if (m != 6) {
-        return yield* new DecodeError(stream, "unexpected major type for tag");
-    }
-    return n;
-});
+    return decodeDefHead(stream).pipe(Either.flatMap(([m, n]) => {
+        if (m != 6) {
+            return Either.left(new DecodeError(stream, "unexpected major type for tag"));
+        }
+        return Either.right(n);
+    }));
+};
 /**
  * Unrelated to constructor
  * @param tag
@@ -1096,19 +1310,36 @@ export function encodeTag(tag) {
  * @param bytes
  * @returns
  */
-export const isTag = (bytes) => peekMajorType(bytes).pipe(Effect.map((m) => m == 6));
+export const isTag = (bytes) => {
+    const m = peekMajorType(bytes);
+    if (Either.isLeft(m)) {
+        return false;
+    }
+    return m.right == 6;
+};
 /**
  * @param bytes
  * @returns
  */
-export const peekTag = (bytes) => decodeTag(Bytes.makeStream(bytes).copy()).pipe(Effect.catchTag("Cbor.DecodeError", () => Effect.succeed(undefined)));
+export const peekTag = (bytes) => {
+    const t = decodeTag(Bytes.makeStream(bytes).copy());
+    if (Either.isLeft(t)) {
+        if (t.left._tag == "Cbor.DecodeError") {
+            return Either.right(undefined);
+        }
+        else {
+            return Either.left(t.left);
+        }
+    }
+    return Either.right(t.right);
+};
 /**
  * @param bytes
  * @returns
  */
-export const decodeTagged = (bytes) => Effect.gen(function* () {
+export const decodeTagged = (bytes) => Either.gen(function* () {
     const stream = Bytes.makeStream(bytes);
-    if (yield* isList(stream)) {
+    if (isList(stream)) {
         const decodeItem = yield* decodeListLazy(stream);
         const tag = Number(yield* decodeItem(decodeInt));
         return [tag, decodeItem];
@@ -1125,25 +1356,25 @@ export const decodeTagged = (bytes) => Effect.gen(function* () {
  * Defaults to empty tuple
  * @returns
  */
-export const decodeTuple = (itemDecoders, optionalDecoders = []) => (bytes) => Effect.gen(function* () {
+export const decodeTuple = (itemDecoders, optionalDecoders = []) => (bytes) => Either.gen(function* () {
     const stream = Bytes.makeStream(bytes);
     /**
      * decodeList is the right decoder, but has the wrong type interface
      * Cast the result to `any` to avoid type errors
      */
-    const res = yield* decodeList((itemStream, i) => Effect.gen(function* () {
+    const res = yield* decodeList((itemStream, i) => Either.gen(function* () {
         let decoder = itemDecoders[i];
         if (decoder === undefined) {
             decoder = optionalDecoders[i - itemDecoders.length];
             if (decoder === undefined) {
-                return yield* new DecodeError(itemStream, `expected at most ${itemDecoders.length + optionalDecoders.length} items, got more than ${i}`);
+                return yield* Either.left(new DecodeError(itemStream, `expected at most ${itemDecoders.length + optionalDecoders.length} items, got more than ${i}`));
             }
         }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return yield* decoder(itemStream);
     }))(stream);
     if (res.length < itemDecoders.length) {
-        return yield* new DecodeError(stream, `expected at least ${itemDecoders.length} items, only got ${res.length}`);
+        return yield* Either.left(new DecodeError(stream, `expected at least ${itemDecoders.length} items, only got ${res.length}`));
     }
     return res;
 });