diff --git a/benchmark/README.md b/benchmark/README.md
index d8eb581..4dcd47d 100644
--- a/benchmark/README.md
+++ b/benchmark/README.md
@@ -5,19 +5,19 @@ Tested on a M1 Pro MacBook Pro.
 ## Option
 
 ```
-fp-ts Option none x 134,775,969 ops/sec ±0.70% (99 runs sampled)
-fp-ts Option some x 95,087,860 ops/sec ±0.26% (97 runs sampled)
-fp-ts Option some chain x 121,914,020 ops/sec ±0.19% (98 runs sampled)
-Boxed Option none x 157,293,978 ops/sec ±0.11% (98 runs sampled)
-Boxed Option some x 204,144,235 ops/sec ±0.27% (94 runs sampled)
-Boxed Option some flatMap x 204,023,130 ops/sec ±0.65% (97 runs sampled)
+fp-ts Option none x 130,955,745 ops/sec ±1.11% (98 runs sampled)
+fp-ts Option some x 97,400,638 ops/sec ±0.26% (100 runs sampled)
+fp-ts Option some chain x 2,776,666 ops/sec ±0.16% (97 runs sampled)
+Boxed Option none x 1,030,036,990 ops/sec ±0.13% (100 runs sampled)
+Boxed Option some x 461,820,063 ops/sec ±0.20% (101 runs sampled)
+Boxed Option some flatMap x 461,736,015 ops/sec ±0.32% (97 runs sampled)
 ```
 
 ## Result
 
 ```
-fp-ts Result x 114,543,587 ops/sec ±0.15% (99 runs sampled)
-Boxed Result x 202,457,204 ops/sec ±0.27% (100 runs sampled)
+fp-ts Result x 117,922,535 ops/sec ±0.39% (98 runs sampled)
+Boxed Result x 465,661,918 ops/sec ±0.21% (101 runs sampled)
 ```
 
 ## Future
@@ -25,6 +25,6 @@ Boxed Result x 202,457,204 ops/sec ±0.27% (100 runs sampled)
 Careful on the interpretation of the following, as Future doesn't use microtasks and calls its listeners synchronously.
 
 ```
-Future x 36,365,914 ops/sec ±0.81% (92 runs sampled)
-Promise x 12,402,743 ops/sec ±0.94% (90 runs sampled)
+Future x 38,364,199 ops/sec ±0.68% (92 runs sampled)
+Promise x 13,482,385 ops/sec ±0.25% (90 runs sampled)
 ```
diff --git a/src/AsyncData.ts b/src/AsyncData.ts
index 2a2d003..0791feb 100644
--- a/src/AsyncData.ts
+++ b/src/AsyncData.ts
@@ -1,168 +1,113 @@
 import { keys, values } from "./Dict";
 import { Option, Result } from "./OptionResult";
-import { LooseRecord, Remap } from "./types";
+import { LooseRecord } from "./types";
 import { zip } from "./ZipUnzip";
 
