New Feature: generate prisms, closes #10

gcanti · gcanti · commit 490178716500 · 2019-02-08T17:24:02.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.2.1
+
+- **New Feature**
+  - generate prisms, closes #10 (@gcanti)
+
 # 0.2.0
 
 - **Breaking Change**
diff --git a/README.md b/README.md
@@ -71,6 +71,18 @@ export function foldL<A, R>(fa: Option<A>, onNone: () => R, onSome: (value0: A)
       return onSome(fa.value0)
   }
 }
+
+/** prisms */
+
+import { Prism } from 'monocle-ts'
+
+export function _none<A>(): Prism<Option<A>, Option<A>> {
+  return Prism.fromPredicate(s => s.type === 'None')
+}
+
+export function _some<A>(): Prism<Option<A>, Option<A>> {
+  return Prism.fromPredicate(s => s.type === 'Some')
+}
 ```
 
 # Records
@@ -209,6 +221,16 @@ export const none: Option<never> = None.value
 export function some<A>(value0: A): Option<A> {
   return new Some(value0)
 }
+
+import { Prism } from 'monocle-ts'
+
+export function _none<A>(): Prism<Option<A>, Option<A>> {
+  return Prism.fromPredicate(s => s.type === 'None')
+}
+
+export function _some<A>(): Prism<Option<A>, Option<A>> {
+  return Prism.fromPredicate(s => s.type === 'Some')
+}
 ```
 
 # Options
diff --git a/docs/bundle.js b/docs/bundle.js
diff --git a/examples/Constrained.ts b/examples/Constrained.ts
@@ -19,3 +19,9 @@ export function foldL<A extends string, R>(fa: Constrained<A>, onFetching: () =>
     case "GotData": return onGotData(fa.value0);
 } }
 
+import { Prism } from "monocle-ts";
+
+export function _fetching<A extends string>(): Prism<Constrained<A>, Constrained<A>> { return Prism.fromPredicate(s => s.type === "Fetching"); }
+
+export function _gotData<A extends string>(): Prism<Constrained<A>, Constrained<A>> { return Prism.fromPredicate(s => s.type === "GotData"); }
+
diff --git a/examples/Either.ts b/examples/Either.ts
@@ -15,3 +15,9 @@ export function fold<L, R, R1>(fa: Either<L, R>, onLeft: (value0: L) => R1, onRi
     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 _right<L, R>(): Prism<Either<L, R>, Either<L, R>> { return Prism.fromPredicate(s => s.type === "Right"); }
+
diff --git a/examples/FooBar.ts b/examples/FooBar.ts
@@ -18,3 +18,9 @@ export function foldL<R>(fa: FooBar, onFoo: () => R, onBar: () => R): R { switch
     case "Bar": return onBar();
 } }
 
+import { Prism } from "monocle-ts";
+
+export const _Foo: Prism<FooBar, FooBar> = Prism.fromPredicate(s => s.type === "Foo");
+
+export const _Bar: Prism<FooBar, FooBar> = Prism.fromPredicate(s => s.type === "Bar");
+
diff --git a/examples/Maybe.ts b/examples/Maybe.ts
@@ -19,3 +19,9 @@ export function foldL<A, R>(fa: Maybe<A>, onNothing: () => R, onJust: (value: A)
     case "Just": return onJust(fa.value);
 } }
 
+import { Prism } from "monocle-ts";
+
+export function _nothing<A>(): Prism<Maybe<A>, Maybe<A>> { return Prism.fromPredicate(s => s.type === "Nothing"); }
+
+export function _just<A>(): Prism<Maybe<A>, Maybe<A>> { return Prism.fromPredicate(s => s.type === "Just"); }
+
diff --git a/examples/Option.ts b/examples/Option.ts
@@ -19,3 +19,9 @@ export function foldL<A, R>(fa: Option<A>, onNone: () => R, onSome: (value0: A)
     case "Some": return onSome(fa.value0);
 } }
 
+import { Prism } from "monocle-ts";
+
+export function _none<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.type === "None"); }
+
+export function _some<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.type === "Some"); }
+
diff --git a/examples/Tree.ts b/examples/Tree.ts
@@ -21,3 +21,9 @@ export function foldL<A, R>(fa: Tree<A>, onLeaf: () => R, onNode: (value0: Tree<
     case "Node": return onNode(fa.value0, fa.value1, fa.value2);
 } }
 
