New Feature: generate setoid instance, closes #12

Author: gcanti

CHANGELOG.md

@@ -13,6 +13,11 @@
 **Note**: Gaps between patch versions are faulty/broken releases.
 **Note**: A feature tagged as Experimental is in a high state of flux, you're at risk of it changing without notice.
 
+# 0.2.2
+
+- **New Feature**
+  - generate setoid instance, closes #12 (@gcanti)
+
 # 0.2.1
 
 - **New Feature**

README.md

@@ -83,6 +83,27 @@ export function _none<A>(): Prism<Option<A>, Option<A>> {
 export function _some<A>(): Prism<Option<A>, Option<A>> {
   return Prism.fromPredicate(s => s.type === 'Some')
 }
+
+/** Setoid instance */
+
+import { Setoid } from 'fp-ts/lib/Setoid'
+
+export function getSetoid<A>(setoidSomeValue0: Setoid<A>): Setoid<Option<A>> {
+  return {
+    equals: (x, y) => {
+      if (x === y) {
+        return true
+      }
+      if (x.type === 'None' && y.type === 'None') {
+        return true
+      }
+      if (x.type === 'Some' && y.type === 'Some') {
+        return setoidSomeValue0.equals(x.value0, y.value0)
+      }
+      return false
+    }
+  }
+}
 ```
 
 # Records
@@ -251,14 +272,16 @@ export interface Options {
    */
   handlersStyle: { type: 'positional' } | { type: 'record'; handlersName: string }
   encoding: 'literal' | 'fp-ts'
+  version: '1.13' | '1.14'
 }
 
 export const defaultOptions: Options = {
   tagName: 'type',
   foldName: 'fold',
   matcheeName: 'fa',
   handlersStyle: { type: 'positional' },
-  encoding: 'literal'
+  encoding: 'literal',
+  version: '1.13'
 }
 ```
 

docs/bundle.js

@@ -25,3 +25,13 @@ export function _fetching<A extends string>(): Prism<Constrained<A>, Constrained
 
 export function _gotData<A extends string>(): Prism<Constrained<A>, Constrained<A>> { return Prism.fromPredicate(s => s.type === "GotData"); }
 
+import { Setoid } from "fp-ts/lib/Setoid";
+
+export function getSetoid<A extends string>(setoidGotDataValue0: Setoid<A>): Setoid<Constrained<A>> { return { equals: (x, y) => { if (x === y) {
+        return true;
+    } if (x.type === "Fetching" && y.type === "Fetching") {
+        return true;
+    } if (x.type === "GotData" && y.type === "GotData") {
+        return setoidGotDataValue0.equals(x.value0, y.value0);
+    } return false; } }; }
+

examples/Constrained.ts

@@ -21,3 +21,13 @@ export function _left<L, R>(): Prism<Either<L, R>, Either<L, R>> { return Prism.
 
 export function _right<L, R>(): Prism<Either<L, R>, Either<L, R>> { return Prism.fromPredicate(s => s.type === "Right"); }
 
+import { Setoid } from "fp-ts/lib/Setoid";
+
+export function getSetoid<L, R>(setoidLeftValue0: Setoid<L>, setoidRightValue0: Setoid<R>): Setoid<Either<L, R>> { return { equals: (x, y) => { if (x === y) {
+        return true;
+    } if (x.type === "Left" && y.type === "Left") {
+        return setoidLeftValue0.equals(x.value0, y.value0);
+    } if (x.type === "Right" && y.type === "Right") {
+        return setoidRightValue0.equals(x.value0, y.value0);
+    } return false; } }; }
+

examples/Either.ts

@@ -0,0 +1,46 @@
+export type FooBarBaz = {
+    readonly type: "Foo";
+} | {
+    readonly type: "Bar";
+} | {
+    readonly type: "Baz";
+};
+
+export const foo: FooBarBaz = { type: "Foo" };
+
+export const bar: FooBarBaz = { type: "Bar" };
+
+export const baz: FooBarBaz = { type: "Baz" };
+
+export function fold<R>(fa: FooBarBaz, onFoo: R, onBar: R, onBaz: R): R { switch (fa.type) {
+    case "Foo": return onFoo;
+    case "Bar": return onBar;
+    case "Baz": return onBaz;
+} }
+
+export function foldL<R>(fa: FooBarBaz, onFoo: () => R, onBar: () => R, onBaz: () => R): R { switch (fa.type) {
+    case "Foo": return onFoo();
+    case "Bar": return onBar();
+    case "Baz": return onBaz();
+} }
+
+import { Prism } from "monocle-ts";
+
+export const _Foo: Prism<FooBarBaz, FooBarBaz> = Prism.fromPredicate(s => s.type === "Foo");
+
+export const _Bar: Prism<FooBarBaz, FooBarBaz> = Prism.fromPredicate(s => s.type === "Bar");
+
+export const _Baz: Prism<FooBarBaz, FooBarBaz> = Prism.fromPredicate(s => s.type === "Baz");
+
+import { Setoid } from "fp-ts/lib/Setoid";
+
+export function getSetoid(): Setoid<FooBarBaz> { return { equals: (x, y) => { if (x === y) {
+        return true;
+    } if (x.type === "Foo" && y.type === "Foo") {
+        return true;
+    } if (x.type === "Bar" && y.type === "Bar") {
+        return true;
+    } if (x.type === "Baz" && y.type === "Baz") {
+        return true;
+    } return false; } }; }
+

examples/FooBar.ts

@@ -25,3 +25,13 @@ export function _nothing<A>(): Prism<Maybe<A>, Maybe<A>> { return Prism.fromPred
 
 export function _just<A>(): Prism<Maybe<A>, Maybe<A>> { return Prism.fromPredicate(s => s.type === "Just"); }
 
+import { Setoid } from "fp-ts/lib/Setoid";
+
+export function getSetoid<A>(setoidJustValue: Setoid<A>): Setoid<Maybe<A>> { return { equals: (x, y) => { if (x === y) {
+        return true;
+    } if (x.type === "Nothing" && y.type === "Nothing") {
+        return true;
+    } if (x.type === "Just" && y.type === "Just") {
+        return setoidJustValue.equals(x.value, y.value);
+    } return false; } }; }
+

examples/FooBarBaz.ts

@@ -25,3 +25,13 @@ export function _none<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredi
 
 export function _some<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.type === "Some"); }
 
+import { Setoid } from "fp-ts/lib/Setoid";
+
+export function getSetoid<A>(setoidSomeValue0: Setoid<A>): Setoid<Option<A>> { return { equals: (x, y) => { if (x === y) {
+        return true;
+    } if (x.type === "None" && y.type === "None") {
+        return true;
+    } if (x.type === "Some" && y.type === "Some") {
+        return setoidSomeValue0.equals(x.value0, y.value0);
+    } return false; } }; }
+

examples/Maybe.ts

@@ -5,3 +5,9 @@ export type State<S, A> = {
 
 export function state<S, A>(value0: (s: S) => [A, S]): State<S, A> { return { type: "State", value0 }; }
 
+import { Setoid } from "fp-ts/lib/Setoid";
+
+export function getSetoid<S, A>(setoidValue0: Setoid<(s: S) => [A, S]>): Setoid<State<S, A>> { return { equals: (x, y) => { if (x === y) {
+        return true;
+    } return setoidValue0.equals(x.value0, y.value0); } }; }
+