-interface IAsyncData<A> {
+class __AsyncData<A> {
+  static P = {
+    Done: <const A>(value: A) => ({ tag: "Done", value }) as const,
+    NotAsked: { tag: "NotAsked" } as const,
+    Loading: { tag: "Loading" } as const,
+  };
   /**
-   * Returns the AsyncData containing the value from the callback
-   *
-   * (AsyncData\<A>, A => B) => AsyncData\<B>
-   */
-  map<B>(this: AsyncData<A>, func: (value: A) => B): AsyncData<B>;
-
-  /**
-   * Returns the AsyncData containing the value from the callback
-   *
-   * (AsyncData\<A>, A => AsyncData\<B>) => AsyncData\<B>
-   */
-  flatMap<B>(
-    this: AsyncData<A>,
-    func: (value: A) => AsyncData<B>,
-  ): AsyncData<B>;
-
-  /**
-   * Takes a callback taking the Ok value and returning a new result and returns an AsyncData with this new result
-   *
-   * (AsyncData\<Result<A, E>>, A => \<Result<B, F>) => AsyncData\<Result<B, F | E>>
-   */
-  mapOkToResult<A, E, B, F>(
-    this: AsyncData<Result<A, E>>,
-    func: (value: A) => Result<B, F>,
-  ): AsyncData<Result<B, F | E>>;
-
-  /**
-   * Takes a callback taking the Ok value and returning a new result and returns an AsyncData with this new result
-   *
-   * (AsyncData\<Result<A, E>>, E => \<Result<B, F>) => AsyncData\<Result<A | B, F>>
-   */
-  mapErrorToResult<A, E, B, F>(
-    this: AsyncData<Result<A, E>>,
-    func: (value: E) => Result<B, F>,
-  ): AsyncData<Result<A | B, F>>;
-
-  /**
-   * Takes a callback taking the Ok value and returning a new ok value and returns an AsyncData resolving to this new result
-   *
-   * (AsyncData\<Result<A, E>>, A => B) => AsyncData\<Result<B, E>>
-   */
-  mapOk<A, E, B>(
-    this: AsyncData<Result<A, E>>,
-    func: (value: A) => B,
-  ): AsyncData<Result<B, E>>;
-
-  /**
-   * Takes a callback taking the Error value and returning a new error value and returns an AsyncData to this new result
-   *
-   * (AsyncData\<Result<A, E>>, E => B) => AsyncData\<Result<A, B>>
-   */
-  mapError<A, E, B>(
-    this: AsyncData<Result<A, E>>,
-    func: (value: E) => B,
-  ): AsyncData<Result<A, B>>;
-
-  /**
-   * Takes a callback taking the Ok value and returning an AsyncData
-   *
-   * (AsyncData\<Result<A, E>>, A => AsyncData\<Result\<B, F>>) => AsyncData\<Result<B, F | E>>
-   */
-  flatMapOk<A, E, B, F>(
-    this: AsyncData<Result<A, E>>,
-    func: (value: A) => AsyncData<Result<B, F>>,
-  ): AsyncData<Result<B, F | E>>;
-
-  /**
-   * Takes a callback taking the Error value and returning an AsyncData
-   *
-   * (AsyncData\<Result<A, E>>, E => AsyncData\<Result\<B, F>>) => AsyncData\<Result<A | B, F | E>>
-   */
-  flatMapError<A, E, B, F>(
-    this: AsyncData<Result<A, E>>,
-    func: (value: E) => AsyncData<Result<B, F>>,
-  ): AsyncData<Result<A | B, F>>;
-
-  /**
-   * Return the value if present, and the fallback otherwise
-   *
-   * (AsyncData\<A>, A) => A
+   * Create an AsyncData.Done value
    */
-  getWithDefault(this: AsyncData<A>, defaultValue: A): A;
+  static Done = <A = never>(value: A): AsyncData<A> => {
+    const asyncData = Object.create(ASYNC_DATA_PROTO) as Done<A>;
+    asyncData.tag = "Done";
+    asyncData.value = value;
+    return asyncData;
+  };
 
   /**
-   * Explodes the AsyncData given its case
+   * Create an AsyncData.Loading value
    */
-  match<B>(
-    this: AsyncData<A>,
-    config: {
-      Done: (value: A) => B;
-      Loading: () => B;
-      NotAsked: () => B;
-    },
-  ): B;
+  static Loading = <A = never>(): AsyncData<A> => LOADING as Loading<A>;
 
   /**
-   * Runs the callback and returns `this`
+   * Create an AsyncData.NotAsked value
    */
-  tap(
-    this: AsyncData<A>,
-    func: (asyncData: AsyncData<A>) => unknown,
-  ): AsyncData<A>;
+  static NotAsked = <A = never>(): AsyncData<A> => NOT_ASKED as NotAsked<A>;
 
   /**
-   * Return an option of the value
-   *
-   * (AsyncData\<A>) => Option\<A>
+   * Turns an array of asyncData into an asyncData of array
    */
-  toOption(this: AsyncData<A>): Option<A>;
+  static all = <AsyncDatas extends AsyncData<any>[] | []>(
+    asyncDatas: AsyncDatas,
+  ) => {
+    const length = asyncDatas.length;
+    let acc = AsyncData.Done<Array<unknown>>([]);
+    let index = 0;
 
-  /**
-   * Typeguard
-   */
-  isDone(this: AsyncData<A>): this is Done<A>;
+    while (true) {
+      if (index >= length) {
+        return acc as AsyncData<{
+          [K in keyof AsyncDatas]: AsyncDatas[K] extends AsyncData<infer T>
+            ? T
+            : never;
+        }>;
+      }
 
-  /**
-   * Typeguard
-   */
-  isLoading(this: AsyncData<A>): this is Loading<A>;
+      const item = asyncDatas[index];
 
-  /**
-   * Typeguard
-   */
-  isNotAsked(this: AsyncData<A>): this is NotAsked<A>;
-}
+      if (item != null) {
+        acc = acc.flatMap((array) => {
+          return item.map((value) => {
+            array.push(value);
+            return array;
+          });
+        });
+      }
 
-type Done<A> = Remap<IAsyncData<A>> & {
-  tag: "Done";
-  value: A;
+      index++;
+    }
+  };
 
   /**
-   * Returns the value. Use within `if (asyncData.isDone()) { ... }`
+   * Turns an dict of asyncData into a asyncData of dict
    */
-  get(this: Done<A>): A;
-};
+  static allFromDict = <Dict extends LooseRecord<AsyncData<any>>>(
+    dict: Dict,
+  ): AsyncData<{
+    [K in keyof Dict]: Dict[K] extends AsyncData<infer T> ? T : never;
+  }> => {
+    const dictKeys = keys(dict);
 
-type Loading<A> = Remap<IAsyncData<A>> & {
-  tag: "Loading";
-};
+    return AsyncData.all(values(dict)).map((values) =>
+      Object.fromEntries(zip(dictKeys, values)),
+    );
+  };
 
-type NotAsked<A> = Remap<IAsyncData<A>> & {
-  tag: "NotAsked";
-};
+  static equals = <A>(
+    a: AsyncData<A>,
+    b: AsyncData<A>,
+    equals: (a: A, b: A) => boolean,
+  ) => {
+    return a.tag === "Done" && b.tag === "Done"
+      ? equals(a.value, b.value)
+      : a.tag === b.tag;
+  };
 
-export type AsyncData<A> = Done<A> | Loading<A> | NotAsked<A>;
+  static isAsyncData = (value: unknown): value is AsyncData<unknown> =>
+    // @ts-ignore
+    value != null && value.__boxed_type__ === "AsyncData";
 
-const asyncDataProto = (<A>(): IAsyncData<A> => ({
-  map<B>(this: AsyncData<A>, func: (value: A) => B) {
-    return this.tag === "Done"
-      ? Done(func(this.value))
-      : (this as unknown as AsyncData<B>);
-  },
+  map<B>(this: AsyncData<A>, func: (value: A) => B): AsyncData<B> {
+    if (this === NOT_ASKED || this === LOADING) {
+      return this as unknown as AsyncData<B>;
+    }
+    return AsyncData.Done(func((this as Done<A>).value));
+  }
 
-  flatMap<B>(this: AsyncData<A>, func: (value: A) => AsyncData<B>) {
-    return this.tag === "Done"
-      ? func(this.value)
-      : (this as unknown as AsyncData<B>);
-  },
+  flatMap<B>(
+    this: AsyncData<A>,
+    func: (value: A) => AsyncData<B>,
+  ): AsyncData<B> {
+    if (this === NOT_ASKED || this === LOADING) {
+      return this as unknown as AsyncData<B>;
+    }
+    return func((this as Done<A>).value);
+  }
 
   /**
    * For AsyncData<Result<*>>:
@@ -179,7 +124,7 @@ const asyncDataProto = (<A>(): IAsyncData<A> => ({
         Error: () => value as unknown as Result<B, E | F>,
       });
     });
-  },
+  }
 
   /**
    * For AsyncData<Result<*>>:
@@ -196,7 +141,7 @@ const asyncDataProto = (<A>(): IAsyncData<A> => ({
         Ok: () => value as unknown as Result<A | B, F>,
       });
     });
-  },
+  }
 
   /**
    * For AsyncData<Result<*>>:
@@ -213,7 +158,7 @@ const asyncDataProto = (<A>(): IAsyncData<A> => ({
         Error: () => value as unknown as Result<B, E>,
       });
     });
-  },
+  }
 
   /**
    * For AsyncData<Result<*>>:
@@ -231,7 +176,7 @@ const asyncDataProto = (<A>(): IAsyncData<A> => ({
         Error: (error) => Result.Error(func(error)),
       });
     });
-  },
+  }
 
   /**
    * For AsyncData<Result<*>>:
@@ -245,10 +190,10 @@ const asyncDataProto = (<A>(): IAsyncData<A> => ({
     return this.flatMap((value) => {
       return value.match({
         Ok: (value) => func(value) as AsyncData<Result<B, F | E>>,
-        Error: () => Done(value as unknown as Result<B, F | E>),
+        Error: () => AsyncData.Done(value as unknown as Result<B, F | E>),
       });
     });
-  },
+  }
 
   /**
    * For AsyncData<Result<*>>:
@@ -261,15 +206,25 @@ const asyncDataProto = (<A>(): IAsyncData<A> => ({
   ): AsyncData<Result<A | B, F>> {
     return this.flatMap((value) => {
       return value.match({
-        Ok: () => Done(value as unknown as Result<A | B, F>),
+        Ok: () => AsyncData.Done(value as unknown as Result<A | B, F>),
         Error: (error) => func(error) as AsyncData<Result<A | B, F>>,
       });
     });
-  },
+  }
 
-  getWithDefault(this: AsyncData<A>, defaultValue: A) {
-    return this.tag === "Done" ? this.value : defaultValue;
-  },
+  /**
+   * Returns the value. Use within `if (asyncData.isDone()) { ... }`
+   */
+  get(this: Done<A>) {
+    return this.value;
+  }
+
+  getWithDefault(this: AsyncData<A>, defaultValue: A): A {
+    if (this === NOT_ASKED || this === LOADING) {
+      return defaultValue;
+    }
+    return (this as Done<A>).value;
+  }
 
   match<B>(
     this: AsyncData<A>,
@@ -278,148 +233,73 @@ const asyncDataProto = (<A>(): IAsyncData<A> => ({
       Loading: () => B;
       NotAsked: () => B;
     },
-  ) {
-    return this.tag === "Done"
-      ? config.Done(this.value)
-      : this.tag === "Loading"
-      ? config.Loading()
-      : config.NotAsked();
-  },
+  ): B {
+    if (this === NOT_ASKED) {
+      return config.NotAsked();
+    }
+    if (this === LOADING) {
+      return config.Loading();
+    }
+    return config.Done((this as Done<A>).value);
+  }
 
   tap(this: AsyncData<A>, func: (asyncData: AsyncData<A>) => unknown) {
     func(this);
     return this;
-  },
+  }
 
-  toOption(this: AsyncData<A>) {
-    return this.tag === "Done" ? Option.Some(this.value) : Option.None();
-  },
+  toOption(this: AsyncData<A>): Option<A> {
+    if (this === NOT_ASKED || this === LOADING) {
+      return Option.None();
+    }
+    return Option.Some((this as Done<A>).value);
+  }
 
-  isDone(this: AsyncData<A>): boolean {
-    return this.tag === "Done";
-  },
+  isDone(this: AsyncData<A>): this is Done<A> {
+    return this !== NOT_ASKED && this !== LOADING;
+  }
 
-  isLoading(this: AsyncData<A>): boolean {
-    return this.tag === "Loading";
-  },
+  isLoading(this: AsyncData<A>): this is Loading<A> {
+    return this === LOADING;
+  }
 
-  isNotAsked(this: AsyncData<A>): boolean {
-    return this.tag === "NotAsked";
-  },
-}))();
+  isNotAsked(this: AsyncData<A>): this is NotAsked<A> {
+    return this === NOT_ASKED;
+  }
+}
 
 // @ts-expect-error