+import { Prism } from "monocle-ts";
+
+export function _leaf<A>(): Prism<Tree<A>, Tree<A>> { return Prism.fromPredicate(s => s.type === "Leaf"); }
+
+export function _node<A>(): Prism<Tree<A>, Tree<A>> { return Prism.fromPredicate(s => s.type === "Node"); }
+
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "fp-ts-codegen",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "TypeScript code generation from a haskell-like syntax for ADT",
   "files": [
     "lib"
diff --git a/src/ast.ts b/src/ast.ts
@@ -352,7 +352,7 @@ const getFunctionDeclaration = (
 
 const getParameterDeclaration = (
   name: string,
-  type: ts.TypeNode,
+  type?: ts.TypeNode,
   isReadonly: boolean = false
 ): ts.ParameterDeclaration => {
   return ts.createParameter(
@@ -641,3 +641,67 @@ export const fold = (d: M.Data): AST<Array<ts.FunctionDeclaration>> => {
     return array.sequence(reader)(folds)
   })
 }
+
+const isPolymorphic = (d: M.Data): boolean => {
+  return d.parameterDeclarations.length > 0
+}
+
+export const prisms = (d: M.Data): AST<Array<ts.Node>> => {
+  return ask<Options>().chain(e => {
+    if (!isSumType(d)) {
+      return reader.of(empty)
+    }
+    const dataType = ts.createTypeReferenceNode(
+      d.name,
+      d.parameterDeclarations.map(p => ts.createTypeReferenceNode(p.name, []))
+    )
+    const type = ts.createTypeReferenceNode('Prism', [dataType, dataType])
+    const getPrism = (name: string) => {
+      return ts.createCall(
+        ts.createPropertyAccess(ts.createIdentifier('Prism'), 'fromPredicate'),
+        [],
+        [
+          ts.createArrowFunction(
+            [],
+            [],
+            [getParameterDeclaration('s')],
+            undefined,
+            undefined,
+            ts.createBinary(
+              ts.createPropertyAccess(ts.createIdentifier('s'), e.tagName),
+              ts.SyntaxKind.EqualsEqualsEqualsToken,
+              ts.createStringLiteral(name)
+            )
+          )
+        ]
+      )
+    }
+    const monocleImport = ts.createImportDeclaration(
+      [],
+      [],
+      ts.createImportClause(
+        undefined,
+        ts.createNamedImports([ts.createImportSpecifier(undefined, ts.createIdentifier('Prism'))])
+      ),
+      ts.createStringLiteral('monocle-ts')
+    )
+    const typeParameters: Array<ts.TypeParameterDeclaration> = d.parameterDeclarations.map(p =>
+      ts.createTypeParameterDeclaration(p.name, p.constraint.map(getTypeNode).toUndefined())
+    )
+    if (isPolymorphic(d)) {
+      return reader.of([
+        monocleImport,
+        ...d.constructors.toArray().map<ts.Node>(c => {
+          const body = ts.createBlock([ts.createReturn(getPrism(c.name))])
+          return getFunctionDeclaration(`_${getFirstLetterLowerCase(c.name)}`, typeParameters, [], type, body)
+        })
+      ])
+    }
+    return reader.of([
+      monocleImport,
+      ...d.constructors.toArray().map(c => {
+        return getConstantDeclaration(`_${c.name}`, getPrism(c.name), type)
+      })
+    ])
+  })
+}
diff --git a/src/printer.ts b/src/printer.ts
@@ -25,9 +25,15 @@ export const fold = (d: M.Data): Printer<Array<string>> => {
   return A.fold(d).map(functionDeclarations => functionDeclarations.map(ast))
 }
 
+export const prisms = (d: M.Data): Printer<Array<string>> => {
+  return A.prisms(d).map(nodes => nodes.map(ast))
+}
+
 export const all = (d: M.Data): Printer<Array<string>> => {
   return data(d).chain(data =>
-    constructors(d).chain(constructors => fold(d).map(folds => [data, ...constructors, ...folds]))
+    constructors(d).chain(constructors =>
+      fold(d).chain(folds => prisms(d).map(prisms => [data, ...constructors, ...folds, ...prisms]))
+    )
   )
 }
 
diff --git a/test/printer/fpts-encoding.ts b/test/printer/fpts-encoding.ts
@@ -44,7 +44,13 @@ export class Some<A> {
 
 export const none: Option<never> = None.value;
 
-export function some<A>(value0: A): Option<A> { return new Some(value0); }`
+export function some<A>(value0: A): Option<A> { return new Some(value0); }
+
+import { Prism } from "monocle-ts";
+
+export function _none<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.type === "None"); }
+
+export function _some<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.type === "Some"); }`
     )
   })
 
@@ -83,7 +89,13 @@ export class Right<L, R> {
 
 export function left<L, R>(value0: L): Either<L, R> { return new Left(value0); }
 
-export function right<L, R>(value0: R): Either<L, R> { return new Right(value0); }`
+export function right<L, R>(value0: R): Either<L, R> { return new Right(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 _right<L, R>(): Prism<Either<L, R>, Either<L, R>> { return Prism.fromPredicate(s => s.type === "Right"); }`
     )
   })
 
