upgrade to fp-ts@1.14

gcanti · gcanti · commit 8e01ab7a4731 · 2019-02-22T08:40:32.000+01:00
diff --git a/CHANGELOG.md b/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.3.0
+
+- **Breaking Change**
+  - upgrade to `fp-ts@1.14.x` (@gcanti)
+
 # 0.2.2
 
 - **New Feature**
diff --git a/README.md b/README.md
@@ -272,16 +272,14 @@ 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',
-  version: '1.13'
+  encoding: 'literal'
 }
 ```
 
diff --git a/docs/bundle.js b/docs/bundle.js
diff --git a/examples/Constrained.ts b/examples/Constrained.ts
@@ -25,13 +25,11 @@ 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; } }; }
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
+
+export function getSetoid<A extends string>(setoidGotDataValue0: Setoid<A>): Setoid<Constrained<A>> { return fromEquals((x, y) => { 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; }); }
 
diff --git a/examples/Either.ts b/examples/Either.ts
@@ -21,13 +21,11 @@ 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; } }; }
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
+
+export function getSetoid<L, R>(setoidLeftValue0: Setoid<L>, setoidRightValue0: Setoid<R>): Setoid<Either<L, R>> { return fromEquals((x, y) => { 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; }); }
 
diff --git a/examples/FooBarBaz.ts b/examples/FooBarBaz.ts
@@ -32,15 +32,13 @@ export const _Bar: Prism<FooBarBaz, FooBarBaz> = Prism.fromPredicate(s => s.type
 
 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; } }; }
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
+
+export function getSetoid(): Setoid<FooBarBaz> { return fromEquals((x, y) => { 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; }); }
 
diff --git a/examples/Maybe.ts b/examples/Maybe.ts
@@ -25,13 +25,11 @@ 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; } }; }
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
+
+export function getSetoid<A>(setoidJustValue: Setoid<A>): Setoid<Maybe<A>> { return fromEquals((x, y) => { 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; }); }
 
diff --git a/examples/NotAlignedNames.ts b/examples/NotAlignedNames.ts
@@ -0,0 +1,10 @@
+export type NotAlignedNames = {
+    readonly value: string;
+};
+
+export function ctor(value: string): NotAlignedNames { return { value }; }
+
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
+
+export function getSetoid(setoidValue: Setoid<string>): Setoid<NotAlignedNames> { return fromEquals((x, y) => { return setoidValue.equals(x.value, y.value); }); }
+
diff --git a/examples/Nullary.ts b/examples/Nullary.ts
@@ -0,0 +1,4 @@
+export type Nullary = {};
+
+export const nullary: Nullary = {};
+
diff --git a/examples/Option.ts b/examples/Option.ts
@@ -25,13 +25,11 @@ 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; } }; }
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
+
+export function getSetoid<A>(setoidSomeValue0: Setoid<A>): Setoid<Option<A>> { return fromEquals((x, y) => { 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; }); }
 
diff --git a/examples/State.ts b/examples/State.ts
@@ -1,13 +1,10 @@
 export type State<S, A> = {
-    readonly type: "State";
     readonly value0: (s: S) => [A, S];
 };
 
-export function state<S, A>(value0: (s: S) => [A, S]): State<S, A> { return { type: "State", value0 }; }
+export function state<S, A>(value0: (s: S) => [A, S]): State<S, A> { return { value0 }; }
 
-import { Setoid } from "fp-ts/lib/Setoid";
+import { Setoid, fromEquals } 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); } }; }
+export function getSetoid<S, A>(setoidValue0: Setoid<(s: S) => [A, S]>): Setoid<State<S, A>> { return fromEquals((x, y) => { return setoidValue0.equals(x.value0, y.value0); }); }
 
diff --git a/examples/These.ts b/examples/These.ts
@@ -30,15 +30,13 @@ export function _right<A, B>(): Prism<These<A, B>, These<A, B>> { return Prism.f
 
 export function _both<A, B>(): Prism<These<A, B>, These<A, B>> { return Prism.fromPredicate(s => s.type === "Both"); }
 
-import { Setoid } from "fp-ts/lib/Setoid";
-
-export function getSetoid<A, B>(setoidLeftLeft: Setoid<A>, setoidRightRight: Setoid<B>, setoidBothLeft: Setoid<A>, setoidBothRight: Setoid<B>): Setoid<These<A, B>> { return { equals: (x, y) => { if (x === y) {
-        return true;
-    } if (x.type === "Left" && y.type === "Left") {
-        return setoidLeftLeft.equals(x.left, y.left);
-    } if (x.type === "Right" && y.type === "Right") {
-        return setoidRightRight.equals(x.right, y.right);
-    } if (x.type === "Both" && y.type === "Both") {
-        return setoidBothLeft.equals(x.left, y.left) && setoidBothRight.equals(x.right, y.right);
-    } return false; } }; }
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
+
+export function getSetoid<A, B>(setoidLeftLeft: Setoid<A>, setoidRightRight: Setoid<B>, setoidBothLeft: Setoid<A>, setoidBothRight: Setoid<B>): Setoid<These<A, B>> { return fromEquals((x, y) => { if (x.type === "Left" && y.type === "Left") {
+    return setoidLeftLeft.equals(x.left, y.left);
+} if (x.type === "Right" && y.type === "Right") {
+    return setoidRightRight.equals(x.right, y.right);
+} if (x.type === "Both" && y.type === "Both") {
+    return setoidBothLeft.equals(x.left, y.left) && setoidBothRight.equals(x.right, y.right);
+} return false; }); }
 
diff --git a/examples/Tree.ts b/examples/Tree.ts
@@ -27,13 +27,11 @@ export function _leaf<A>(): Prism<Tree<A>, Tree<A>> { return Prism.fromPredicate
 
 export function _node<A>(): Prism<Tree<A>, Tree<A>> { return Prism.fromPredicate(s => s.type === "Node"); }
 
-import { Setoid } from "fp-ts/lib/Setoid";
-
-export function getSetoid<A>(setoidNodeValue1: Setoid<A>): Setoid<Tree<A>> { const S: Setoid<Tree<A>> = { equals: (x, y) => { if (x === y) {
-        return true;
-    } if (x.type === "Leaf" && y.type === "Leaf") {
-        return true;
-    } if (x.type === "Node" && y.type === "Node") {
-        return S.equals(x.value0, y.value0) && setoidNodeValue1.equals(x.value1, y.value1) && S.equals(x.value2, y.value2);
-    } return false; } }; return S; }
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
+
+export function getSetoid<A>(setoidNodeValue1: Setoid<A>): Setoid<Tree<A>> { const S: Setoid<Tree<A>> = fromEquals((x, y) => { if (x.type === "Leaf" && y.type === "Leaf") {
+    return true;
+} if (x.type === "Node" && y.type === "Node") {
+    return S.equals(x.value0, y.value0) && setoidNodeValue1.equals(x.value1, y.value1) && S.equals(x.value2, y.value2);
+} return false; }); return S; }
 
diff --git a/examples/Tuple2.ts b/examples/Tuple2.ts
@@ -1,13 +1,10 @@
 export type Tuple2<A, B> = {
-    readonly type: "Tuple2";
     readonly value0: [A, B];
 };
 
-export function tuple2<A, B>(value0: [A, B]): Tuple2<A, B> { return { type: "Tuple2", value0 }; }
+export function tuple2<A, B>(value0: [A, B]): Tuple2<A, B> { return { value0 }; }
 
-import { Setoid } from "fp-ts/lib/Setoid";
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
 
-export function getSetoid<A, B>(setoidValue0: Setoid<[A, B]>): Setoid<Tuple2<A, B>> { return { equals: (x, y) => { if (x === y) {
-        return true;
-    } return setoidValue0.equals(x.value0, y.value0); } }; }
+export function getSetoid<A, B>(setoidValue0: Setoid<[A, B]>): Setoid<Tuple2<A, B>> { return fromEquals((x, y) => { return setoidValue0.equals(x.value0, y.value0); }); }
 
diff --git a/examples/User.ts b/examples/User.ts
@@ -1,15 +1,12 @@
 export type User = {
-    readonly type: "User";
     readonly name: string;
     readonly surname: string;
     readonly age: number;
 };
 
-export function user(name: string, surname: string, age: number): User { return { type: "User", name, surname, age }; }
+export function user(name: string, surname: string, age: number): User { return { name, surname, age }; }
 
-import { Setoid } from "fp-ts/lib/Setoid";
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
 
-export function getSetoid(setoidName: Setoid<string>, setoidSurname: Setoid<string>, setoidAge: Setoid<number>): Setoid<User> { return { equals: (x, y) => { if (x === y) {
-        return true;
-    } return setoidName.equals(x.name, y.name) && setoidSurname.equals(x.surname, y.surname) && setoidAge.equals(x.age, y.age); } }; }
+export function getSetoid(setoidName: Setoid<string>, setoidSurname: Setoid<string>, setoidAge: Setoid<number>): Setoid<User> { return fromEquals((x, y) => { return setoidName.equals(x.name, y.name) && setoidSurname.equals(x.surname, y.surname) && setoidAge.equals(x.age, y.age); }); }
 
diff --git a/examples/Writer.ts b/examples/Writer.ts
@@ -1,13 +1,10 @@
 export type Writer<W, A> = {
-    readonly type: "Writer";
     readonly value0: () => [A, W];
 };
 
-export function writer<W, A>(value0: () => [A, W]): Writer<W, A> { return { type: "Writer", value0 }; }
+export function writer<W, A>(value0: () => [A, W]): Writer<W, A> { return { value0 }; }
 
-import { Setoid } from "fp-ts/lib/Setoid";
+import { Setoid, fromEquals } from "fp-ts/lib/Setoid";
 
-export function getSetoid<W, A>(setoidValue0: Setoid<() => [A, W]>): Setoid<Writer<W, A>> { return { equals: (x, y) => { if (x === y) {
-        return true;
-    } return setoidValue0.equals(x.value0, y.value0); } }; }
+export function getSetoid<W, A>(setoidValue0: Setoid<() => [A, W]>): Setoid<Writer<W, A>> { return fromEquals((x, y) => { return setoidValue0.equals(x.value0, y.value0); }); }
 
diff --git a/examples/index.ts b/examples/index.ts
@@ -9,4 +9,6 @@ import './Constrained'
 import './Tuple2'
 import './State'
 import './Writer'
+import './Nullary'
+import './NotAlignedNames'
 
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "fp-ts-codegen",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "TypeScript code generation from a haskell-like syntax for ADT",
   "files": [
     "lib"
@@ -32,7 +32,7 @@
   },
   "homepage": "https://github.com/gcanti/fp-ts-codegen",
   "dependencies": {
-    "fp-ts": "^1.13.0",
+    "fp-ts": "^1.14.1",
     "monocle-ts": "^1.5.3",
     "parser-ts": "^0.5.1",
     "typescript": "^3.2.4"
@@ -92,7 +92,7 @@
         "branches": 100,
         "functions": 100,
         "lines": 100,
-        "statements": 0
+        "statements": 100
       }
     }
   }
diff --git a/playground/index.tsx b/playground/index.tsx
@@ -91,6 +91,7 @@ class App extends React.Component<Props, State> {
                   <option value="data These A B = Left { left :: A } | Right { right :: B } | Both { left :: A, right :: B }">
                     These (record syntax)
                   </option>
+                  <option value="data User = User { name :: string, surname :: string, age :: number }">User</option>
                 </select>
               </td>
               <td className="code">
diff --git a/src/ast.ts b/src/ast.ts
diff --git a/test/examples.ts b/test/examples.ts
diff --git a/test/printer.ts b/test/printer.ts

-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +export type Nullary = {};
++
 +export const nullary: Nullary = {};
++