-asyncDataProto.__boxed_type__ = "AsyncData";
+__AsyncData.prototype.__boxed_type__ = "AsyncData";
 
-const doneProto = (<A>(): Omit<Done<A>, "tag" | "value"> => ({
-  ...(asyncDataProto as IAsyncData<A>),
-
-  get() {
-    return this.value;
-  },
-}))();
-
-const Done = <A = never>(value: A): AsyncData<A> => {
-  const asyncData = Object.create(doneProto) as Done<A>;
-  asyncData.tag = "Done";
-  asyncData.value = value;
-  return asyncData;
-};
+const ASYNC_DATA_PROTO = Object.create(
+  null,
+  Object.getOwnPropertyDescriptors(__AsyncData.prototype),
+);
 
 const LOADING = (() => {
-  const asyncData = Object.create(asyncDataProto) as Loading<unknown>;
+  const asyncData = Object.create(ASYNC_DATA_PROTO) as Loading<unknown>;
   asyncData.tag = "Loading";
   return asyncData;
 })();
 
 const NOT_ASKED = (() => {
-  const asyncData = Object.create(asyncDataProto) as NotAsked<unknown>;
+  const asyncData = Object.create(ASYNC_DATA_PROTO) as NotAsked<unknown>;
   asyncData.tag = "NotAsked";
   return asyncData;
 })();
 
-const Loading = <A = never>(): AsyncData<A> => LOADING as Loading<A>;
-const NotAsked = <A = never>(): AsyncData<A> => NOT_ASKED as NotAsked<A>;
-
-const asyncDataPattern = {
-  Done: <const A>(value: A) => ({ tag: "Done", value } as const),
-  NotAsked: { tag: "NotAsked" } as const,
-  Loading: { tag: "Loading" } as const,
-};
-
-export const AsyncData = {
-  /**
-   * Create an AsyncData.Done value
-   */
-  Done,
-
-  /**
-   * Create an AsyncData.Loading value
-   */
-  Loading,
-
-  /**
-   * Create an AsyncData.NotAsked value
-   */
-  NotAsked,
-
-  /**
-   * Turns an array of asyncData into an asyncData of array
-   */
-  all<AsyncDatas extends AsyncData<any>[] | []>(asyncDatas: AsyncDatas) {
-    const length = asyncDatas.length;
-    let acc = AsyncData.Done<Array<unknown>>([]);
-    let index = 0;
-
-    while (true) {
-      if (index >= length) {
-        return acc as AsyncData<{
-          [K in keyof AsyncDatas]: AsyncDatas[K] extends AsyncData<infer T>
-            ? T
-            : never;
-        }>;
-      }
-
-      const item = asyncDatas[index];
-
-      if (item != null) {
-        acc = acc.flatMap((array) => {
-          return item.map((value) => {
-            array.push(value);
-            return array;
-          });
-        });
-      }
-
-      index++;
-    }
-  },
-
-  /**
-   * Turns an dict of asyncData into a asyncData of dict
-   */
-  allFromDict<Dict extends LooseRecord<AsyncData<any>>>(
-    dict: Dict,
-  ): AsyncData<{
-    [K in keyof Dict]: Dict[K] extends AsyncData<infer T> ? T : never;
-  }> {
-    const dictKeys = keys(dict);
-
-    return AsyncData.all(values(dict)).map((values) =>
-      Object.fromEntries(zip(dictKeys, values)),
-    );
-  },
+interface Done<A> extends __AsyncData<A> {
+  tag: "Done";
+  value: A;
+}
 
-  equals<A>(a: AsyncData<A>, b: AsyncData<A>, equals: (a: A, b: A) => boolean) {
-    return a.tag === "Done" && b.tag === "Done"
-      ? equals(a.value, b.value)
-      : a.tag === b.tag;
-  },
+interface Loading<A> extends __AsyncData<A> {
+  tag: "Loading";
+}
 
-  isAsyncData: (value: unknown): value is AsyncData<unknown> =>
-    value != null &&
-    (Object.prototype.isPrototypeOf.call(doneProto, value) ||
-      Object.prototype.isPrototypeOf.call(asyncDataProto, value)),
+interface NotAsked<A> extends __AsyncData<A> {
+  tag: "NotAsked";
+}
 
-  P: asyncDataPattern,
-};
+export const AsyncData = __AsyncData;
+export type AsyncData<A> = Done<A> | Loading<A> | NotAsked<A>;
diff --git a/src/Future.ts b/src/Future.ts
index 95a9128..2733354 100644
--- a/src/Future.ts
+++ b/src/Future.ts
@@ -3,24 +3,34 @@ import { Result } from "./OptionResult";
 import { LooseRecord } from "./types";
 import { zip } from "./ZipUnzip";
 