@@ -144,7 +156,13 @@ export class GotData<A> {
 
 export const fetching: Constrained<string> = Fetching.value;
 
-export function gotData<A extends string>(value0: A): Constrained<A> { return new GotData(value0); }`
+export function gotData<A extends string>(value0: A): Constrained<A> { return new GotData(value0); }
+
+import { Prism } from "monocle-ts";
+
+export function _fetching<A extends string>(): Prism<Constrained<A>, Constrained<A>> { return Prism.fromPredicate(s => s.type === "Fetching"); }
+
+export function _gotData<A extends string>(): Prism<Constrained<A>, Constrained<A>> { return Prism.fromPredicate(s => s.type === "GotData"); }`
     )
   })
 
diff --git a/test/printer/literal-encoding.ts b/test/printer/literal-encoding.ts
@@ -116,6 +116,16 @@ describe('[printer] literal encoding', () => {
     })
   })
 
+  describe('prisms', () => {
+    it('should handle monomorphic data', () => {
+      assertPrinterEqual(P.prisms, E.FooBar, [
+        'import { Prism } from "monocle-ts";',
+        'export const _Foo: Prism<FooBar, FooBar> = Prism.fromPredicate(s => s.type === "Foo");',
+        'export const _Bar: Prism<FooBar, FooBar> = Prism.fromPredicate(s => s.type === "Bar");'
+      ])
+    })
+  })
+
   describe('print', () => {
     it('positional members', () => {
       assert.strictEqual(
@@ -139,7 +149,13 @@ export function fold<A, R>(fa: Option<A>, onNone: R, onSome: (value0: A) => R):
 export function foldL<A, R>(fa: Option<A>, onNone: () => R, onSome: (value0: A) => R): R { switch (fa.type) {
     case "None": return onNone();
     case "Some": return onSome(fa.value0);
-} }`
+} }
+
+import { Prism } from "monocle-ts";
+
+export function _none<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.type === "None"); }
+
+export function _some<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.type === "Some"); }`
       )
     })
 
@@ -165,7 +181,13 @@ export function fold<A, R>(fa: Maybe<A>, onNothing: R, onJust: (value: A) => R):
 export function foldL<A, R>(fa: Maybe<A>, onNothing: () => R, onJust: (value: A) => R): R { switch (fa.type) {
     case "Nothing": return onNothing();
     case "Just": return onJust(fa.value);
-} }`
+} }
+
+import { Prism } from "monocle-ts";
+
+export function _nothing<A>(): Prism<Maybe<A>, Maybe<A>> { return Prism.fromPredicate(s => s.type === "Nothing"); }
+
+export function _just<A>(): Prism<Maybe<A>, Maybe<A>> { return Prism.fromPredicate(s => s.type === "Just"); }`
       )
     })
 
@@ -191,7 +213,13 @@ export function fold<A extends string, R>(fa: Constrained<A>, onFetching: R, onG
 export function foldL<A extends string, R>(fa: Constrained<A>, onFetching: () => R, onGotData: (value0: A) => R): R { switch (fa.type) {
     case "Fetching": return onFetching();
     case "GotData": return onGotData(fa.value0);
-} }`
+} }
+
+import { Prism } from "monocle-ts";
+
+export function _fetching<A extends string>(): Prism<Constrained<A>, Constrained<A>> { return Prism.fromPredicate(s => s.type === "Fetching"); }
+
+export function _gotData<A extends string>(): Prism<Constrained<A>, Constrained<A>> { return Prism.fromPredicate(s => s.type === "GotData"); }`
       )
     })
 
diff --git a/test/printer/options.ts b/test/printer/options.ts
@@ -28,7 +28,13 @@ export function fold<A, R>(fa: Option<A>, onNone: R, onSome: (value0: A) => R):
 export function foldL<A, R>(fa: Option<A>, onNone: () => R, onSome: (value0: A) => R): R { switch (fa.tag) {
     case "None": return onNone();
     case "Some": return onSome(fa.value0);
-} }`
+} }
+
+import { Prism } from "monocle-ts";
+
+export function _none<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.tag === "None"); }
+
+export function _some<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.tag === "Some"); }`
     )
   })
 

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "fp-ts-codegen",`
`3`		`- "version": "0.2.0",`
	`3`	`+ "version": "0.2.1",`
`4`	`4`	`"description": "TypeScript code generation from a haskell-like syntax for ADT",`
`5`	`5`	`"files": [`
`6`	`6`	`"lib"`