use parameter declarations when printing phantom fields, fix #16

Author: gcanti

.travis.yml

@@ -1,6 +1,3 @@
 language: node_js
 node_js:
-  - "10"
-before_script:
-  - export DISPLAY=:99.0
-  - sh -e /etc/init.d/xvfb start
+  - '10'

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.1
+
+- **Bug Fix**
+  - use parameter declarations when printing phantom fields, fix #16 (@gcanti)
+
 # 0.3.0
 
 - **Breaking Change**

docs/bundle.js

@@ -1,29 +1,29 @@
-export type Either<L, R> = {
+export type Either<E, R> = {
     readonly type: "Left";
-    readonly value0: L;
+    readonly value0: E;
 } | {
     readonly type: "Right";
     readonly value0: R;
 };
 
-export function left<L, R>(value0: L): Either<L, R> { return { type: "Left", value0 }; }
+export function left<E, R>(value0: E): Either<E, R> { return { type: "Left", value0 }; }
 
-export function right<L, R>(value0: R): Either<L, R> { return { type: "Right", value0 }; }
+export function right<E, R>(value0: R): Either<E, R> { return { type: "Right", value0 }; }
 
-export function fold<L, R, R1>(fa: Either<L, R>, onLeft: (value0: L) => R1, onRight: (value0: R) => R1): R1 { switch (fa.type) {
+export function fold<E, R, R1>(fa: Either<E, R>, onLeft: (value0: E) => R1, onRight: (value0: R) => R1): R1 { switch (fa.type) {
     case "Left": return onLeft(fa.value0);
     case "Right": return onRight(fa.value0);
 } }
 
 import { Prism } from "monocle-ts";
 
-export function _left<L, R>(): Prism<Either<L, R>, Either<L, R>> { return Prism.fromPredicate(s => s.type === "Left"); }
+export function _left<E, R>(): Prism<Either<E, R>, Either<E, R>> { return Prism.fromPredicate(s => s.type === "Left"); }
 
-export function _right<L, R>(): Prism<Either<L, R>, Either<L, R>> { return Prism.fromPredicate(s => s.type === "Right"); }
+export function _right<E, R>(): Prism<Either<E, R>, Either<E, R>> { return Prism.fromPredicate(s => s.type === "Right"); }
 
 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") {
+export function getSetoid<E, R>(setoidLeftValue0: Setoid<E>, setoidRightValue0: Setoid<R>): Setoid<Either<E, 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);

examples/Either.ts

@@ -1,6 +1,6 @@
 {
   "name": "fp-ts-codegen",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "TypeScript code generation from a haskell-like syntax for ADT",
   "files": [
     "lib"
@@ -33,7 +33,7 @@
   },
   "homepage": "https://github.com/gcanti/fp-ts-codegen",
   "dependencies": {
-    "fp-ts": "^1.15.0",
+    "fp-ts": "^1.19.1",
     "monocle-ts": "^1.5.3",
     "parser-ts": "^0.5.1",
     "typescript": "^3.2.4"

package-lock.json

@@ -284,9 +284,15 @@ const getDataFptsEncoding = (d: M.Data): AST<Array<ts.Node>> => {
       const getPolymorphicFields = (): Array<ts.PropertyDeclaration> => {
         const URI = getPropertyDeclaration('_URI', ts.createTypeReferenceNode('URI', A.empty), undefined, true)
         const len = getDataParametersLength(d)
-        const fptsParameters = URI2HKTParametersNames.slice(0, len).map(name =>
-          getPropertyDeclaration(`_${name}`, ts.createTypeReferenceNode(name, A.empty), undefined, true)
-        )
+        const parameterDeclarations = d.parameterDeclarations.slice().reverse()
+        const fptsParameters = URI2HKTParametersNames.slice(0, len).map((name, i) => {
+          return getPropertyDeclaration(
+            `_${name}`,
+            ts.createTypeReferenceNode(parameterDeclarations[i].name, A.empty),
+            undefined,
+            true
+          )
+        })
         return [...fptsParameters, URI]
       }
 
@@ -455,7 +461,7 @@ const getLiteralConstructor = (c: M.Constructor, d: M.Data): AST<ts.Node> => {
 
 const getConstructorsLiteralEncoding = (d: M.Data): AST<Array<ts.Node>> => {
   const constructors = d.constructors.map(c =>
-    A.foldL(c.members, () => getLiteralNullaryConstructor(c, d), () => getLiteralConstructor(c, d))
+    A.foldLeft(() => getLiteralNullaryConstructor(c, d), () => getLiteralConstructor(c, d))(c.members)
   )
   return A.array.sequence(reader)(constructors)
 }
@@ -494,7 +500,7 @@ const getFptsConstructor = (c: M.Constructor, d: M.Data): AST<ts.Node> => {
 
 const getConstructorsFptsEncoding = (d: M.Data): AST<Array<ts.Node>> => {
   const constructors = d.constructors.map(c =>
-    A.foldL(c.members, () => getFptsNullaryConstructor(c, d), () => getFptsConstructor(c, d))
+    A.foldLeft(() => getFptsNullaryConstructor(c, d), () => getFptsConstructor(c, d))(c.members)
   )
   return A.array.sequence(reader)(constructors)
 }
@@ -745,8 +751,7 @@ export const setoid = (d: M.Data): AST<Array<ts.Node>> => {
       })
   })
   const getReturnValue = (c: M.Constructor): ts.Expression => {
-    return A.foldL(
-      c.members,
+    return A.foldLeft(
       () => ts.createTrue(),
       () => {
         const callExpressions = c.members.map((m, position) => {
@@ -759,7 +764,7 @@ export const setoid = (d: M.Data): AST<Array<ts.Node>> => {
         })
         return S.fold(semigroupBinaryExpression)(callExpressions[0])(callExpressions.slice(1))
       }
-    )
+    )(c.members)
   }
   return ask<Options>().chain(e => {
     const setoidImport = getImportDeclaration(['Setoid', 'fromEquals'], 'fp-ts/lib/Setoid')

package.json

@@ -1,4 +1,4 @@
-import { NonEmptyArray, make } from 'fp-ts/lib/NonEmptyArray2v'
+import { NonEmptyArray, cons } from 'fp-ts/lib/NonEmptyArray2v'
 import { Option, none } from 'fp-ts/lib/Option'
 
 export type Identifier = string
@@ -89,7 +89,7 @@ export const data = (
 ): Data => ({
   name,
   parameterDeclarations,
-  constructors: make(head, tail)
+  constructors: cons(head, tail)
 })
 
 export const isNullary = (c: Constructor): boolean => {

src/ast.ts

@@ -3,7 +3,7 @@ import * as Ast from './ast'
 import * as M from './model'
 import { Reader, reader } from 'fp-ts/lib/Reader'
 import * as Mon from 'fp-ts/lib/Monoid'
-import { array } from 'fp-ts/lib/Array'
+import * as A from 'fp-ts/lib/Array'
 
 export interface Printer<A> extends Reader<Ast.Options, A> {}
 
@@ -42,10 +42,10 @@ export const getMonoid = <A>(M: Mon.Monoid<A>): Mon.Monoid<Printer<A>> => {
   }
 }
 
-const monoidPrinter: Mon.Monoid<Printer<Array<string>>> = getMonoid(Mon.getArrayMonoid<string>())
+const monoidPrinter: Mon.Monoid<Printer<Array<string>>> = getMonoid(A.getMonoid<string>())
 
 export const all = (d: M.Data): Printer<Array<string>> => {
-  return Mon.fold(monoidPrinter)([data(d).map(array.of), constructors(d), folds(d), prisms(d), setoid(d)])
+  return Mon.fold(monoidPrinter)([data(d).map(A.array.of), constructors(d), folds(d), prisms(d), setoid(d)])
 }
 
 export const print = (d: M.Data, options: Ast.Options): string => {

src/model.ts

@@ -14,8 +14,8 @@ export const Maybe = M.data('Maybe', [M.parameterDeclaration('A')], M.constructo
 // data Either L R = Left L | Right R
 export const Either = M.data(
   'Either',
-  [M.parameterDeclaration('L'), M.parameterDeclaration('R')],
-  M.constructor('Left', [M.member(M.ref('L'))]),
+  [M.parameterDeclaration('E'), M.parameterDeclaration('R')],
+  M.constructor('Left', [M.member(M.ref('E'))]),
   [M.constructor('Right', [M.member(M.ref('R'))])]
 )