-export class Future<A> {
+export class __Future<A> {
   /**
    * Creates a new future from its initializer function (like `new Promise(...)`)
    */
   static make = <A>(
     init: (resolver: (value: A) => void) => (() => void) | void,
   ): Future<A> => {
-    return new Future(init);
+    const future = Object.create(FUTURE_PROTO) as Future<A>;
+    const resolver = (value: A) => {
+      if (future._state.tag === "Pending") {
+        const resolveCallbacks = future._state.resolveCallbacks;
+        future._state = { tag: "Resolved", value };
+        resolveCallbacks?.forEach((func) => func(value));
+      }
+    };
+    future._state = { tag: "Pending" };
+    future._state.cancel = init(resolver);
+    return future as Future<A>;
   };
 
   static isFuture = (value: unknown): value is Future<unknown> =>
-    value != null && Object.prototype.isPrototypeOf.call(futureProto, value);
+    value != null && Object.prototype.isPrototypeOf.call(FUTURE_PROTO, value);
 
   /**
    * Creates a future resolved to the passed value
    */
   static value = <A>(value: A): Future<A> => {
-    const future = Object.create(futureProto);
+    const future = Object.create(FUTURE_PROTO);
     future._state = { tag: "Resolved", value };
     return future as Future<A>;
   };
@@ -98,19 +108,8 @@ export class Future<A> {
     | { tag: "Cancelled" }
     | { tag: "Resolved"; value: A };
 
-  protected constructor(
-    init: (resolver: (value: A) => void) => (() => void) | void,
-  ) {
-    const resolver = (value: A) => {
-      if (this._state.tag === "Pending") {
-        const resolveCallbacks = this._state.resolveCallbacks;
-        this._state = { tag: "Resolved", value };
-        resolveCallbacks?.forEach((func) => func(value));
-      }
-    };
-
+  protected constructor() {
     this._state = { tag: "Pending" };
-    this._state.cancel = init(resolver);
   }
 
   /**
@@ -145,7 +144,10 @@ export class Future<A> {
       const { cancel, cancelCallbacks } = this._state;
       // We have to set the future as cancelled first to avoid an infinite loop
       this._state = { tag: "Cancelled" };
-      cancel?.();
+      if (cancel != undefined) {
+        // @ts-ignore Compiler doesn't like that `cancel` is potentially `void`
+        cancel();
+      }
       cancelCallbacks?.forEach((func) => func());
     }
   }
@@ -390,7 +392,10 @@ export class Future<A> {
   }
 }
 
-const futureProto = Object.create(
+const FUTURE_PROTO = Object.create(
   null,
-  Object.getOwnPropertyDescriptors(Future.prototype),
+  Object.getOwnPropertyDescriptors(__Future.prototype),
 );
+
+export const Future = __Future;
+export type Future<A> = __Future<A>;
diff --git a/src/OptionResult.ts b/src/OptionResult.ts
index 4460ff1..569f606 100644
--- a/src/OptionResult.ts
+++ b/src/OptionResult.ts
@@ -1,221 +1,53 @@
 import { keys, values } from "./Dict";
-import { LooseRecord, Remap } from "./types";
+import { LooseRecord } from "./types";
 import { zip } from "./ZipUnzip";
 
-interface IOption<A> {
-  /**
-   * Returns the Option containing the value from the callback
-   *
-   * (Option\<A>, A => B) => Option\<B>
-   */
-  map<B>(this: Option<A>, func: (value: A) => B): Option<B>;
-
-  /**
-   * Returns the Option containing the value from the callback
-   *
-   * (Option\<A>, A => Option\<B>) => Option\<B>
-   */
-  flatMap<B>(this: Option<A>, func: (value: A) => Option<B>): Option<B>;
-
-  /**
-   * Returns the Option if its value matches the predicate, otherwise false
-   *
-   * (Option\<A>, A => boolean) => Option\<A>
-   */
-  filter<B extends A>(
-    this: Option<A>,
-    func: (value: A) => value is B,
-  ): Option<B>;
-  filter(this: Option<A>, func: (value: A) => boolean): Option<A>;
-
-  /**
-   * Return the value if present, and the fallback otherwise
-   *
-   * (Option\<A>, A) => A
-   */
-  getWithDefault(this: Option<A>, defaultValue: A): A;
-
-  /**
-   * Explodes the Option given its case
-   */
-  match<B>(
-    this: Option<A>,
-    config: { Some: (value: A) => B; None: () => B },
-  ): B;
-
-  /**
-   * Runs the callback and returns `this`
-   */
-  tap(this: Option<A>, func: (option: Option<A>) => unknown): Option<A>;
-
-  /**
-   * Converts the Option\<A> to a `A | undefined`
-   */
-  toUndefined(this: Option<A>): A | undefined;
-
-  /**
-   * Converts the Option\<A> to a `A | null`
-   */
-  toNull(this: Option<A>): A | null;
+class __Option<A> {
+  static P = {
+    Some: <const A>(value: A) => ({ tag: "Some", value }) as const,
+    None: { tag: "None" } as const,
+  };
 
-  /**
-   * Takes the option and turns it into Ok(value) is Some, or Error(valueWhenNone)
-   */
-  toResult<E>(this: Option<A>, valueWhenNone: E): Result<A, E>;
+  static Some = <A = never>(value: A): Option<A> => {
+    const option = Object.create(OPTION_PROTO) as Some<A>;
+    option.tag = "Some";
+    option.value = value;
+    return option;
+  };
 
-  /**
-   * Typeguard
-   */
-  isSome(this: Option<A>): this is Some<A>;
-
-  /**
-   * Typeguard
-   */
-  isNone(this: Option<A>): this is None<A>;
-}
+  static None = <A = never>(): Option<A> => NONE as None<A>;
 
-type Some<A> = Remap<IOption<A>> & {
-  tag: "Some";
-  value: A;
-
-  /**
-   * Returns the value. Use within `if (option.isSome()) { ... }`
-   */
-  get(this: Some<A>): A;
-};
-
-type None<A> = Remap<IOption<A>> & {
-  tag: "None";
-};
-
-export type Option<A> = Some<A> | None<A>;
-
-const optionProto = (<A>(): IOption<A> => ({
-  map<B>(this: Option<A>, func: (value: A) => B) {
-    return this.tag === "Some"
-      ? Some(func(this.value))
-      : (this as unknown as Option<B>);
-  },
-
-  flatMap<B>(this: Option<A>, func: (value: A) => Option<B>) {
-    return this.tag === "Some"
-      ? func(this.value)
-      : (this as unknown as Option<B>);
-  },
-
-  filter(this: Option<A>, func: (value: A) => boolean) {
-    return this.tag === "Some" && func(this.value) ? this : Option.None();
-  },
-
-  getWithDefault(this: Option<A>, defaultValue: A) {
-    return this.tag === "Some" ? this.value : defaultValue;
-  },
-
-  match<B>(this: Option<A>, config: { Some: (value: A) => B; None: () => B }) {
-    return this.tag === "Some" ? config.Some(this.value) : config.None();
-  },
-
-  tap(this: Option<A>, func: (option: Option<A>) => unknown) {
-    func(this);
-    return this;
-  },
-
-  toUndefined(this: Option<A>) {
-    return this.tag === "Some" ? this.value : undefined;
-  },
-
-  toNull(this: Option<A>) {
-    return this.tag === "Some" ? this.value : null;
-  },
-
-  toResult<E>(this: Option<A>, valueWhenNone: E): Result<A, E> {
-    return this.match({
-      Some: (ok) => Result.Ok(ok),
-      None: () => Result.Error(valueWhenNone),
-    });
-  },
-
-  isSome(this: Option<A>): boolean {
-    return this.tag === "Some";
-  },
-
-  isNone(this: Option<A>): boolean {
-    return this.tag === "None";
-  },
-}))();
-
-// @ts-expect-error
-optionProto.__boxed_type__ = "Option";
-
-const someProto = (<A>(): Omit<Some<A>, "tag" | "value"> => ({
-  ...(optionProto as IOption<A>),
-
-  get() {
-    return this.value;
-  },
-}))();
-
-const Some = <A = never>(value: A): Option<A> => {
-  const option = Object.create(someProto) as Some<A>;
-  option.tag = "Some";
-  option.value = value;
-  return option;
-};
-
-const NONE = (() => {
-  const option = Object.create(optionProto) as None<unknown>;
-  option.tag = "None";
-  return option;
-})();
-
-const None = <A = never>(): Option<A> => NONE as None<A>;
-
-const optionPattern = {
-  Some: <const A>(value: A) => ({ tag: "Some", value } as const),
-  None: { tag: "None" } as const,
-};
-
-export const Option = {
-  /**
-   * Create an Option.Some value
-   */
-  Some,
-
-  /**
-   * Create an Option.None value
-   */
-  None,
-
-  isOption: (value: unknown): value is Option<unknown> =>
-    value != null &&
-    (Object.prototype.isPrototypeOf.call(optionProto, value) ||
-      Object.prototype.isPrototypeOf.call(someProto, value)),
+  static isOption = (value: unknown): value is Option<unknown> =>
+    // @ts-ignore
+    value != null && value.__boxed_type__ === "Option";
 
   /**
    * Create an Option from a nullable value
    */
-  fromNullable<A>(nullable: A | null | undefined): Option<A> {
-    return nullable == null ? None<A>() : Some<A>(nullable);
-  },
+  static fromNullable = <A>(nullable: A | null | undefined): Option<A> => {
+    return nullable == null ? (NONE as None<A>) : Option.Some<A>(nullable);
+  };
 
   /**
    * Create an Option from a value | null
    */
-  fromNull<A>(nullable: A | null): Option<A> {
-    return nullable === null ? None<A>() : Some<A>(nullable);
-  },
+  static fromNull = <A>(nullable: A | null): Option<A> => {
+    return nullable === null ? (NONE as None<A>) : Option.Some<A>(nullable);
+  };
 
   /**
    * Create an Option from a undefined | value
    */
-  fromUndefined<A>(nullable: A | undefined): Option<A> {
-    return nullable === undefined ? None<A>() : Some<A>(nullable);
-  },
+  static fromUndefined = <A>(nullable: A | undefined): Option<A> => {
+    return nullable === undefined
+      ? (NONE as None<A>)
+      : Option.Some<A>(nullable);
+  };
 
   /**
    * Turns an array of options into an option of array
    */
-  all<Options extends Option<any>[] | []>(options: Options) {
+  static all = <Options extends Option<any>[] | []>(options: Options) => {
     const length = options.length;
     let acc = Option.Some<Array<unknown>>([]);
     let index = 0;
@@ -240,302 +72,247 @@ export const Option = {
 
       index++;
     }
-  },
+  };
 
   /**
    * Turns an dict of options into a options of dict
    */
-  allFromDict<Dict extends LooseRecord<Option<any>>>(
+  static allFromDict = <Dict extends LooseRecord<Option<any>>>(
     dict: Dict,
   ): Option<{
     [K in keyof Dict]: Dict[K] extends Option<infer T> ? T : never;
-  }> {
+  }> => {
     const dictKeys = keys(dict);
 
-    return this.all(values(dict)).map((values) =>
+    return Option.all(values(dict)).map((values) =>
       Object.fromEntries(zip(dictKeys, values)),
     );
-  },
+  };
 
-  equals<A>(
+  static equals = <A>(
     a: Option<A>,
     b: Option<A>,
     equals: (a: A, b: A) => boolean,
-  ): boolean {
-    return a.tag === "Some" && b.tag === "Some"
-      ? equals(a.value, b.value)
+  ): boolean => {
+    return a.isSome() && b.isSome()
+      ? equals(a.get(), b.get())
       : a.tag === b.tag;
-  },
-
-  P: optionPattern,
-};
+  };
 
-interface IResult<A, E> {
   /**
-   * Returns the Result containing the value from the callback
+   * Returns the Option containing the value from the callback
    *
-   * (Result\<A, E>, A => B) => Result\<B>
+   * (Option\<A>, A => B) => Option\<B>
    */
-  map<B>(this: Result<A, E>, func: (value: A) => B): Result<B, E>;
+  map<B>(this: Option<A>, func: (value: A) => B): Option<B> {
+    if (this === NONE) {
+      return this as unknown as Option<B>;
+    }
+    return Option.Some(func((this as Some<A>).value));
+  }
 
   /**
-   * Returns the Result containing the error returned from the callback
+   * Returns the Option containing the value from the callback
    *
-   * (Result\<A, E>, E => F) => Result\<F>
+   * (Option\<A>, A => Option\<B>) => Option\<B>
    */
-  mapError<F>(this: Result<A, E>, func: (value: E) => F): Result<A, F>;
+  flatMap<B>(this: Option<A>, func: (value: A) => Option<B>): Option<B> {
+    if (this === NONE) {
+      return this as unknown as Option<B>;
+    }
+    return func((this as Some<A>).value);
+  }
 
   /**
-   * Returns the Result containing the value from the callback
+   * Returns the Option if its value matches the predicate, otherwise false
    *
-   * (Result\<A, E>, A => Result\<B, F>) => Result\<B, E | F>
+   * (Option\<A>, A => boolean) => Option\<A>
    */
-  flatMap<B, F>(
-    this: Result<A, E>,
-    func: (value: A) => Result<B, F>,
-  ): Result<B, F | E>;
+  filter<B extends A>(
+    this: Option<A>,
+    func: (value: A) => value is B,
+  ): Option<B>;
+  filter(this: Option<A>, func: (value: A) => boolean): Option<A>;
+  filter(this: Option<A>, func: (value: A) => boolean): Option<A> {
+    if (this === NONE) {
+      return this as unknown as Option<A>;
+    }
+    return func((this as Some<A>).value) ? this : (NONE as None<A>);
+  }
 
   /**
-   * Returns the Result containing the value from the callback
-   *
-   * (Result\<A, E>, E => Result\<A, F>) => Result\<A | B, F>
+   * Returns the value. Use within `if (Option.isSome()) { ... }`
    */
-  flatMapError<B, F>(
-    this: Result<A, E>,
-    func: (value: E) => Result<B, F>,
-  ): Result<A | B, F>;
-
+  get(this: Some<A>) {
+    return this.value;
+  }
   /**
    * Return the value if present, and the fallback otherwise
    *
-   * (Result\<A, E>, A) => A
+   * (Option\<A>, A) => A
    */
-  getWithDefault(this: Result<A, E>, defaultValue: A): A;
+  getWithDefault(this: Option<A>, defaultValue: A): A {
+    if (this === NONE) {
+      return defaultValue;
+    }
+    return (this as Some<A>).value;
+  }
 
   /**
-   * Explodes the Result given its case
+   * Explodes the Option given its case
    */
   match<B>(
-    this: Result<A, E>,
-    config: { Ok: (value: A) => B; Error: (error: E) => B },
-  ): B;
+    this: Option<A>,
+    config: { Some: (value: A) => B; None: () => B },
+  ): B {
+    if (this === NONE) {
+      return config.None();
+    }
+    return config.Some((this as Some<A>).value);
+  }
 
   /**
    * Runs the callback and returns `this`
    */
-  tap(
-    this: Result<A, E>,
-    func: (result: Result<A, E>) => unknown,
-  ): Result<A, E>;
+  tap(this: Option<A>, func: (option: Option<A>) => unknown): Option<A> {
+    func(this);
+    return this;
+  }
 
   /**
-   * Runs the callback if ok and returns `this`
+   * Converts the Option\<A> to a `A | undefined`
    */
-  tapOk(this: Result<A, E>, func: (value: A) => unknown): Result<A, E>;
+  toUndefined(this: Option<A>): A | undefined {
+    if (this === NONE) {
+      return undefined;
+    }
+    return (this as Some<A>).value;
+  }
 
   /**
-   * Runs the callback if error and returns `this`
+   * Converts the Option\<A> to a `A | null`
    */
-  tapError(this: Result<A, E>, func: (error: E) => unknown): Result<A, E>;
+  toNull(this: Option<A>): A | null {
+    if (this === NONE) {
+      return null;
+    }
+    return (this as Some<A>).value;
+  }
 
   /**
-   * Return an option of the value
-   *
-   * (Result\<A, E>) => Option\<A>
+   * Takes the option and turns it into Ok(value) is Some, or Error(valueWhenNone)
    */
-  toOption(this: Result<A, E>): Option<A>;
+  toResult<E>(this: Option<A>, valueWhenNone: E): Result<A, E> {
+    return this.match({
+      Some: (ok) => Result.Ok(ok),
+      None: () => Result.Error(valueWhenNone),
+    });
+  }
 
   /**
    * Typeguard
    */
-  isOk(this: Result<A, E>): this is Ok<A, E>;
+  isSome(this: Option<A>): this is Some<A> {
+    return this !== NONE;
+  }
 
   /**
    * Typeguard
    */
-  isError(this: Result<A, E>): this is Error<A, E>;
+  isNone(this: Option<A>): this is None<A> {
+    return this === NONE;
+  }
 }
 
-type Ok<A, E> = Remap<IResult<A, E>> & {
-  tag: "Ok";
-  value: A;
-
-  /**
-   * Returns the ok value. Use within `if (result.isOk()) { ... }`
-   */
-  get(this: Ok<A, E>): A;
-};
-
-type Error<A, E> = Remap<IResult<A, E>> & {
-  tag: "Error";
-  value: E;
-
-  /**
-   * Returns the error value. Use within `if (result.isError()) { ... }`
-   */
-  getError(this: Error<A, E>): E;
-};
-
-export type Result<A, E> = Ok<A, E> | Error<A, E>;
-
-const resultProto = (<A, E>(): IResult<A, E> => ({
-  map<B>(this: Result<A, E>, func: (value: A) => B) {
-    return this.tag === "Ok"
-      ? Ok(func(this.value))
-      : (this as unknown as Result<B, E>);
-  },
-
-  mapError<F>(this: Result<A, E>, func: (value: E) => F) {
-    return this.tag === "Ok"
-      ? (this as unknown as Result<A, F>)
-      : Error(func(this.value));
-  },
-
-  flatMap<B, F>(this: Result<A, E>, func: (value: A) => Result<B, F>) {
-    return this.tag === "Ok"
-      ? func(this.value)
-      : (this as unknown as Result<B, F | E>);
-  },
-
-  flatMapError<B, F>(this: Result<A, E>, func: (value: E) => Result<B, F>) {
-    return this.tag === "Ok"
-      ? (this as unknown as Result<A | B, F>)
-      : func(this.value);
-  },
-
-  getWithDefault(this: Result<A, E>, defaultValue: A) {
-    return this.tag === "Ok" ? this.value : defaultValue;
-  },
-
-  match<B>(
-    this: Result<A, E>,
-    config: { Ok: (value: A) => B; Error: (error: E) => B },
-  ) {
-    return this.tag === "Ok" ? config.Ok(this.value) : config.Error(this.value);
-  },
-
-  tap(this: Result<A, E>, func: (result: Result<A, E>) => unknown) {
-    func(this);
-    return this;
-  },
-
-  tapOk(this: Result<A, E>, func: (value: A) => unknown) {
-    if (this.tag === "Ok") {
-      func(this.value);
-    }
-    return this;
-  },
-
-  tapError(this: Result<A, E>, func: (error: E) => unknown) {
-    if (this.tag === "Error") {
-      func(this.value);
-    }
-    return this;
-  },
-
-  toOption(this: Result<A, E>) {
-    return this.tag === "Ok" ? Some(this.value) : None();
-  },
-
-  isOk(this: Result<A, E>): boolean {
-    return this.tag === "Ok";
-  },
-
-  isError(this: Result<A, E>): boolean {
-    return this.tag === "Error";
-  },
-}))();
-
 // @ts-expect-error
-resultProto.__boxed_type__ = "Result";
+__Option.prototype.__boxed_type__ = "Option";
 
-const okProto = (<A, E>(): Omit<Ok<A, E>, "tag" | "value"> => ({
-  ...(resultProto as IResult<A, E>),
+const OPTION_PROTO = Object.create(
+  null,
+  Object.getOwnPropertyDescriptors(__Option.prototype),
+);
 
-  get() {
-    return this.value;
-  },
-}))();
-
-const errorProto = (<A, E>(): Omit<Error<A, E>, "tag" | "value"> => ({
-  ...(resultProto as IResult<A, E>),
+const NONE = (() => {
+  const option = Object.create(OPTION_PROTO) as None<unknown>;
+  option.tag = "None";
+  return option;
+})();
 
-  getError() {
-    return this.value;
-  },
-}))();
+interface Some<A> extends __Option<A> {
+  tag: "Some";
+  value: A;
+}
 
-const Ok = <A = never, E = never>(value: A): Result<A, E> => {
-  const result = Object.create(okProto) as Ok<A, E>;
-  result.tag = "Ok";
-  result.value = value;
-  return result;
-};
+interface None<A> extends __Option<A> {
+  tag: "None";
+}
 
-const Error = <A = never, E = never>(value: E): Result<A, E> => {
-  const result = Object.create(errorProto) as Error<A, E>;
-  result.tag = "Error";
-  result.value = value;
-  return result;
-};
+export const Option = __Option;
+export type Option<A> = Some<A> | None<A>;
 
-const resultPattern = {
-  Ok: <const A>(value: A) => ({ tag: "Ok", value } as const),
-  Error: <const E>(value: E) => ({ tag: "Error", value } as const),
-};
+class __Result<A, E> {
+  static P = {
+    Ok: <const A>(value: A) => ({ tag: "Ok", value }) as const,
+    Error: <const E>(error: E) => ({ tag: "Error", error }) as const,
+  };
 
-export const Result = {
-  /**
-   * Create an Result.Ok value
-   */
-  Ok,
+  static Ok = <A = never, E = never>(value: A): Result<A, E> => {
+    const result = Object.create(RESULT_PROTO) as Ok<A, E>;
+    result.tag = "Ok";
+    result.value = value;
+    return result;
+  };
 
-  /**
-   * Create an Result.Error value
-   */
-  Error,
+  static Error = <A = never, E = never>(error: E): Result<A, E> => {
+    const result = Object.create(RESULT_PROTO) as Error<A, E>;
+    result.tag = "Error";
+    result.error = error;
+    return result;
+  };
 
-  isResult: (value: unknown): value is Result<unknown, unknown> =>
-    value != null &&
-    (Object.prototype.isPrototypeOf.call(okProto, value) ||
-      Object.prototype.isPrototypeOf.call(errorProto, value)),
+  static isResult = (value: unknown): value is Result<unknown, unknown> =>
+    // @ts-ignore
+    value != null && value.__boxed_type__ === "Result";
 
   /**
    * Runs the function and resolves a result of its return value, or to an error if thrown
    */
-  fromExecution<A, E = unknown>(func: () => A): Result<A, E> {
+  static fromExecution = <A, E = unknown>(func: () => A): Result<A, E> => {
     try {
       return Result.Ok(func());
     } catch (error) {
       return Result.Error(error) as Result<A, E>;
     }
-  },
+  };
 
   /**
    * Takes the promise and resolves a result of its value, or to an error if rejected
    */
-  async fromPromise<A, E = unknown>(
+  static fromPromise = async <A, E = unknown>(
     promise: Promise<A>,
-  ): Promise<Result<A, E>> {
+  ): Promise<Result<A, E>> => {
     try {
       const value = await promise;
       return Result.Ok<A, E>(value);
     } catch (error) {
       return Result.Error<A, E>(error as E);
     }
-  },
+  };
 
   /**
    * Takes the option and turns it into Ok(value) is Some, or Error(valueWhenNone)
    */
-  fromOption<A, E>(option: Option<A>, valueWhenNone: E): Result<A, E> {
+  static fromOption = <A, E>(
+    option: Option<A>,
+    valueWhenNone: E,
+  ): Result<A, E> => {
     return option.toResult(valueWhenNone);
-  },
+  };
 
   /**
    * Turns an array of results into an result of array
    */
-  all<Results extends Result<any, any>[] | []>(results: Results) {
+  static all = <Results extends Result<any, any>[] | []>(results: Results) => {
     const length = results.length;
     let acc = Result.Ok<Array<unknown>, unknown>([]);
     let index = 0;
@@ -569,12 +346,12 @@ export const Result = {
 
       index++;
     }
-  },
+  };
 
   /**
    * Turns an dict of results into a results of dict
    */
-  allFromDict<Dict extends LooseRecord<Result<any, any>>>(
+  static allFromDict = <Dict extends LooseRecord<Result<any, any>>>(
     dict: Dict,
   ): Result<
     {
@@ -583,27 +360,187 @@ export const Result = {
     {
       [K in keyof Dict]: Dict[K] extends Result<any, infer T> ? T : never;
     }[keyof Dict]
-  > {
+  > => {
     const dictKeys = keys(dict);
 
     return Result.all(values(dict)).map((values) =>
       Object.fromEntries(zip(dictKeys, values)),
     );
-  },
+  };
 
-  equals<A, E>(
+  static equals = <A, E>(
     a: Result<A, E>,
     b: Result<A, E>,
     equals: (a: A, b: A) => boolean,
-  ) {
+  ) => {
     if (a.tag !== b.tag) {
       return false;
     }
-    if (a.tag === "Error" && b.tag === "Error") {
+    if (a.isError() && b.isError()) {
       return true;
     }
-    return equals(a.value as unknown as A, b.value as unknown as A);
-  },
 
-  P: resultPattern,
-};
+    if (a.isOk() && b.isOk()) {
+      return equals(a.get(), b.get());
+    }
+
+    return false;
+  };
+
+  /**
+   * Returns the Result containing the value from the callback
+   *
+   * (Result\<A, E>, A => B) => Result\<B>
+   */
+  map<B>(this: Result<A, E>, func: (value: A) => B): Result<B, E> {
+    return this.tag === "Ok"
+      ? Result.Ok(func(this.value))
+      : (this as unknown as Result<B, E>);
+  }
+
+  /**
+   * Returns the Result containing the error returned from the callback
+   *
+   * (Result\<A, E>, E => F) => Result\<F>
+   */
+  mapError<F>(this: Result<A, E>, func: (value: E) => F): Result<A, F> {
+    return this.tag === "Ok"
+      ? (this as unknown as Result<A, F>)
+      : Result.Error(func(this.error));
+  }
+
+  /**
+   * Returns the Result containing the value from the callback
+   *
+   * (Result\<A, E>, A => Result\<B, F>) => Result\<B, E | F>
+   */
+  flatMap<B, F>(
+    this: Result<A, E>,
+    func: (value: A) => Result<B, F>,
+  ): Result<B, F | E> {
+    return this.tag === "Ok"
+      ? func(this.value)
+      : (this as unknown as Result<B, F | E>);
+  }
+
+  /**
+   * Returns the Result containing the value from the callback
+   *
+   * (Result\<A, E>, E => Result\<A, F>) => Result\<A | B, F>
+   */
+  flatMapError<B, F>(
+    this: Result<A, E>,
+    func: (value: E) => Result<B, F>,
+  ): Result<A | B, F> {
+    return this.tag === "Ok"
+      ? (this as unknown as Result<A | B, F>)
+      : func(this.error);
+  }
+  /**
+   * Returns the value. Use within `if (result.isOk()) { ... }`
+   */
+  get(this: Ok<A, E>) {
+    return this.value;
+  }
+
+  /**
+   * Returns the error. Use within `if (result.isError()) { ... }`
+   */
+  getError(this: Error<A, E>) {
+    return this.error;
+  }
+
+  /**
+   * Return the value if present, and the fallback otherwise
+   *
+   * (Result\<A, E>, A) => A
+   */
+  getWithDefault(this: Result<A, E>, defaultValue: A): A {
+    return this.tag === "Ok" ? this.value : defaultValue;
+  }
+
+  /**
+   * Explodes the Result given its case
+   */
+  match<B>(
+    this: Result<A, E>,
+    config: { Ok: (value: A) => B; Error: (error: E) => B },
+  ): B {
+    return this.tag === "Ok" ? config.Ok(this.value) : config.Error(this.error);
+  }
+
+  /**
+   * Runs the callback and returns `this`
+   */
+  tap(
+    this: Result<A, E>,
+    func: (result: Result<A, E>) => unknown,
+  ): Result<A, E> {
+    func(this);
+    return this;
+  }
+
+  /**
+   * Runs the callback if ok and returns `this`
+   */
+  tapOk(this: Result<A, E>, func: (value: A) => unknown): Result<A, E> {
+    if (this.tag === "Ok") {
+      func(this.value);
+    }
+    return this;
+  }
+
+  /**
+   * Runs the callback if error and returns `this`
+   */
+  tapError(this: Result<A, E>, func: (error: E) => unknown): Result<A, E> {
+    if (this.tag === "Error") {
+      func(this.error);
+    }
+    return this;
+  }
+
+  /**
+   * Return an option of the value
+   *
+   * (Result\<A, E>) => Option\<A>
+   */
+  toOption(this: Result<A, E>): Option<A> {
+    return this.tag === "Ok" ? Option.Some(this.value) : (NONE as None<A>);
+  }
+
+  /**
+   * Typeguard
+   */
+  isOk(this: Result<A, E>): this is Ok<A, E> {
+    return this.tag === "Ok";
+  }
+
+  /**
+   * Typeguard
+   */
+  isError(this: Result<A, E>): this is Error<A, E> {
+    return this.tag === "Error";
+  }
+}
+
+// @ts-expect-error
+__Result.prototype.__boxed_type__ = "Result";
+
+const RESULT_PROTO = Object.create(
+  null,
+  Object.getOwnPropertyDescriptors(__Result.prototype),
+);
+
+interface Ok<A, E> extends __Result<A, E> {
+  tag: "Ok";
+  value: A;
+}
+
+interface Error<A, E> extends __Result<A, E> {
+  tag: "Error";
+  error: E;
+}
+
+export const Result = __Result;
+export type Result<A, E> = Ok<A, E> | Error<A, E>;
diff --git a/src/Serializer.ts b/src/Serializer.ts
index 3650ed5..742e63d 100644
--- a/src/Serializer.ts
+++ b/src/Serializer.ts
@@ -20,6 +20,7 @@ export const encode = (value: any, indent?: number | undefined) => {
           __boxed_type__: "Result",
           tag: value.tag,
           value: value.value,
+          error: value.error,
         };
       }
       if (value.__boxed_type__ === "AsyncData") {
@@ -46,7 +47,7 @@ export const decode = (value: string) => {
     if (value.__boxed_type__ === "Result") {
       return value.tag === "Ok"
         ? Result.Ok(value.value)
-        : Result.Error(value.value);
+        : Result.Error(value.error);
     }
     if (value.__boxed_type__ === "AsyncData") {
       return value.tag === "NotAsked"
diff --git a/src/types.ts b/src/types.ts
index b025b2f..163c8ab 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -1,5 +1 @@
 export type LooseRecord<T> = Record<PropertyKey, T>;
-
-export type Remap<T> = {
-  [K in keyof T]: T[K];
-};
diff --git a/test/Result.test.ts b/test/Result.test.ts
index 80937c6..6f575f0 100644
--- a/test/Result.test.ts
+++ b/test/Result.test.ts
@@ -139,7 +139,7 @@ test("Result.equals", () => {
 test("Result serialize", () => {
   expect(JSON.parse(JSON.stringify(Result.Error(1)))).toEqual({
     tag: "Error",
-    value: 1,
+    error: 1,
   });
   expect(JSON.parse(JSON.stringify(Result.Ok(1)))).toEqual({
     tag: "Ok",