├── .gitignore
├── .travis.yml
├── .vscode
    └── settings.json
├── CHANGELOG.md
├── LICENSE
├── README.md
├── docs
    ├── _config.yml
    ├── bundle.js
    ├── index.html
    ├── index.md
    ├── modules
    │   ├── ast.ts.md
    │   ├── haskell.ts.md
    │   ├── index.md
    │   ├── index.ts.md
    │   ├── model.ts.md
    │   └── printer.ts.md
    ├── prism.css
    └── style.css
├── dtslint
    ├── index.d.ts
    ├── index.ts
    ├── tsconfig.json
    └── tslint.json
├── examples
    ├── Constrained.ts
    ├── Either.ts
    ├── FooBarBaz.ts
    ├── Maybe.ts
    ├── NotAlignedNames.ts
    ├── Nullary.ts
    ├── Option.ts
    ├── State.ts
    ├── These.ts
    ├── Tree.ts
    ├── Tuple2.ts
    ├── User.ts
    ├── Writer.ts
    └── index.ts
├── generate-examples.ts
├── jest.config.js
├── package-lock.json
├── package.json
├── playground
    ├── index.tsx
    ├── tsconfig.json
    └── webpack.config.js
├── src
    ├── ast.ts
    ├── haskell.ts
    ├── index.ts
    ├── model.ts
    └── printer.ts
├── test
    ├── examples.ts
    ├── haskell.ts
    ├── helpers.ts
    ├── index.ts
    ├── model.ts
    ├── printer.ts
    └── tsconfig.json
├── tsconfig.json
└── tslint.json


/.gitignore:
--------------------------------------------------------------------------------
1 | *.log
2 | node_modules
3 | lib
4 | dev
5 | coverage
6 | .cache
7 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - '10'
4 | 


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | {
2 |   "typescript.tsdk": "./node_modules/typescript/lib",
3 |   "prettier.printWidth": 120,
4 |   "prettier.semi": false,
5 |   "prettier.singleQuote": true,
6 |   "tslint.enable": true
7 | }
8 | 


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
 1 | # Changelog
 2 | 
 3 | > **Tags:**
 4 | >
 5 | > - [New Feature]
 6 | > - [Bug Fix]
 7 | > - [Breaking Change]
 8 | > - [Documentation]
 9 | > - [Internal]
10 | > - [Polish]
11 | > - [Experimental]
12 | 
13 | **Note**: Gaps between patch versions are faulty/broken releases.
14 | **Note**: A feature tagged as Experimental is in a high state of flux, you're at risk of it changing without notice.
15 | 
16 | # 0.4.0
17 | 
18 | - **Breaking Change**
19 |   - upgrade to `fp-ts@2.x`, `monocle-ts@2.x`, `parser-ts@0.6.x` (@gcanti)
20 |   - options
21 |     - remove encoding (@gcanti)
22 |     - remove matcheeName (@gcanti)
23 |   - make generated `fold` always lazy and data-last (@gcanti)
24 | 
25 | # 0.3.1
26 | 
27 | - **Bug Fix**
28 |   - use parameter declarations when printing phantom fields, fix #16 (@gcanti)
29 | 
30 | # 0.3.0
31 | 
32 | - **Breaking Change**
33 |   - upgrade to `fp-ts@1.14.x` (@gcanti)
34 | 
35 | # 0.2.2
36 | 
37 | - **New Feature**
38 |   - generate setoid instance, closes #12 (@gcanti)
39 | 
40 | # 0.2.1
41 | 
42 | - **New Feature**
43 |   - generate prisms, closes #10 (@gcanti)
44 | 
45 | # 0.2.0
46 | 
47 | - **Breaking Change**
48 |   - model refactoring (@gcanti)
49 | - **New Feature**
50 |   - add support for unit type (@gcanti)
51 | 
52 | # 0.1.0
53 | 
54 | - **Breaking Change**
55 |   - rename `parser.ts` to `haskell.ts` (@gcanti)
56 | - **New Feature**
57 |   - add support for `fp-ts` encoding (@gcanti)
58 | 
59 | # 0.0.2
60 | 
61 | - **Breaking Change**
62 |   - `model.ts` is changed in order to support tuple types and function types (@gcanti)
63 | - **New Feature**
64 |   - add support for tuple types (@gcanti)
65 |   - add support for function types (@gcanti)
66 | 
67 | # 0.0.1
68 | 
69 | Initial release
70 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Giulio Canti
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | TypeScript code generation from a haskell-like syntax for ADT (algebraic data types)
  2 | 
  3 | # Playground
  4 | 
  5 | [A playground with a few examples](https://gcanti.github.io/fp-ts-codegen/)
  6 | 
  7 | # Installation
  8 | 
  9 | To install the stable version:
 10 | 
 11 | ```sh
 12 | npm install fp-ts-codegen
 13 | ```
 14 | 
 15 | # Usage
 16 | 
 17 | Signature
 18 | 
 19 | ```ts
 20 | function run(input: string, options: Options = defaultOptions): Either<string, string>
 21 | ```
 22 | 
 23 | Example
 24 | 
 25 | ```ts
 26 | import { run } from 'fp-ts-codegen'
 27 | 
 28 | console.log(run('data Option A = None | Some A'))
 29 | ```
 30 | 
 31 | Output
 32 | 
 33 | ```ts
 34 | /** type definition */
 35 | 
 36 | export type Option<A> =
 37 |   | {
 38 |       readonly type: 'None'
 39 |     }
 40 |   | {
 41 |       readonly type: 'Some'
 42 |       readonly value0: A
 43 |     }
 44 | 
 45 | /** constructors */
 46 | 
 47 | export const none: Option<never> = { type: 'None' }
 48 | 
 49 | export function some<A>(value0: A): Option<A> {
 50 |   return { type: 'Some', value0 }
 51 | }
 52 | 
 53 | /** pattern matching */
 54 | 
 55 | export function fold<A, R>(onNone: () => R, onSome: (value0: A) => R): (fa: Option<A>) => R {
 56 |   return fa => {
 57 |     switch (fa.type) {
 58 |       case 'None':
 59 |         return onNone()
 60 |       case 'Some':
 61 |         return onSome(fa.value0)
 62 |     }
 63 |   }
 64 | }
 65 | 
 66 | /** prisms */
 67 | 
 68 | import { Prism } from 'monocle-ts'
 69 | 
 70 | export function _none<A>(): Prism<Option<A>, Option<A>> {
 71 |   return Prism.fromPredicate(s => s.type === 'None')
 72 | }
 73 | 
 74 | export function _some<A>(): Prism<Option<A>, Option<A>> {
 75 |   return Prism.fromPredicate(s => s.type === 'Some')
 76 | }
 77 | 
 78 | /** Eq instance */
 79 | 
 80 | import { Eq } from 'fp-ts/lib/Eq'
 81 | 
 82 | export function getEq<A>(eqSomeValue0: Eq<A>): Eq<Option<A>> {
 83 |   return {
 84 |     equals: (x, y) => {
 85 |       if (x === y) {
 86 |         return true
 87 |       }
 88 |       if (x.type === 'None' && y.type === 'None') {
 89 |         return true
 90 |       }
 91 |       if (x.type === 'Some' && y.type === 'Some') {
 92 |         return eqSomeValue0.equals(x.value0, y.value0)
 93 |       }
 94 |       return false
 95 |     }
 96 |   }
 97 | }
 98 | ```
 99 | 
100 | # Records
101 | 
102 | Syntax: `{ name :: type }`
103 | 
104 | Example
105 | 
106 | Source
107 | 
108 | ```haskell
109 | --     record ---v
110 | data User = User { name :: string, surname :: string }
111 | ```
112 | 
113 | Output
114 | 
115 | ```ts
116 | export type User = {
117 |   readonly type: 'User'
118 |   readonly name: string
119 |   readonly surname: string
120 | }
121 | 
122 | export function user(name: string, surname: string): User {
123 |   return { type: 'User', name, surname }
124 | }
125 | ```
126 | 
127 | # Tuples
128 | 
129 | Syntax: `(type1, type2, ...types)`
130 | 
131 | Example
132 | 
133 | Source
134 | 
135 | ```haskell
136 | --              tuple ---v
137 | data Tuple2 A B = Tuple2 (A, B)
138 | ```
139 | 
140 | Output
141 | 
142 | ```ts
143 | export type Tuple2<A, B> = {
144 |   readonly type: 'Tuple2'
145 |   readonly value0: [A, B]
146 | }
147 | 
148 | export function tuple2<A, B>(value0: [A, B]): Tuple2<A, B> {
149 |   return { type: 'Tuple2', value0 }
150 | }
151 | ```
152 | 
153 | # Constraints
154 | 
155 | Syntax: `(<name> :: <constraint>)`
156 | 
157 | Example
158 | 
159 | Source
160 | 
161 | ```haskell
162 | --    constraint ---v
163 | data Constrained (A :: string) = Fetching | GotData A
164 | ```
165 | 
166 | Output
167 | 
168 | ```ts
169 | export type Constrained<A extends string> =
170 |   | {
171 |       readonly type: 'Fetching'
172 |     }
173 |   | {
174 |       readonly type: 'GotData'
175 |       readonly value0: A
176 |     }
177 | ```
178 | 
179 | # Options
180 | 
181 | ```ts
182 | // fp-ts-codegen/lib/ast module
183 | 
184 | export interface Options {
185 |   /** the name of the field used as tag */
186 |   tagName: string
187 |   /** the name prefix used for pattern matching functions */
188 |   foldName: string
189 |   /**
190 |    * the pattern matching handlers can be expressed as positional arguments
191 |    * or a single object literal `tag -> handler`
192 |    */
193 |   handlersStyle: { type: 'positional' } | { type: 'record'; handlersName: string }
194 | }
195 | 
196 | export const defaultOptions: Options = {
197 |   tagName: '_tag',
198 |   foldName: 'fold',
199 |   handlersStyle: { type: 'positional' }
200 | }
201 | ```
202 | 
203 | ## Options management
204 | 
205 | Example
206 | 
207 | ```ts
208 | import { lenses, defaultOptions } from 'fp-ts-codegen/lib/ast'
209 | 
210 | lenses.tagName.set('tag')(defaultOptions)
211 | /*
212 | {
213 |   tagName: 'tag',
214 |   foldName: 'fold',
215 |   ...
216 | }
217 | */
218 | ```
219 | 
220 | # Modules
221 | 
222 | - `ast` module: internal model -> TypeScript AST
223 | - `model` module: internal model
224 | - `printer` module: internal model -> TypeScript code
225 | - `haskell` module: haskell-like syntax -> internal model
226 | - `index` module: haskell-like syntax -> TypeScript code
227 | 
228 | # Roadmap
229 | 
230 | - derive type class instances? (`Functor`, `Foldable`, etc...)
231 | - ???
232 | 


--------------------------------------------------------------------------------
/docs/_config.yml:
--------------------------------------------------------------------------------
 1 | remote_theme: pmarsceill/just-the-docs
 2 | 
 3 | # Enable or disable the site search
 4 | search_enabled: true
 5 | 
 6 | # Aux links for the upper right navigation
 7 | aux_links:
 8 |   'fp-ts-codegen on GitHub':
 9 |     - 'https://github.com/gcanti/fp-ts-codegen'
10 | 


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 |   <head>
 4 |     <meta charset="UTF-8" />
 5 |     <title>fp-ts-codegen playground</title>
 6 |     <link rel="stylesheet" href="./prism.css" />
 7 |     <link rel="stylesheet" href="./style.css" />
 8 |   </head>
 9 |   <body>
10 |     <div id="main" class="main"></div>
11 |     <script src="./bundle.js"></script>
12 |   </body>
13 | </html>
14 | 


--------------------------------------------------------------------------------
/docs/index.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Home
3 | nav_order: 1
4 | ---
5 | 


--------------------------------------------------------------------------------
/docs/modules/ast.ts.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: ast.ts
  3 | nav_order: 1
  4 | parent: Modules
  5 | ---
  6 | 
  7 | ---
  8 | 
  9 | <h2 class="text-delta">Table of contents</h2>
 10 | 
 11 | - [AST (interface)](#ast-interface)
 12 | - [Options (interface)](#options-interface)
 13 | - [defaultOptions (constant)](#defaultoptions-constant)
 14 | - [lenses (constant)](#lenses-constant)
 15 | - [constructors (function)](#constructors-function)
 16 | - [data (function)](#data-function)
 17 | - [eq (function)](#eq-function)
 18 | - [fold (function)](#fold-function)
 19 | - [prisms (function)](#prisms-function)
 20 | 
 21 | ---
 22 | 
 23 | # AST (interface)
 24 | 
 25 | **Signature**
 26 | 
 27 | ```ts
 28 | export interface AST<A> extends R.Reader<Options, A> {}
 29 | ```
 30 | 
 31 | Added in v0.4.0
 32 | 
 33 | # Options (interface)
 34 | 
 35 | **Signature**
 36 | 
 37 | ```ts
 38 | export interface Options {
 39 |   /** the name of the field used as tag */
 40 |   tagName: string
 41 |   /** the name prefix used for pattern matching functions */
 42 |   foldName: string
 43 |   /**
 44 |    * the pattern matching handlers can be expressed as positional arguments
 45 |    * or a single object literal `tag -> handler`
 46 |    */
 47 |   handlersStyle: { type: 'positional' } | { type: 'record'; handlersName: string }
 48 | }
 49 | ```
 50 | 
 51 | Added in v0.4.0
 52 | 
 53 | # defaultOptions (constant)
 54 | 
 55 | **Signature**
 56 | 
 57 | ```ts
 58 | export const defaultOptions: Options = ...
 59 | ```
 60 | 
 61 | Added in v0.4.0
 62 | 
 63 | # lenses (constant)
 64 | 
 65 | **Signature**
 66 | 
 67 | ```ts
 68 | export const lenses: { [K in keyof Options]: Lens<Options, Options[K]> } = ...
 69 | ```
 70 | 
 71 | Added in v0.4.0
 72 | 
 73 | # constructors (function)
 74 | 
 75 | **Signature**
 76 | 
 77 | ```ts
 78 | export function constructors(d: M.Data): AST<Array<ts.Node>> { ... }
 79 | ```
 80 | 
 81 | Added in v0.4.0
 82 | 
 83 | # data (function)
 84 | 
 85 | **Signature**
 86 | 
 87 | ```ts
 88 | export function data(d: M.Data): AST<Array<ts.Node>> { ... }
 89 | ```
 90 | 
 91 | Added in v0.4.0
 92 | 
 93 | # eq (function)
 94 | 
 95 | **Signature**
 96 | 
 97 | ```ts
 98 | export function eq(d: M.Data): AST<Array<ts.Node>> { ... }
 99 | ```
100 | 
101 | Added in v0.4.0
102 | 
103 | # fold (function)
104 | 
105 | **Signature**
106 | 
107 | ```ts
108 | export function fold(d: M.Data): AST<O.Option<ts.FunctionDeclaration>> { ... }
109 | ```
110 | 
111 | Added in v0.4.0
112 | 
113 | # prisms (function)
114 | 
115 | **Signature**
116 | 
117 | ```ts
118 | export function prisms(d: M.Data): AST<Array<ts.Node>> { ... }
119 | ```
120 | 
121 | Added in v0.4.0
122 | 


--------------------------------------------------------------------------------
/docs/modules/haskell.ts.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: haskell.ts
  3 | nav_order: 2
  4 | parent: Modules
  5 | ---
  6 | 
  7 | ---
  8 | 
  9 | <h2 class="text-delta">Table of contents</h2>
 10 | 
 11 | - [constructor (constant)](#constructor-constant)
 12 | - [data (constant)](#data-constant)
 13 | - [fun (constant)](#fun-constant)
 14 | - [identifier (constant)](#identifier-constant)
 15 | - [parameterDeclaration (constant)](#parameterdeclaration-constant)
 16 | - [ref (constant)](#ref-constant)
 17 | - [tuple (constant)](#tuple-constant)
 18 | - [type (constant)](#type-constant)
 19 | - [types (constant)](#types-constant)
 20 | - [parse (function)](#parse-function)
 21 | 
 22 | ---
 23 | 
 24 | # constructor (constant)
 25 | 
 26 | **Signature**
 27 | 
 28 | ```ts
 29 | export const constructor: P.Parser<C.Char, M.Constructor> = ...
 30 | ```
 31 | 
 32 | Added in v0.4.0
 33 | 
 34 | # data (constant)
 35 | 
 36 | **Signature**
 37 | 
 38 | ```ts
 39 | export const data: P.Parser<C.Char, M.Data> = ...
 40 | ```
 41 | 
 42 | Added in v0.4.0
 43 | 
 44 | # fun (constant)
 45 | 
 46 | **Signature**
 47 | 
 48 | ```ts
 49 | export const fun: P.Parser<C.Char, M.Type> = ...
 50 | ```
 51 | 
 52 | Added in v0.4.0
 53 | 
 54 | # identifier (constant)
 55 | 
 56 | **Signature**
 57 | 
 58 | ```ts
 59 | export const identifier: P.Parser<C.Char, string> = ...
 60 | ```
 61 | 
 62 | Added in v0.4.0
 63 | 
 64 | # parameterDeclaration (constant)
 65 | 
 66 | **Signature**
 67 | 
 68 | ```ts
 69 | export const parameterDeclaration = ...
 70 | ```
 71 | 
 72 | # ref (constant)
 73 | 
 74 | **Signature**
 75 | 
 76 | ```ts
 77 | export const ref: P.Parser<C.Char, M.Type> = ...
 78 | ```
 79 | 
 80 | Added in v0.4.0
 81 | 
 82 | # tuple (constant)
 83 | 
 84 | **Signature**
 85 | 
 86 | ```ts
 87 | export const tuple: P.Parser<C.Char, M.Type> = ...
 88 | ```
 89 | 
 90 | Added in v0.4.0
 91 | 
 92 | # type (constant)
 93 | 
 94 | **Signature**
 95 | 
 96 | ```ts
 97 | export const type: P.Parser<C.Char, M.Type> = ...
 98 | ```
 99 | 
100 | Added in v0.4.0
101 | 
102 | # types (constant)
103 | 
104 | **Signature**
105 | 
106 | ```ts
107 | export const types: P.Parser<C.Char, Array<M.Type>> = ...
108 | ```
109 | 
110 | Added in v0.4.0
111 | 
112 | # parse (function)
113 | 
114 | **Signature**
115 | 
116 | ```ts
117 | export function parse(s: string): Either<string, M.Data> { ... }
118 | ```
119 | 
120 | Added in v0.4.0
121 | 


--------------------------------------------------------------------------------
/docs/modules/index.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Modules
3 | has_children: true
4 | permalink: /docs/modules
5 | nav_order: 2
6 | ---
7 | 


--------------------------------------------------------------------------------
/docs/modules/index.ts.md:
--------------------------------------------------------------------------------
 1 | ---
 2 | title: index.ts
 3 | nav_order: 3
 4 | parent: Modules
 5 | ---
 6 | 
 7 | ---
 8 | 
 9 | <h2 class="text-delta">Table of contents</h2>
10 | 
11 | - [run (function)](#run-function)
12 | 
13 | ---
14 | 
15 | # run (function)
16 | 
17 | **Signature**
18 | 
19 | ```ts
20 | export function run(input: string, options: Options = defaultOptions): E.Either<string, string> { ... }
21 | ```
22 | 
23 | Added in v0.4.0
24 | 


--------------------------------------------------------------------------------
/docs/modules/model.ts.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: model.ts
  3 | nav_order: 4
  4 | parent: Modules
  5 | ---
  6 | 
  7 | ---
  8 | 
  9 | <h2 class="text-delta">Table of contents</h2>
 10 | 
 11 | - [Constructor (interface)](#constructor-interface)
 12 | - [Data (interface)](#data-interface)
 13 | - [Fun (interface)](#fun-interface)
 14 | - [Member (interface)](#member-interface)
 15 | - [ParameterDeclaration (interface)](#parameterdeclaration-interface)
 16 | - [Ref (interface)](#ref-interface)
 17 | - [Tuple (interface)](#tuple-interface)
 18 | - [Unit (interface)](#unit-interface)
 19 | - [Identifier (type alias)](#identifier-type-alias)
 20 | - [Type (type alias)](#type-type-alias)
 21 | - [unit (constant)](#unit-constant)
 22 | - [constructor (function)](#constructor-function)
 23 | - [data (function)](#data-function)
 24 | - [fun (function)](#fun-function)
 25 | - [isEnum (function)](#isenum-function)
 26 | - [isNullary (function)](#isnullary-function)
 27 | - [isPolymorphic (function)](#ispolymorphic-function)
 28 | - [isRecursive (function)](#isrecursive-function)
 29 | - [isRecursiveMember (function)](#isrecursivemember-function)
 30 | - [isSum (function)](#issum-function)
 31 | - [member (function)](#member-function)
 32 | - [parameterDeclaration (function)](#parameterdeclaration-function)
 33 | - [ref (function)](#ref-function)
 34 | - [tuple (function)](#tuple-function)
 35 | 
 36 | ---
 37 | 
 38 | # Constructor (interface)
 39 | 
 40 | **Signature**
 41 | 
 42 | ```ts
 43 | export interface Constructor {
 44 |   readonly name: Identifier
 45 |   readonly members: Array<Member>
 46 | }
 47 | ```
 48 | 
 49 | Added in v0.4.0
 50 | 
 51 | # Data (interface)
 52 | 
 53 | **Signature**
 54 | 
 55 | ```ts
 56 | export interface Data {
 57 |   readonly name: Identifier
 58 |   readonly parameterDeclarations: Array<ParameterDeclaration>
 59 |   readonly constructors: NonEmptyArray<Constructor>
 60 | }
 61 | ```
 62 | 
 63 | Added in v0.4.0
 64 | 
 65 | # Fun (interface)
 66 | 
 67 | **Signature**
 68 | 
 69 | ```ts
 70 | export interface Fun {
 71 |   readonly kind: 'Fun'
 72 |   readonly domain: Type
 73 |   readonly codomain: Type
 74 | }
 75 | ```
 76 | 
 77 | Added in v0.4.0
 78 | 
 79 | # Member (interface)
 80 | 
 81 | **Signature**
 82 | 
 83 | ```ts
 84 | export interface Member {
 85 |   readonly type: Type
 86 |   readonly name: Option<Identifier>
 87 | }
 88 | ```
 89 | 
 90 | Added in v0.4.0
 91 | 
 92 | # ParameterDeclaration (interface)
 93 | 
 94 | **Signature**
 95 | 
 96 | ```ts
 97 | export interface ParameterDeclaration {
 98 |   readonly name: Identifier
 99 |   readonly constraint: Option<Type>
100 | }
101 | ```
102 | 
103 | Added in v0.4.0
104 | 
105 | # Ref (interface)
106 | 
107 | **Signature**
108 | 
109 | ```ts
110 | export interface Ref {
111 |   readonly kind: 'Ref'
112 |   readonly name: Identifier
113 |   readonly parameters: Array<Type>
114 | }
115 | ```
116 | 
117 | Added in v0.4.0
118 | 
119 | # Tuple (interface)
120 | 
121 | **Signature**
122 | 
123 | ```ts
124 | export interface Tuple {
125 |   readonly kind: 'Tuple'
126 |   readonly types: Array<Type>
127 | }
128 | ```
129 | 
130 | Added in v0.4.0
131 | 
132 | # Unit (interface)
133 | 
134 | **Signature**
135 | 
136 | ```ts
137 | export interface Unit {
138 |   readonly kind: 'Unit'
139 | }
140 | ```
141 | 
142 | Added in v0.4.0
143 | 
144 | # Identifier (type alias)
145 | 
146 | **Signature**
147 | 
148 | ```ts
149 | export type Identifier = string
150 | ```
151 | 
152 | Added in v0.4.0
153 | 
154 | # Type (type alias)
155 | 
156 | **Signature**
157 | 
158 | ```ts
159 | export type Type = Ref | Tuple | Fun | Unit
160 | ```
161 | 
162 | Added in v0.4.0
163 | 
164 | # unit (constant)
165 | 
166 | **Signature**
167 | 
168 | ```ts
169 | export const unit: Type = ...
170 | ```
171 | 
172 | Added in v0.4.0
173 | 
174 | # constructor (function)
175 | 
176 | **Signature**
177 | 
178 | ```ts
179 | export function constructor(name: Identifier, members: Array<Member> = []): Constructor { ... }
180 | ```
181 | 
182 | Added in v0.4.0
183 | 
184 | # data (function)
185 | 
186 | **Signature**
187 | 
188 | ```ts
189 | export function data(
190 |   name: Identifier,
191 |   parameterDeclarations: Array<ParameterDeclaration>,
192 |   constructors: NonEmptyArray<Constructor>
193 | ): Data { ... }
194 | ```
195 | 
196 | Added in v0.4.0
197 | 
198 | # fun (function)
199 | 
200 | **Signature**
201 | 
202 | ```ts
203 | export function fun(domain: Type, codomain: Type): Type { ... }
204 | ```
205 | 
206 | Added in v0.4.0
207 | 
208 | # isEnum (function)
209 | 
210 | **Signature**
211 | 
212 | ```ts
213 | export function isEnum(d: Data): boolean { ... }
214 | ```
215 | 
216 | Added in v0.4.0
217 | 
218 | # isNullary (function)
219 | 
220 | **Signature**
221 | 
222 | ```ts
223 | export function isNullary(c: Constructor): boolean { ... }
224 | ```
225 | 
226 | Added in v0.4.0
227 | 
228 | # isPolymorphic (function)
229 | 
230 | **Signature**
231 | 
232 | ```ts
233 | export function isPolymorphic(d: Data): boolean { ... }
234 | ```
235 | 
236 | Added in v0.4.0
237 | 
238 | # isRecursive (function)
239 | 
240 | **Signature**
241 | 
242 | ```ts
243 | export function isRecursive(d: Data): boolean { ... }
244 | ```
245 | 
246 | Added in v0.4.0
247 | 
248 | # isRecursiveMember (function)
249 | 
250 | **Signature**
251 | 
252 | ```ts
253 | export function isRecursiveMember(m: Member, d: Data): boolean { ... }
254 | ```
255 | 
256 | Added in v0.4.0
257 | 
258 | # isSum (function)
259 | 
260 | **Signature**
261 | 
262 | ```ts
263 | export function isSum(d: Data): boolean { ... }
264 | ```
265 | 
266 | Added in v0.4.0
267 | 
268 | # member (function)
269 | 
270 | **Signature**
271 | 
272 | ```ts
273 | export function member(type: Type, name: Option<Identifier> = none): Member { ... }
274 | ```
275 | 
276 | Added in v0.4.0
277 | 
278 | # parameterDeclaration (function)
279 | 
280 | **Signature**
281 | 
282 | ```ts
283 | export function parameterDeclaration(name: Identifier, constraint: Option<Type> = none): ParameterDeclaration { ... }
284 | ```
285 | 
286 | Added in v0.4.0
287 | 
288 | # ref (function)
289 | 
290 | **Signature**
291 | 
292 | ```ts
293 | export function ref(name: Identifier, parameters: Array<Type> = []): Type { ... }
294 | ```
295 | 
296 | Added in v0.4.0
297 | 
298 | # tuple (function)
299 | 
300 | **Signature**
301 | 
302 | ```ts
303 | export function tuple(types: Array<Type>): Type { ... }
304 | ```
305 | 
306 | Added in v0.4.0
307 | 


--------------------------------------------------------------------------------
/docs/modules/printer.ts.md:
--------------------------------------------------------------------------------
  1 | ---
  2 | title: printer.ts
  3 | nav_order: 5
  4 | parent: Modules
  5 | ---
  6 | 
  7 | ---
  8 | 
  9 | <h2 class="text-delta">Table of contents</h2>
 10 | 
 11 | - [Printer (interface)](#printer-interface)
 12 | - [all (function)](#all-function)
 13 | - [ast (function)](#ast-function)
 14 | - [constructors (function)](#constructors-function)
 15 | - [data (function)](#data-function)
 16 | - [eq (function)](#eq-function)
 17 | - [fold (function)](#fold-function)
 18 | - [getMonoid (function)](#getmonoid-function)
 19 | - [print (function)](#print-function)
 20 | - [prisms (function)](#prisms-function)
 21 | 
 22 | ---
 23 | 
 24 | # Printer (interface)
 25 | 
 26 | **Signature**
 27 | 
 28 | ```ts
 29 | export interface Printer<A> extends R.Reader<Ast.Options, A> {}
 30 | ```
 31 | 
 32 | Added in v0.4.0
 33 | 
 34 | # all (function)
 35 | 
 36 | **Signature**
 37 | 
 38 | ```ts
 39 | export function all(d: M.Data): Printer<Array<string>> { ... }
 40 | ```
 41 | 
 42 | Added in v0.4.0
 43 | 
 44 | # ast (function)
 45 | 
 46 | **Signature**
 47 | 
 48 | ```ts
 49 | export function ast(ast: ts.Node): string { ... }
 50 | ```
 51 | 
 52 | Added in v0.4.0
 53 | 
 54 | # constructors (function)
 55 | 
 56 | **Signature**
 57 | 
 58 | ```ts
 59 | export function constructors(d: M.Data): Printer<Array<string>> { ... }
 60 | ```
 61 | 
 62 | Added in v0.4.0
 63 | 
 64 | # data (function)
 65 | 
 66 | **Signature**
 67 | 
 68 | ```ts
 69 | export function data(d: M.Data): Printer<string> { ... }
 70 | ```
 71 | 
 72 | Added in v0.4.0
 73 | 
 74 | # eq (function)
 75 | 
 76 | **Signature**
 77 | 
 78 | ```ts
 79 | export function eq(d: M.Data): Printer<Array<string>> { ... }
 80 | ```
 81 | 
 82 | Added in v0.4.0
 83 | 
 84 | # fold (function)
 85 | 
 86 | **Signature**
 87 | 
 88 | ```ts
 89 | export function fold(d: M.Data): Printer<string> { ... }
 90 | ```
 91 | 
 92 | Added in v0.4.0
 93 | 
 94 | # getMonoid (function)
 95 | 
 96 | **Signature**
 97 | 
 98 | ```ts
 99 | export function getMonoid<A>(M: Mon.Monoid<A>): Mon.Monoid<Printer<A>> { ... }
100 | ```
101 | 
102 | Added in v0.4.0
103 | 
104 | # print (function)
105 | 
106 | **Signature**
107 | 
108 | ```ts
109 | export function print(options: Ast.Options): (d: M.Data) => string { ... }
110 | ```
111 | 
112 | Added in v0.4.0
113 | 
114 | # prisms (function)
115 | 
116 | **Signature**
117 | 
118 | ```ts
119 | export function prisms(d: M.Data): Printer<Array<string>> { ... }
120 | ```
121 | 
122 | Added in v0.4.0
123 | 


--------------------------------------------------------------------------------
/docs/prism.css:
--------------------------------------------------------------------------------
  1 | /* PrismJS 1.15.0
  2 | https://prismjs.com/download.html#themes=prism&languages=clike+javascript+typescript */
  3 | /**
  4 |  * prism.js default theme for JavaScript, CSS and HTML
  5 |  * Based on dabblet (http://dabblet.com)
  6 |  * @author Lea Verou
  7 |  */
  8 | 
  9 | code[class*="language-"],
 10 | pre[class*="language-"] {
 11 | 	color: black;
 12 | 	background: none;
 13 | 	text-shadow: 0 1px white;
 14 | 	font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
 15 | 	text-align: left;
 16 | 	white-space: pre;
 17 | 	word-spacing: normal;
 18 | 	word-break: normal;
 19 | 	word-wrap: normal;
 20 | 	line-height: 1.5;
 21 | 
 22 | 	-moz-tab-size: 4;
 23 | 	-o-tab-size: 4;
 24 | 	tab-size: 4;
 25 | 
 26 | 	-webkit-hyphens: none;
 27 | 	-moz-hyphens: none;
 28 | 	-ms-hyphens: none;
 29 | 	hyphens: none;
 30 | }
 31 | 
 32 | pre[class*="language-"]::-moz-selection, pre[class*="language-"] ::-moz-selection,
 33 | code[class*="language-"]::-moz-selection, code[class*="language-"] ::-moz-selection {
 34 | 	text-shadow: none;
 35 | 	background: #b3d4fc;
 36 | }
 37 | 
 38 | pre[class*="language-"]::selection, pre[class*="language-"] ::selection,
 39 | code[class*="language-"]::selection, code[class*="language-"] ::selection {
 40 | 	text-shadow: none;
 41 | 	background: #b3d4fc;
 42 | }
 43 | 
 44 | @media print {
 45 | 	code[class*="language-"],
 46 | 	pre[class*="language-"] {
 47 | 		text-shadow: none;
 48 | 	}
 49 | }
 50 | 
 51 | /* Code blocks */
 52 | pre[class*="language-"] {
 53 | 	padding: 1em;
 54 | 	margin: .5em 0;
 55 | 	overflow: auto;
 56 | }
 57 | 
 58 | :not(pre) > code[class*="language-"],
 59 | pre[class*="language-"] {
 60 | 	background: #f5f2f0;
 61 | }
 62 | 
 63 | /* Inline code */
 64 | :not(pre) > code[class*="language-"] {
 65 | 	padding: .1em;
 66 | 	border-radius: .3em;
 67 | 	white-space: normal;
 68 | }
 69 | 
 70 | .token.comment,
 71 | .token.prolog,
 72 | .token.doctype,
 73 | .token.cdata {
 74 | 	color: slategray;
 75 | }
 76 | 
 77 | .token.punctuation {
 78 | 	color: #999;
 79 | }
 80 | 
 81 | .namespace {
 82 | 	opacity: .7;
 83 | }
 84 | 
 85 | .token.property,
 86 | .token.tag,
 87 | .token.boolean,
 88 | .token.number,
 89 | .token.constant,
 90 | .token.symbol,
 91 | .token.deleted {
 92 | 	color: #905;
 93 | }
 94 | 
 95 | .token.selector,
 96 | .token.attr-name,
 97 | .token.string,
 98 | .token.char,
 99 | .token.builtin,
100 | .token.inserted {
101 | 	color: #690;
102 | }
103 | 
104 | .token.operator,
105 | .token.entity,
106 | .token.url,
107 | .language-css .token.string,
108 | .style .token.string {
109 | 	color: #9a6e3a;
110 | 	background: hsla(0, 0%, 100%, .5);
111 | }
112 | 
113 | .token.atrule,
114 | .token.attr-value,
115 | .token.keyword {
116 | 	color: #07a;
117 | }
118 | 
119 | .token.function,
120 | .token.class-name {
121 | 	color: #DD4A68;
122 | }
123 | 
124 | .token.regex,
125 | .token.important,
126 | .token.variable {
127 | 	color: #e90;
128 | }
129 | 
130 | .token.important,
131 | .token.bold {
132 | 	font-weight: bold;
133 | }
134 | .token.italic {
135 | 	font-style: italic;
136 | }
137 | 
138 | .token.entity {
139 | 	cursor: help;
140 | }
141 | 
142 | 


--------------------------------------------------------------------------------
/docs/style.css:
--------------------------------------------------------------------------------
 1 | body {
 2 |   font-family: 'Fira code', monospace;
 3 | }
 4 | 
 5 | table td {
 6 |   vertical-align: top;
 7 |   padding: 20px;
 8 | }
 9 | 
10 | table td.source {
11 |   width: 40%;
12 | }
13 | 
14 | table td.code {
15 |   width: 60%;
16 | }
17 | 
18 | textarea {
19 |   font-family: 'Fira code', monospace;
20 |   width: 100%;
21 |   border: none;
22 |   font-size: 16px;
23 |   padding: 10px;
24 | }
25 | 
26 | select {
27 |   font-size: 16px;
28 | }
29 | 


--------------------------------------------------------------------------------
/dtslint/index.d.ts:
--------------------------------------------------------------------------------
1 | // TypeScript Version: 3.0
2 | 


--------------------------------------------------------------------------------
/dtslint/index.ts:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gcanti/fp-ts-codegen/40a70dc17724a594fb191dd37c192633d1ed4412/dtslint/index.ts


--------------------------------------------------------------------------------
/dtslint/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "noEmit": true,
 4 |     "strict": true,
 5 |     "noImplicitAny": true,
 6 |     "noImplicitThis": true,
 7 |     "strictNullChecks": true,
 8 |     "strictFunctionTypes": true,
 9 |     "noImplicitReturns": false,
10 |     "noUnusedLocals": false,
11 |     "noUnusedParameters": true,
12 |     "noFallthroughCasesInSwitch": true,
13 |     "target": "es5",
14 |     "lib": ["es2015"]
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/dtslint/tslint.json:
--------------------------------------------------------------------------------
1 | {
2 |   "extends": "dtslint/dtslint.json",
3 |   "rules": {
4 |     "semicolon": false,
5 |     "array-type": false
6 |   }
7 | }
8 | 


--------------------------------------------------------------------------------
/examples/Constrained.ts:
--------------------------------------------------------------------------------
 1 | export type Constrained<A extends string> = {
 2 |     readonly type: "Fetching";
 3 | } | {
 4 |     readonly type: "GotData";
 5 |     readonly value0: A;
 6 | };
 7 | 
 8 | export const fetching: Constrained<string> = { type: "Fetching" };
 9 | 
10 | export function gotData<A extends string>(value0: A): Constrained<A> { return { type: "GotData", value0 }; }
11 | 
12 | export function fold<A extends string, R>(onFetching: () => R, onGotData: (value0: A) => R): (fa: Constrained<A>) => R { return fa => { switch (fa.type) {
13 |     case "Fetching": return onFetching();
14 |     case "GotData": return onGotData(fa.value0);
15 | } }; }
16 | 
17 | import { Prism } from "monocle-ts";
18 | 
19 | export function _fetching<A extends string>(): Prism<Constrained<A>, Constrained<A>> { return Prism.fromPredicate(s => s.type === "Fetching"); }
20 | 
21 | export function _gotData<A extends string>(): Prism<Constrained<A>, Constrained<A>> { return Prism.fromPredicate(s => s.type === "GotData"); }
22 | 
23 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
24 | 
25 | export function getEq<A extends string>(eqGotDataValue0: Eq<A>): Eq<Constrained<A>> { return fromEquals((x, y) => { if (x.type === "Fetching" && y.type === "Fetching") {
26 |     return true;
27 | } if (x.type === "GotData" && y.type === "GotData") {
28 |     return eqGotDataValue0.equals(x.value0, y.value0);
29 | } return false; }); }
30 | 
31 | 


--------------------------------------------------------------------------------
/examples/Either.ts:
--------------------------------------------------------------------------------
 1 | export type Either<E, R> = {
 2 |     readonly type: "Left";
 3 |     readonly value0: E;
 4 | } | {
 5 |     readonly type: "Right";
 6 |     readonly value0: R;
 7 | };
 8 | 
 9 | export function left<E, R>(value0: E): Either<E, R> { return { type: "Left", value0 }; }
10 | 
11 | export function right<E, R>(value0: R): Either<E, R> { return { type: "Right", value0 }; }
12 | 
13 | export function fold<E, R, R1>(onLeft: (value0: E) => R1, onRight: (value0: R) => R1): (fa: Either<E, R>) => R1 { return fa => { switch (fa.type) {
14 |     case "Left": return onLeft(fa.value0);
15 |     case "Right": return onRight(fa.value0);
16 | } }; }
17 | 
18 | import { Prism } from "monocle-ts";
19 | 
20 | export function _left<E, R>(): Prism<Either<E, R>, Either<E, R>> { return Prism.fromPredicate(s => s.type === "Left"); }
21 | 
22 | export function _right<E, R>(): Prism<Either<E, R>, Either<E, R>> { return Prism.fromPredicate(s => s.type === "Right"); }
23 | 
24 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
25 | 
26 | export function getEq<E, R>(eqLeftValue0: Eq<E>, eqRightValue0: Eq<R>): Eq<Either<E, R>> { return fromEquals((x, y) => { if (x.type === "Left" && y.type === "Left") {
27 |     return eqLeftValue0.equals(x.value0, y.value0);
28 | } if (x.type === "Right" && y.type === "Right") {
29 |     return eqRightValue0.equals(x.value0, y.value0);
30 | } return false; }); }
31 | 
32 | 


--------------------------------------------------------------------------------
/examples/FooBarBaz.ts:
--------------------------------------------------------------------------------
 1 | export type FooBarBaz = {
 2 |     readonly type: "Foo";
 3 | } | {
 4 |     readonly type: "Bar";
 5 | } | {
 6 |     readonly type: "Baz";
 7 | };
 8 | 
 9 | export const foo: FooBarBaz = { type: "Foo" };
10 | 
11 | export const bar: FooBarBaz = { type: "Bar" };
12 | 
13 | export const baz: FooBarBaz = { type: "Baz" };
14 | 
15 | export function fold<R>(onFoo: () => R, onBar: () => R, onBaz: () => R): (fa: FooBarBaz) => R { return fa => { switch (fa.type) {
16 |     case "Foo": return onFoo();
17 |     case "Bar": return onBar();
18 |     case "Baz": return onBaz();
19 | } }; }
20 | 
21 | import { Prism } from "monocle-ts";
22 | 
23 | export const _Foo: Prism<FooBarBaz, FooBarBaz> = Prism.fromPredicate(s => s.type === "Foo");
24 | 
25 | export const _Bar: Prism<FooBarBaz, FooBarBaz> = Prism.fromPredicate(s => s.type === "Bar");
26 | 
27 | export const _Baz: Prism<FooBarBaz, FooBarBaz> = Prism.fromPredicate(s => s.type === "Baz");
28 | 
29 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
30 | 
31 | export function getEq(): Eq<FooBarBaz> { return fromEquals((x, y) => { if (x.type === "Foo" && y.type === "Foo") {
32 |     return true;
33 | } if (x.type === "Bar" && y.type === "Bar") {
34 |     return true;
35 | } if (x.type === "Baz" && y.type === "Baz") {
36 |     return true;
37 | } return false; }); }
38 | 
39 | 


--------------------------------------------------------------------------------
/examples/Maybe.ts:
--------------------------------------------------------------------------------
 1 | export type Maybe<A> = {
 2 |     readonly type: "Nothing";
 3 | } | {
 4 |     readonly type: "Just";
 5 |     readonly value: A;
 6 | };
 7 | 
 8 | export const nothing: Maybe<never> = { type: "Nothing" };
 9 | 
10 | export function just<A>(value: A): Maybe<A> { return { type: "Just", value }; }
11 | 
12 | export function fold<A, R>(onNothing: () => R, onJust: (value: A) => R): (fa: Maybe<A>) => R { return fa => { switch (fa.type) {
13 |     case "Nothing": return onNothing();
14 |     case "Just": return onJust(fa.value);
15 | } }; }
16 | 
17 | import { Prism } from "monocle-ts";
18 | 
19 | export function _nothing<A>(): Prism<Maybe<A>, Maybe<A>> { return Prism.fromPredicate(s => s.type === "Nothing"); }
20 | 
21 | export function _just<A>(): Prism<Maybe<A>, Maybe<A>> { return Prism.fromPredicate(s => s.type === "Just"); }
22 | 
23 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
24 | 
25 | export function getEq<A>(eqJustValue: Eq<A>): Eq<Maybe<A>> { return fromEquals((x, y) => { if (x.type === "Nothing" && y.type === "Nothing") {
26 |     return true;
27 | } if (x.type === "Just" && y.type === "Just") {
28 |     return eqJustValue.equals(x.value, y.value);
29 | } return false; }); }
30 | 
31 | 


--------------------------------------------------------------------------------
/examples/NotAlignedNames.ts:
--------------------------------------------------------------------------------
 1 | export type NotAlignedNames = {
 2 |     readonly value: string;
 3 | };
 4 | 
 5 | export function ctor(value: string): NotAlignedNames { return { value }; }
 6 | 
 7 | 
 8 | 
 9 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
10 | 
11 | export function getEq(eqValue: Eq<string>): Eq<NotAlignedNames> { return fromEquals((x, y) => { return eqValue.equals(x.value, y.value); }); }
12 | 
13 | 


--------------------------------------------------------------------------------
/examples/Nullary.ts:
--------------------------------------------------------------------------------
1 | export type Nullary = {};
2 | 
3 | export const nullary: Nullary = {};
4 | 
5 | 
6 | 
7 | 


--------------------------------------------------------------------------------
/examples/Option.ts:
--------------------------------------------------------------------------------
 1 | export type Option<A> = {
 2 |     readonly type: "None";
 3 | } | {
 4 |     readonly type: "Some";
 5 |     readonly value0: A;
 6 | };
 7 | 
 8 | export const none: Option<never> = { type: "None" };
 9 | 
10 | export function some<A>(value0: A): Option<A> { return { type: "Some", value0 }; }
11 | 
12 | export function fold<A, R>(onNone: () => R, onSome: (value0: A) => R): (fa: Option<A>) => R { return fa => { switch (fa.type) {
13 |     case "None": return onNone();
14 |     case "Some": return onSome(fa.value0);
15 | } }; }
16 | 
17 | import { Prism } from "monocle-ts";
18 | 
19 | export function _none<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.type === "None"); }
20 | 
21 | export function _some<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.type === "Some"); }
22 | 
23 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
24 | 
25 | export function getEq<A>(eqSomeValue0: Eq<A>): Eq<Option<A>> { return fromEquals((x, y) => { if (x.type === "None" && y.type === "None") {
26 |     return true;
27 | } if (x.type === "Some" && y.type === "Some") {
28 |     return eqSomeValue0.equals(x.value0, y.value0);
29 | } return false; }); }
30 | 
31 | 


--------------------------------------------------------------------------------
/examples/State.ts:
--------------------------------------------------------------------------------
 1 | export type State<S, A> = {
 2 |     readonly value0: (s: S) => [A, S];
 3 | };
 4 | 
 5 | export function state<S, A>(value0: (s: S) => [A, S]): State<S, A> { return { value0 }; }
 6 | 
 7 | 
 8 | 
 9 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
10 | 
11 | export function getEq<S, A>(eqValue0: Eq<(s: S) => [A, S]>): Eq<State<S, A>> { return fromEquals((x, y) => { return eqValue0.equals(x.value0, y.value0); }); }
12 | 
13 | 


--------------------------------------------------------------------------------
/examples/These.ts:
--------------------------------------------------------------------------------
 1 | export type These<A, B> = {
 2 |     readonly type: "Left";
 3 |     readonly left: A;
 4 | } | {
 5 |     readonly type: "Right";
 6 |     readonly right: B;
 7 | } | {
 8 |     readonly type: "Both";
 9 |     readonly left: A;
10 |     readonly right: B;
11 | };
12 | 
13 | export function left<A, B>(left: A): These<A, B> { return { type: "Left", left }; }
14 | 
15 | export function right<A, B>(right: B): These<A, B> { return { type: "Right", right }; }
16 | 
17 | export function both<A, B>(left: A, right: B): These<A, B> { return { type: "Both", left, right }; }
18 | 
19 | export function fold<A, B, R>(onLeft: (left: A) => R, onRight: (right: B) => R, onBoth: (left: A, right: B) => R): (fa: These<A, B>) => R { return fa => { switch (fa.type) {
20 |     case "Left": return onLeft(fa.left);
21 |     case "Right": return onRight(fa.right);
22 |     case "Both": return onBoth(fa.left, fa.right);
23 | } }; }
24 | 
25 | import { Prism } from "monocle-ts";
26 | 
27 | export function _left<A, B>(): Prism<These<A, B>, These<A, B>> { return Prism.fromPredicate(s => s.type === "Left"); }
28 | 
29 | export function _right<A, B>(): Prism<These<A, B>, These<A, B>> { return Prism.fromPredicate(s => s.type === "Right"); }
30 | 
31 | export function _both<A, B>(): Prism<These<A, B>, These<A, B>> { return Prism.fromPredicate(s => s.type === "Both"); }
32 | 
33 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
34 | 
35 | export function getEq<A, B>(eqLeftLeft: Eq<A>, eqRightRight: Eq<B>, eqBothLeft: Eq<A>, eqBothRight: Eq<B>): Eq<These<A, B>> { return fromEquals((x, y) => { if (x.type === "Left" && y.type === "Left") {
36 |     return eqLeftLeft.equals(x.left, y.left);
37 | } if (x.type === "Right" && y.type === "Right") {
38 |     return eqRightRight.equals(x.right, y.right);
39 | } if (x.type === "Both" && y.type === "Both") {
40 |     return eqBothLeft.equals(x.left, y.left) && eqBothRight.equals(x.right, y.right);
41 | } return false; }); }
42 | 
43 | 


--------------------------------------------------------------------------------
/examples/Tree.ts:
--------------------------------------------------------------------------------
 1 | export type Tree<A> = {
 2 |     readonly type: "Leaf";
 3 | } | {
 4 |     readonly type: "Node";
 5 |     readonly value0: Tree<A>;
 6 |     readonly value1: A;
 7 |     readonly value2: Tree<A>;
 8 | };
 9 | 
10 | export const leaf: Tree<never> = { type: "Leaf" };
11 | 
12 | export function node<A>(value0: Tree<A>, value1: A, value2: Tree<A>): Tree<A> { return { type: "Node", value0, value1, value2 }; }
13 | 
14 | export function fold<A, R>(onLeaf: () => R, onNode: (value0: Tree<A>, value1: A, value2: Tree<A>) => R): (fa: Tree<A>) => R { return fa => { switch (fa.type) {
15 |     case "Leaf": return onLeaf();
16 |     case "Node": return onNode(fa.value0, fa.value1, fa.value2);
17 | } }; }
18 | 
19 | import { Prism } from "monocle-ts";
20 | 
21 | export function _leaf<A>(): Prism<Tree<A>, Tree<A>> { return Prism.fromPredicate(s => s.type === "Leaf"); }
22 | 
23 | export function _node<A>(): Prism<Tree<A>, Tree<A>> { return Prism.fromPredicate(s => s.type === "Node"); }
24 | 
25 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
26 | 
27 | export function getEq<A>(eqNodeValue1: Eq<A>): Eq<Tree<A>> { const S: Eq<Tree<A>> = fromEquals((x, y) => { if (x.type === "Leaf" && y.type === "Leaf") {
28 |     return true;
29 | } if (x.type === "Node" && y.type === "Node") {
30 |     return S.equals(x.value0, y.value0) && eqNodeValue1.equals(x.value1, y.value1) && S.equals(x.value2, y.value2);
31 | } return false; }); return S; }
32 | 
33 | 


--------------------------------------------------------------------------------
/examples/Tuple2.ts:
--------------------------------------------------------------------------------
 1 | export type Tuple2<A, B> = {
 2 |     readonly value0: [A, B];
 3 | };
 4 | 
 5 | export function tuple2<A, B>(value0: [A, B]): Tuple2<A, B> { return { value0 }; }
 6 | 
 7 | 
 8 | 
 9 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
10 | 
11 | export function getEq<A, B>(eqValue0: Eq<[A, B]>): Eq<Tuple2<A, B>> { return fromEquals((x, y) => { return eqValue0.equals(x.value0, y.value0); }); }
12 | 
13 | 


--------------------------------------------------------------------------------
/examples/User.ts:
--------------------------------------------------------------------------------
 1 | export type User = {
 2 |     readonly name: string;
 3 |     readonly surname: string;
 4 |     readonly age: number;
 5 | };
 6 | 
 7 | export function user(name: string, surname: string, age: number): User { return { name, surname, age }; }
 8 | 
 9 | 
10 | 
11 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
12 | 
13 | export function getEq(eqName: Eq<string>, eqSurname: Eq<string>, eqAge: Eq<number>): Eq<User> { return fromEquals((x, y) => { return eqName.equals(x.name, y.name) && eqSurname.equals(x.surname, y.surname) && eqAge.equals(x.age, y.age); }); }
14 | 
15 | 


--------------------------------------------------------------------------------
/examples/Writer.ts:
--------------------------------------------------------------------------------
 1 | export type Writer<W, A> = {
 2 |     readonly value0: () => [A, W];
 3 | };
 4 | 
 5 | export function writer<W, A>(value0: () => [A, W]): Writer<W, A> { return { value0 }; }
 6 | 
 7 | 
 8 | 
 9 | import { Eq, fromEquals } from "fp-ts/lib/Eq";
10 | 
11 | export function getEq<W, A>(eqValue0: Eq<() => [A, W]>): Eq<Writer<W, A>> { return fromEquals((x, y) => { return eqValue0.equals(x.value0, y.value0); }); }
12 | 
13 | 


--------------------------------------------------------------------------------
/examples/index.ts:
--------------------------------------------------------------------------------
 1 | import './Option'
 2 | import './Maybe'
 3 | import './Either'
 4 | import './These'
 5 | import './Tree'
 6 | import './FooBarBaz'
 7 | import './User'
 8 | import './Constrained'
 9 | import './Tuple2'
10 | import './State'
11 | import './Writer'
12 | import './Nullary'
13 | import './NotAlignedNames'
14 | 
15 | 


--------------------------------------------------------------------------------
/generate-examples.ts:
--------------------------------------------------------------------------------
 1 | import * as fs from 'fs'
 2 | import * as path from 'path'
 3 | import * as M from './src/model'
 4 | import * as P from './src/printer'
 5 | import * as E from './test/examples'
 6 | import { defaultOptions } from './src/ast'
 7 | 
 8 | const examples = Object.keys(E).map(k => (E as any)[k] as M.Data)
 9 | 
10 | const print = P.print(defaultOptions)
11 | 
12 | examples.forEach(example => {
13 |   const code = print(example) + '\n\n'
14 |   const filePath = path.join(__dirname, `./examples/${example.name}.ts`)
15 |   fs.writeFileSync(filePath, code, { encoding: 'utf-8' })
16 | })
17 | 
18 | const index = examples.map(example => `import './${example.name}'`).join('\n') + '\n\n'
19 | 
20 | fs.writeFileSync(path.join(__dirname, `./examples/index.ts`), index, { encoding: 'utf-8' })
21 | 


--------------------------------------------------------------------------------
/jest.config.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   preset: 'ts-jest',
 3 |   testEnvironment: 'node',
 4 |   collectCoverage: true,
 5 |   collectCoverageFrom: ['src/**/*.ts'],
 6 |   transform: {
 7 |     '^.+\\.tsx?$': 'ts-jest'
 8 |   },
 9 |   testRegex: 'test',
10 |   moduleFileExtensions: ['ts', 'js'],
11 |   coverageThreshold: {
12 |     global: {
13 |       branches: 100,
14 |       functions: 100,
15 |       lines: 100,
16 |       statements: 100
17 |     }
18 |   },
19 |   modulePathIgnorePatterns: ['examples.ts', 'helpers.ts']
20 | }
21 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "fp-ts-codegen",
 3 |   "version": "0.4.0",
 4 |   "description": "TypeScript code generation from a haskell-like syntax for ADT",
 5 |   "files": [
 6 |     "lib"
 7 |   ],
 8 |   "main": "lib/index.js",
 9 |   "typings": "lib/index.d.ts",
10 |   "scripts": {
11 |     "lint": "tslint -p tsconfig.json src/**/*.ts test/**/*.ts",
12 |     "jest": "jest",
13 |     "prettier": "prettier --no-semi --single-quote --print-width 120 --parser typescript --list-different \"{src,test}/**/*.ts\"",
14 |     "fix-prettier": "prettier --no-semi --single-quote --print-width 120 --parser typescript --write \"{src,test}/**/*.ts\"",
15 |     "test": "npm run prettier && npm run jest && npm run docs && npm run examples && npm run playground",
16 |     "clean": "rimraf rm -rf lib/*",
17 |     "build": "npm run clean && tsc",
18 |     "dtslint": "dtslint dtslint",
19 |     "mocha": "mocha -r ts-node/register \"./test/**/*.ts\" --recursive",
20 |     "examples": "rimraf examples/*.ts && ts-node generate-examples.ts && ts-node examples/index.ts",
21 |     "playground": "webpack --config playground/webpack.config.js",
22 |     "watch-playground": "webpack --config playground/webpack.config.js --watch",
23 |     "docs": "docs-ts"
24 |   },
25 |   "repository": {
26 |     "type": "git",
27 |     "url": "https://github.com/gcanti/fp-ts-codegen.git"
28 |   },
29 |   "author": "Giulio Canti <giulio.canti@gmail.com>",
30 |   "license": "MIT",
31 |   "bugs": {
32 |     "url": "https://github.com/gcanti/fp-ts-codegen/issues"
33 |   },
34 |   "homepage": "https://github.com/gcanti/fp-ts-codegen",
35 |   "dependencies": {
36 |     "fp-ts": "^2.0.1",
37 |     "monocle-ts": "^2.0.0",
38 |     "parser-ts": "^0.6.0",
39 |     "typescript": "^3.5.2"
40 |   },
41 |   "devDependencies": {
42 |     "@types/jest": "^23.3.13",
43 |     "@types/node": "^10.12.18",
44 |     "@types/prismjs": "^1.9.0",
45 |     "@types/react": "^16.7.21",
46 |     "@types/react-dom": "^16.0.11",
47 |     "docs-ts": "^0.1.0",
48 |     "dtslint": "^0.4.2",
49 |     "jest": "^24.8.0",
50 |     "mocha": "^5.2.0",
51 |     "prettier": "^1.16.4",
52 |     "prismjs": "^1.15.0",
53 |     "react": "^16.7.0",
54 |     "react-dom": "^16.7.0",
55 |     "react-simple-code-editor": "^0.8.0",
56 |     "rimraf": "^2.6.3",
57 |     "ts-jest": "^24.0.2",
58 |     "ts-loader": "^5.3.3",
59 |     "ts-node": "3.3.0",
60 |     "tslint": "^5.12.1",
61 |     "tslint-config-standard": "^8.0.1",
62 |     "webpack": "^4.29.0",
63 |     "webpack-cli": "^3.2.1"
64 |   },
65 |   "tags": [
66 |     "fp-ts",
67 |     "ADT"
68 |   ],
69 |   "keywords": [
70 |     "fp-ts",
71 |     "ADT"
72 |   ]
73 | }
74 | 


--------------------------------------------------------------------------------
/playground/index.tsx:
--------------------------------------------------------------------------------
  1 | import * as E from 'fp-ts/lib/Either'
  2 | import { pipe } from 'fp-ts/lib/pipeable'
  3 | import { highlight, languages } from 'prismjs'
  4 | import 'prismjs/components/prism-typescript'
  5 | import * as React from 'react'
  6 | import * as ReactDOM from 'react-dom'
  7 | import Editor from 'react-simple-code-editor'
  8 | import * as pkg from '../package.json'
  9 | import { run } from '../src'
 10 | import { defaultOptions, lenses, Options } from '../src/ast'
 11 | 
 12 | const defaultSource = 'data Option A = None | Some A'
 13 | 
 14 | interface Props {
 15 |   source: string
 16 |   handlersStyle: Options['handlersStyle']
 17 | }
 18 | 
 19 | interface State extends Props {
 20 |   code: string
 21 | }
 22 | 
 23 | const getState = (source: string, handlersStyle: Options['handlersStyle']): State => {
 24 |   const options = lenses.handlersStyle.set(handlersStyle)(defaultOptions)
 25 |   return {
 26 |     source,
 27 |     handlersStyle,
 28 |     code: pipe(
 29 |       run(source, options),
 30 |       E.getOrElse(e => `/*\n${e}\n*/`)
 31 |     )
 32 |   }
 33 | }
 34 | 
 35 | class App extends React.Component<Props, State> {
 36 |   constructor(props: Props) {
 37 |     super(props)
 38 |     this.state = getState(props.source, props.handlersStyle)
 39 |   }
 40 | 
 41 |   render() {
 42 |     const onValueChange = (code: string) => {
 43 |       console.log(code)
 44 |     }
 45 |     const onCodeChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
 46 |       this.setState(getState(e.currentTarget.value, this.state.handlersStyle))
 47 |     }
 48 |     const onHandlersStyleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
 49 |       if (e.currentTarget.checked) {
 50 |         this.setState(getState(this.state.source, { type: 'record', handlersName: 'handlers' }))
 51 |       } else {
 52 |         this.setState(getState(this.state.source, { type: 'positional' }))
 53 |       }
 54 |     }
 55 |     const onExampleChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
 56 |       this.setState(getState(e.currentTarget.value, this.state.handlersStyle))
 57 |     }
 58 |     return (
 59 |       <div>
 60 |         <h1>
 61 |           {pkg.name} playground (v{pkg.version})
 62 |         </h1>
 63 |         <table>
 64 |           <thead>
 65 |             <tr>
 66 |               <th>Source</th>
 67 |               <th>Output (unformatted)</th>
 68 |             </tr>
 69 |           </thead>
 70 |           <tbody>
 71 |             <tr>
 72 |               <td className="source">
 73 |                 <textarea rows={10} value={this.state.source} onChange={onCodeChange} />
 74 |                 <input type="checkbox" onChange={onHandlersStyleChange} /> fold handlers style:{' '}
 75 |                 {this.state.handlersStyle.type}
 76 |                 <br />
 77 |                 <br />
 78 |                 Examples:
 79 |                 <select onChange={onExampleChange}>
 80 |                   <option value="data Option A = None | Some A">Option</option>
 81 |                   <option value="data Either A B = Left A | Right B">Either</option>
 82 |                   <option value="data These A B = Left A | Right B | Both A B">These</option>
 83 |                   <option value="data List A = Nil | Cons A (List A)">List</option>
 84 |                   <option value="data Tree A = Leaf | Node (Tree A) A (Tree A)">Tree</option>
 85 |                   <option value="data These A B = Left { left :: A } | Right { right :: B } | Both { left :: A, right :: B }">
 86 |                     These (record syntax)
 87 |                   </option>
 88 |                   <option value="data User = User { name :: string, surname :: string, age :: number }">User</option>
 89 |                 </select>
 90 |               </td>
 91 |               <td className="code">
 92 |                 <Editor
 93 |                   value={this.state.code}
 94 |                   onValueChange={code => onValueChange(code)}
 95 |                   highlight={code => {
 96 |                     return highlight(code, languages.js)
 97 |                   }}
 98 |                   padding={10}
 99 |                   style={{
100 |                     fontFamily: '"Fira code", monospace',
101 |                     fontSize: 12
102 |                   }}
103 |                 />
104 |               </td>
105 |             </tr>
106 |           </tbody>
107 |         </table>
108 |       </div>
109 |     )
110 |   }
111 | }
112 | 
113 | ReactDOM.render(<App source={defaultSource} handlersStyle={{ type: 'positional' }} />, document.getElementById('main'))
114 | 


--------------------------------------------------------------------------------
/playground/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "module": "commonjs",
 4 |     "noImplicitReturns": false,
 5 |     "noUnusedLocals": true,
 6 |     "noUnusedParameters": true,
 7 |     "noFallthroughCasesInSwitch": true,
 8 |     "strict": true,
 9 |     "target": "es5",
10 |     "moduleResolution": "node",
11 |     "forceConsistentCasingInFileNames": true,
12 |     "lib": ["es6", "dom"],
13 |     "jsx": "react",
14 |     "resolveJsonModule": true
15 |   }
16 | }
17 | 


--------------------------------------------------------------------------------
/playground/webpack.config.js:
--------------------------------------------------------------------------------
 1 | const path = require('path')
 2 | 
 3 | module.exports = {
 4 |   mode: 'production',
 5 |   entry: './playground/index.tsx',
 6 |   output: {
 7 |     path: path.resolve(__dirname, '../docs'),
 8 |     filename: 'bundle.js'
 9 |   },
10 |   module: {
11 |     rules: [
12 |       {
13 |         test: /\.tsx?$/,
14 |         use: 'ts-loader',
15 |         exclude: /node_modules/
16 |       }
17 |     ]
18 |   },
19 |   resolve: {
20 |     extensions: ['.tsx', '.ts', '.js']
21 |   }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/ast.ts:
--------------------------------------------------------------------------------
  1 | import * as O from 'fp-ts/lib/Option'
  2 | import * as R from 'fp-ts/lib/Reader'
  3 | import * as ts from 'typescript'
  4 | import * as M from './model'
  5 | import { Lens } from 'monocle-ts'
  6 | import { tuple } from 'fp-ts/lib/function'
  7 | import * as S from 'fp-ts/lib/Semigroup'
  8 | import * as A from 'fp-ts/lib/Array'
  9 | import { head } from 'fp-ts/lib/NonEmptyArray'
 10 | import { pipe } from 'fp-ts/lib/pipeable'
 11 | 
 12 | /**
 13 |  * @since 0.4.0
 14 |  */
 15 | export interface Options {
 16 |   /** the name of the field used as tag */
 17 |   tagName: string
 18 |   /** the name prefix used for pattern matching functions */
 19 |   foldName: string
 20 |   /**
 21 |    * the pattern matching handlers can be expressed as positional arguments
 22 |    * or a single object literal `tag -> handler`
 23 |    */
 24 |   handlersStyle: { type: 'positional' } | { type: 'record'; handlersName: string }
 25 | }
 26 | 
 27 | /**
 28 |  * @since 0.4.0
 29 |  */
 30 | export const defaultOptions: Options = {
 31 |   tagName: 'type',
 32 |   foldName: 'fold',
 33 |   handlersStyle: { type: 'positional' }
 34 | }
 35 | 
 36 | const getLens = Lens.fromProp<Options>()
 37 | 
 38 | /**
 39 |  * @since 0.4.0
 40 |  */
 41 | export const lenses: { [K in keyof Options]: Lens<Options, Options[K]> } = {
 42 |   tagName: getLens('tagName'),
 43 |   foldName: getLens('foldName'),
 44 |   handlersStyle: getLens('handlersStyle')
 45 | }
 46 | 
 47 | /**
 48 |  * @since 0.4.0
 49 |  */
 50 | export interface AST<A> extends R.Reader<Options, A> {}
 51 | 
 52 | const getMemberName = (m: M.Member, position: number): string => {
 53 |   return pipe(
 54 |     m.name,
 55 |     O.getOrElse(() => `value${position}`)
 56 |   )
 57 | }
 58 | 
 59 | const getDomainParameterName = (type: M.Type): O.Option<string> => {
 60 |   switch (type.kind) {
 61 |     case 'Ref':
 62 |       return O.some(getFirstLetterLowerCase(type.name))
 63 |     case 'Tuple':
 64 |       return O.some('tuple')
 65 |     case 'Fun':
 66 |       return O.some('f')
 67 |     case 'Unit':
 68 |       return O.none
 69 |   }
 70 | }
 71 | 
 72 | const getTypeNode = (type: M.Type): ts.TypeNode => {
 73 |   switch (type.kind) {
 74 |     case 'Ref':
 75 |       return ts.createTypeReferenceNode(type.name, type.parameters.map(p => getTypeNode(p)))
 76 |     case 'Tuple':
 77 |       return ts.createTupleTypeNode(type.types.map(getTypeNode))
 78 |     case 'Fun':
 79 |       return ts.createFunctionTypeNode(
 80 |         undefined,
 81 |         pipe(
 82 |           getDomainParameterName(type.domain),
 83 |           O.map(domainName => [getParameterDeclaration(domainName, getTypeNode(type.domain))]),
 84 |           O.getOrElse<Array<ts.ParameterDeclaration>>(() => A.empty)
 85 |         ),
 86 |         getTypeNode(type.codomain)
 87 |       )
 88 |     case 'Unit':
 89 |       return ts.createTypeReferenceNode('undefined', A.empty)
 90 |   }
 91 | }
 92 | 
 93 | const getTypeAliasDeclaration = (
 94 |   name: string,
 95 |   type: ts.TypeNode,
 96 |   typeParameters?: Array<ts.TypeParameterDeclaration>
 97 | ) => {
 98 |   return ts.createTypeAliasDeclaration(
 99 |     undefined,
100 |     [ts.createModifier(ts.SyntaxKind.ExportKeyword)],
101 |     name,
102 |     typeParameters,
103 |     type
104 |   )
105 | }
106 | 
107 | const getDataTypeParameterDeclarations = (d: M.Data): Array<ts.TypeParameterDeclaration> => {
108 |   return d.parameterDeclarations.map(p =>
109 |     ts.createTypeParameterDeclaration(
110 |       p.name,
111 |       pipe(
112 |         p.constraint,
113 |         O.map(getTypeNode),
114 |         O.toUndefined
115 |       )
116 |     )
117 |   )
118 | }
119 | 
120 | const getDataTypeReferenceWithNever = (d: M.Data): ts.TypeReferenceNode => {
121 |   return ts.createTypeReferenceNode(
122 |     d.name,
123 |     d.parameterDeclarations.map(p =>
124 |       pipe(
125 |         p.constraint,
126 |         O.map(c => getTypeNode(c)),
127 |         O.getOrElse<ts.TypeNode>(() => ts.createKeywordTypeNode(ts.SyntaxKind.NeverKeyword))
128 |       )
129 |     )
130 |   )
131 | }
132 | 
133 | const getDataTypeParameterReferences = (d: M.Data): Array<ts.TypeReferenceNode> => {
134 |   return d.parameterDeclarations.map(p => ts.createTypeReferenceNode(p.name, A.empty))
135 | }
136 | 
137 | const getDataType = (d: M.Data): ts.TypeReferenceNode => {
138 |   return ts.createTypeReferenceNode(d.name, getDataTypeParameterReferences(d))
139 | }
140 | 
141 | const getPropertySignature = (name: string, type: ts.TypeNode, isReadonly: boolean = true): ts.PropertySignature => {
142 |   return ts.createPropertySignature(
143 |     isReadonly ? [ts.createModifier(ts.SyntaxKind.ReadonlyKeyword)] : undefined,
144 |     name,
145 |     undefined,
146 |     type,
147 |     undefined
148 |   )
149 | }
150 | 
151 | /**
152 |  * @since 0.4.0
153 |  */
154 | export function data(d: M.Data): AST<Array<ts.Node>> {
155 |   return e => {
156 |     const unionType = ts.createUnionTypeNode(
157 |       d.constructors.map(c => {
158 |         const members: Array<ts.TypeElement> = c.members.map((m, position) => {
159 |           return getPropertySignature(getMemberName(m, position), getTypeNode(m.type))
160 |         })
161 |         const tag: ts.TypeElement = getPropertySignature(e.tagName, ts.createLiteralTypeNode(ts.createLiteral(c.name)))
162 |         return ts.createTypeLiteralNode(M.isSum(d) ? [tag, ...members] : members)
163 |       })
164 |     )
165 |     return [getTypeAliasDeclaration(d.name, unionType, getDataTypeParameterDeclarations(d))]
166 |   }
167 | }
168 | 
169 | const getFirstLetterLowerCase = (name: string): string => {
170 |   return name.substring(0, 1).toLocaleLowerCase() + name.substring(1)
171 | }
172 | 
173 | const getFirstLetterUpperCase = (name: string): string => {
174 |   return name.substring(0, 1).toLocaleUpperCase() + name.substring(1)
175 | }
176 | 
177 | const getConstantDeclaration = (
178 |   name: string,
179 |   initializer: ts.Expression,
180 |   type?: ts.TypeReferenceNode,
181 |   isExported: boolean = true
182 | ): ts.VariableStatement => {
183 |   return ts.createVariableStatement(
184 |     isExported ? [ts.createModifier(ts.SyntaxKind.ExportKeyword)] : A.empty,
185 |     ts.createVariableDeclarationList([ts.createVariableDeclaration(name, type, initializer)], ts.NodeFlags.Const)
186 |   )
187 | }
188 | 
189 | const getFunctionDeclaration = (
190 |   name: string,
191 |   typeParameters: Array<ts.TypeParameterDeclaration>,
192 |   parameters: Array<ts.ParameterDeclaration>,
193 |   type: ts.TypeNode,
194 |   body: ts.Block
195 | ) => {
196 |   return ts.createFunctionDeclaration(
197 |     undefined,
198 |     [ts.createModifier(ts.SyntaxKind.ExportKeyword)],
199 |     undefined,
200 |     name,
201 |     typeParameters,
202 |     parameters,
203 |     type,
204 |     body
205 |   )
206 | }
207 | 
208 | const getParameterDeclaration = (name: string, type?: ts.TypeNode): ts.ParameterDeclaration => {
209 |   return ts.createParameter(undefined, undefined, undefined, name, undefined, type, undefined)
210 | }
211 | 
212 | const getLiteralNullaryConstructor = (c: M.Constructor, d: M.Data): AST<ts.Node> => {
213 |   return e => {
214 |     const name = getFirstLetterLowerCase(c.name)
215 |     const initializer = ts.createObjectLiteral(
216 |       M.isSum(d) ? [ts.createPropertyAssignment(e.tagName, ts.createStringLiteral(c.name))] : []
217 |     )
218 |     return getConstantDeclaration(name, initializer, getDataTypeReferenceWithNever(d))
219 |   }
220 | }
221 | 
222 | const getLiteralConstructor = (c: M.Constructor, d: M.Data): AST<ts.Node> => {
223 |   return e => {
224 |     const name = getFirstLetterLowerCase(c.name)
225 |     const typeParameters = getDataTypeParameterDeclarations(d)
226 |     const parameters = c.members.map((m, position) => {
227 |       const name = getMemberName(m, position)
228 |       const type = getTypeNode(m.type)
229 |       return getParameterDeclaration(name, type)
230 |     })
231 |     const properties = c.members.map((m, position) => {
232 |       const name = getMemberName(m, position)
233 |       return ts.createShorthandPropertyAssignment(name)
234 |     })
235 |     const body = ts.createBlock([
236 |       ts.createReturn(
237 |         ts.createObjectLiteral(
238 |           M.isSum(d)
239 |             ? [ts.createPropertyAssignment(e.tagName, ts.createStringLiteral(c.name)), ...properties]
240 |             : properties
241 |         )
242 |       )
243 |     ])
244 |     return getFunctionDeclaration(name, typeParameters, parameters, getDataType(d), body)
245 |   }
246 | }
247 | 
248 | /**
249 |  * @since 0.4.0
250 |  */
251 | export function constructors(d: M.Data): AST<Array<ts.Node>> {
252 |   const constructors = d.constructors.map(c =>
253 |     A.foldLeft(() => getLiteralNullaryConstructor(c, d), () => getLiteralConstructor(c, d))(c.members)
254 |   )
255 |   return A.array.sequence(R.reader)(constructors)
256 | }
257 | 
258 | const getFoldReturnTypeParameterName = (d: M.Data): string => {
259 |   const base = 'R'
260 |   let candidate = base
261 |   let counter = 0
262 |   while (d.parameterDeclarations.findIndex(({ name }) => candidate === name) !== -1) {
263 |     candidate = base + ++counter
264 |   }
265 |   return candidate
266 | }
267 | 
268 | const getFoldHandlerName = (c: M.Constructor): string => {
269 |   return `on${c.name}`
270 | }
271 | 
272 | const getFoldPositionalHandlers = (d: M.Data): Array<ts.ParameterDeclaration> => {
273 |   const returnTypeParameterName = getFoldReturnTypeParameterName(d)
274 |   return d.constructors.map(c => {
275 |     const type = ts.createFunctionTypeNode(
276 |       undefined,
277 |       c.members.map((m, position) => getParameterDeclaration(getMemberName(m, position), getTypeNode(m.type))),
278 |       ts.createTypeReferenceNode(returnTypeParameterName, A.empty)
279 |     )
280 |     return getParameterDeclaration(getFoldHandlerName(c), type)
281 |   })
282 | }
283 | 
284 | const getFoldRecordHandlers = (d: M.Data, handlersName: string): Array<ts.ParameterDeclaration> => {
285 |   const returnTypeParameterName = getFoldReturnTypeParameterName(d)
286 |   const type = ts.createTypeLiteralNode(
287 |     d.constructors.map(c => {
288 |       const type = ts.createFunctionTypeNode(
289 |         undefined,
290 |         c.members.map((m, position) => getParameterDeclaration(getMemberName(m, position), getTypeNode(m.type))),
291 |         ts.createTypeReferenceNode(returnTypeParameterName, A.empty)
292 |       )
293 |       return getPropertySignature(getFoldHandlerName(c), type, false)
294 |     })
295 |   )
296 |   return [getParameterDeclaration(handlersName, type)]
297 | }
298 | 
299 | const getFoldPositionalBody = (d: M.Data, matcheeName: string, tagName: string) => {
300 |   return ts.createBlock([
301 |     ts.createSwitch(
302 |       ts.createPropertyAccess(ts.createIdentifier(matcheeName), tagName),
303 |       ts.createCaseBlock(
304 |         d.constructors.map(c => {
305 |           const access = ts.createIdentifier(getFoldHandlerName(c))
306 |           return ts.createCaseClause(ts.createStringLiteral(c.name), [
307 |             ts.createReturn(
308 |               ts.createCall(
309 |                 access,
310 |                 A.empty,
311 |                 c.members.map((m, position) => {
312 |                   return ts.createPropertyAccess(ts.createIdentifier(matcheeName), getMemberName(m, position))
313 |                 })
314 |               )
315 |             )
316 |           ])
317 |         })
318 |       )
319 |     )
320 |   ])
321 | }
322 | 
323 | const getFoldRecordBody = (d: M.Data, matcheeName: string, tagName: string, handlersName: string) => {
324 |   return ts.createBlock([
325 |     ts.createSwitch(
326 |       ts.createPropertyAccess(ts.createIdentifier(matcheeName), tagName),
327 |       ts.createCaseBlock(
328 |         d.constructors.map(c => {
329 |           const access = ts.createPropertyAccess(ts.createIdentifier(handlersName), getFoldHandlerName(c))
330 |           return ts.createCaseClause(ts.createStringLiteral(c.name), [
331 |             ts.createReturn(
332 |               ts.createCall(
333 |                 access,
334 |                 A.empty,
335 |                 c.members.map((m, position) => {
336 |                   return ts.createPropertyAccess(ts.createIdentifier(matcheeName), getMemberName(m, position))
337 |                 })
338 |               )
339 |             )
340 |           ])
341 |         })
342 |       )
343 |     )
344 |   ])
345 | }
346 | 
347 | const getFold = (d: M.Data, name: string): AST<ts.FunctionDeclaration> => {
348 |   return e => {
349 |     const matcheeName = 'fa'
350 |     const tagName = e.tagName
351 |     const handlersStyle = e.handlersStyle
352 |     const returnTypeParameterName = getFoldReturnTypeParameterName(d)
353 |     const typeParameterDeclarations = [
354 |       ...getDataTypeParameterDeclarations(d),
355 |       ts.createTypeParameterDeclaration(returnTypeParameterName)
356 |     ]
357 |     const handlers =
358 |       handlersStyle.type === 'positional'
359 |         ? getFoldPositionalHandlers(d)
360 |         : getFoldRecordHandlers(d, handlersStyle.handlersName)
361 |     const matchee = getParameterDeclaration(matcheeName, getDataType(d))
362 |     const returnType = ts.createFunctionTypeNode(
363 |       [],
364 |       [matchee],
365 |       ts.createTypeReferenceNode(returnTypeParameterName, A.empty)
366 |     )
367 |     const body = ts.createArrowFunction(
368 |       [],
369 |       [],
370 |       [getParameterDeclaration(matcheeName)],
371 |       undefined,
372 |       undefined,
373 |       handlersStyle.type === 'positional'
374 |         ? getFoldPositionalBody(d, matcheeName, tagName)
375 |         : getFoldRecordBody(d, matcheeName, tagName, handlersStyle.handlersName)
376 |     )
377 |     return getFunctionDeclaration(
378 |       name,
379 |       typeParameterDeclarations,
380 |       handlers,
381 |       returnType,
382 |       ts.createBlock([ts.createReturn(body)])
383 |     )
384 |   }
385 | }
386 | 
387 | /**
388 |  * @since 0.4.0
389 |  */
390 | export function fold(d: M.Data): AST<O.Option<ts.FunctionDeclaration>> {
391 |   if (!M.isSum(d)) {
392 |     return R.of(O.none)
393 |   } else {
394 |     return pipe(
395 |       R.ask<Options>(),
396 |       R.chain(e => getFold(d, e.foldName)),
397 |       R.map(O.some)
398 |     )
399 |   }
400 | }
401 | 
402 | const getImportDeclaration = (namedImports: Array<string>, from: string): ts.ImportDeclaration => {
403 |   return ts.createImportDeclaration(
404 |     A.empty,
405 |     A.empty,
406 |     ts.createImportClause(
407 |       undefined,
408 |       ts.createNamedImports(namedImports.map(name => ts.createImportSpecifier(undefined, ts.createIdentifier(name))))
409 |     ),
410 |     ts.createStringLiteral(from)
411 |   )
412 | }
413 | 
414 | const getArrowFunction = (parameters: Array<string>, body: ts.ConciseBody) => {
415 |   return ts.createArrowFunction(
416 |     [],
417 |     A.empty,
418 |     parameters.map(p => getParameterDeclaration(p)),
419 |     undefined,
420 |     undefined,
421 |     body
422 |   )
423 | }
424 | 
425 | /**
426 |  * @since 0.4.0
427 |  */
428 | export function prisms(d: M.Data): AST<Array<ts.Node>> {
429 |   return pipe(
430 |     R.ask<Options>(),
431 |     R.chain(e => {
432 |       if (!M.isSum(d)) {
433 |         return R.of(A.empty)
434 |       }
435 |       const dataType = getDataType(d)
436 |       const type = ts.createTypeReferenceNode('Prism', [dataType, dataType])
437 |       const getPrism = (name: string) => {
438 |         return ts.createCall(ts.createPropertyAccess(ts.createIdentifier('Prism'), 'fromPredicate'), A.empty, [
439 |           getArrowFunction(
440 |             ['s'],
441 |             getStrictEquals(ts.createPropertyAccess(ts.createIdentifier('s'), e.tagName), ts.createStringLiteral(name))
442 |           )
443 |         ])
444 |       }
445 |       const monocleImport = getImportDeclaration(['Prism'], 'monocle-ts')
446 |       const typeParameters: Array<ts.TypeParameterDeclaration> = getDataTypeParameterDeclarations(d)
447 |       const constructors = d.constructors
448 |       if (M.isPolymorphic(d)) {
449 |         return R.of([
450 |           monocleImport,
451 |           ...constructors.map<ts.Node>(c => {
452 |             const body = ts.createBlock([ts.createReturn(getPrism(c.name))])
453 |             return getFunctionDeclaration(`_${getFirstLetterLowerCase(c.name)}`, typeParameters, A.empty, type, body)
454 |           })
455 |         ])
456 |       }
457 |       return R.of([
458 |         monocleImport,
459 |         ...constructors.map(c => {
460 |           return getConstantDeclaration(`_${c.name}`, getPrism(c.name), type)
461 |         })
462 |       ])
463 |     })
464 |   )
465 | }
466 | 
467 | const semigroupBinaryExpression: S.Semigroup<ts.Expression> = {
468 |   concat: (x, y) => ts.createBinary(x, ts.SyntaxKind.AmpersandAmpersandToken, y)
469 | }
470 | 
471 | const getStrictEquals = (left: ts.Expression, right: ts.Expression): ts.BinaryExpression => {
472 |   return ts.createBinary(left, ts.SyntaxKind.EqualsEqualsEqualsToken, right)
473 | }
474 | 
475 | /**
476 |  * @since 0.4.0
477 |  */
478 | export function eq(d: M.Data): AST<Array<ts.Node>> {
479 |   const isSum = M.isSum(d)
480 |   if (!isSum && M.isNullary(head(d.constructors))) {
481 |     return R.of(A.empty)
482 |   }
483 |   const getMemberEqName = (c: M.Constructor, m: M.Member, position: number): string => {
484 |     let s = 'eq'
485 |     if (isSum) {
486 |       s += c.name
487 |     }
488 |     return s + getFirstLetterUpperCase(getMemberName(m, position))
489 |   }
490 |   const constructors = d.constructors
491 |   const eqsParameters = A.array.chain(constructors, c => {
492 |     return c.members
493 |       .map((m, position) => tuple(m, position))
494 |       .filter(([m]) => !M.isRecursiveMember(m, d))
495 |       .map(([m, position]) => {
496 |         const type = ts.createTypeReferenceNode('Eq', [getTypeNode(m.type)])
497 |         return getParameterDeclaration(getMemberEqName(c, m, position), type)
498 |       })
499 |   })
500 |   const getReturnValue = (c: M.Constructor): ts.Expression => {
501 |     return A.foldLeft(
502 |       () => ts.createTrue(),
503 |       () => {
504 |         const callExpressions = c.members.map((m, position) => {
505 |           const eqName = M.isRecursiveMember(m, d) ? 'S' : getMemberEqName(c, m, position)
506 |           const memberName = getMemberName(m, position)
507 |           return ts.createCall(ts.createPropertyAccess(ts.createIdentifier(eqName), 'equals'), A.empty, [
508 |             ts.createPropertyAccess(ts.createIdentifier('x'), memberName),
509 |             ts.createPropertyAccess(ts.createIdentifier('y'), memberName)
510 |           ])
511 |         })
512 |         return S.fold(semigroupBinaryExpression)(callExpressions[0], callExpressions.slice(1))
513 |       }
514 |     )(c.members)
515 |   }
516 |   return pipe(
517 |     R.ask<Options>(),
518 |     R.chain(e => {
519 |       const eqImport = getImportDeclaration(['Eq', 'fromEquals'], 'fp-ts/lib/Eq')
520 |       const ifs = [
521 |         ...constructors.map(c => {
522 |           return ts.createIf(
523 |             semigroupBinaryExpression.concat(
524 |               getStrictEquals(ts.createPropertyAccess(ts.createIdentifier('x'), e.tagName), ts.createLiteral(c.name)),
525 |               getStrictEquals(ts.createPropertyAccess(ts.createIdentifier('y'), e.tagName), ts.createLiteral(c.name))
526 |             ),
527 |             ts.createBlock([ts.createReturn(getReturnValue(c))])
528 |           )
529 |         }),
530 |         ts.createReturn(ts.createFalse())
531 |       ]
532 |       const statements: Array<ts.Statement> = []
533 |       if (isSum) {
534 |         statements.push(...ifs)
535 |       } else {
536 |         statements.push(ts.createReturn(getReturnValue(head(d.constructors))))
537 |       }
538 |       const arrowFunction = getArrowFunction(['x', 'y'], ts.createBlock(statements))
539 |       const eq = ts.createCall(ts.createIdentifier('fromEquals'), A.empty, [arrowFunction])
540 |       const returnType = ts.createTypeReferenceNode('Eq', [getDataType(d)])
541 |       const body = M.isRecursive(d)
542 |         ? [getConstantDeclaration('S', eq, returnType, false), ts.createReturn(ts.createIdentifier('S'))]
543 |         : [ts.createReturn(eq)]
544 |       const typeParameters: Array<ts.TypeParameterDeclaration> = getDataTypeParameterDeclarations(d)
545 |       return R.of([
546 |         eqImport,
547 |         getFunctionDeclaration('getEq', typeParameters, eqsParameters, returnType, ts.createBlock(body))
548 |       ])
549 |     })
550 |   )
551 | }
552 | 


--------------------------------------------------------------------------------
/src/haskell.ts:
--------------------------------------------------------------------------------
  1 | import { parser as P, string as S, char as C } from 'parser-ts'
  2 | import * as M from './model'
  3 | import { Either } from 'fp-ts/lib/Either'
  4 | import { some } from 'fp-ts/lib/Option'
  5 | import { pipe } from 'fp-ts/lib/pipeable'
  6 | import { run } from 'parser-ts/lib/code-frame'
  7 | 
  8 | const isDigit = (c: string): boolean => '0123456789'.indexOf(c) !== -1
  9 | 
 10 | const isPunctuation = (c: string): boolean => '| =\n():,{};[]->'.indexOf(c) !== -1
 11 | 
 12 | const identifierFirstLetter = P.sat<C.Char>(c => !isDigit(c) && !isPunctuation(c))
 13 | 
 14 | const identifierBody = P.sat<C.Char>(c => !isPunctuation(c))
 15 | 
 16 | /**
 17 |  * @since 0.4.0
 18 |  */
 19 | export const identifier: P.Parser<C.Char, string> = P.expected(
 20 |   S.fold([identifierFirstLetter, C.many(identifierBody)]),
 21 |   'an identifier'
 22 | )
 23 | 
 24 | const leftParens: P.Parser<C.Char, string> = S.fold([C.char('('), S.spaces])
 25 | 
 26 | const rightParens: P.Parser<C.Char, string> = S.fold([S.spaces, C.char(')')])
 27 | 
 28 | const withParens = <A>(parser: P.Parser<C.Char, A>): P.Parser<C.Char, A> => {
 29 |   return pipe(
 30 |     leftParens,
 31 |     P.apSecond(parser),
 32 |     P.apFirst(rightParens)
 33 |   )
 34 | }
 35 | 
 36 | const unparametrizedRef: P.Parser<C.Char, M.Type> = pipe(
 37 |   identifier,
 38 |   P.map(name => M.ref(name))
 39 | )
 40 | 
 41 | /**
 42 |  * @since 0.4.0
 43 |  */
 44 | export const ref: P.Parser<C.Char, M.Type> = pipe(
 45 |   identifier,
 46 |   P.chain(name =>
 47 |     pipe(
 48 |       S.spaces,
 49 |       P.apSecond(
 50 |         pipe(
 51 |           types,
 52 |           P.map(parameters => M.ref(name, parameters))
 53 |         )
 54 |       )
 55 |     )
 56 |   )
 57 | )
 58 | 
 59 | const comma = S.fold([S.spaces, C.char(','), S.spaces])
 60 | 
 61 | /**
 62 |  * @since 0.4.0
 63 |  */
 64 | export const tuple: P.Parser<C.Char, M.Type> = P.expected(
 65 |   pipe(
 66 |     leftParens,
 67 |     P.chain(() =>
 68 |       pipe(
 69 |         P.sepBy(comma, type),
 70 |         P.map(types => {
 71 |           switch (types.length) {
 72 |             case 0:
 73 |               return M.unit
 74 |             case 1:
 75 |               return types[0]
 76 |             default:
 77 |               return M.tuple(types)
 78 |           }
 79 |         })
 80 |       )
 81 |     ),
 82 |     P.apFirst(rightParens)
 83 |   ),
 84 |   'a tuple'
 85 | )
 86 | 
 87 | const arrow = S.fold([S.spaces, S.string('->'), S.spaces])
 88 | 
 89 | /**
 90 |  * @since 0.4.0
 91 |  */
 92 | export const fun: P.Parser<C.Char, M.Type> = P.expected(
 93 |   pipe(
 94 |     S.spaces,
 95 |     P.chain(() =>
 96 |       pipe(
 97 |         ref,
 98 |         P.alt(() => tuple),
 99 |         P.chain(domain =>
100 |           pipe(
101 |             arrow,
102 |             P.apSecond(type),
103 |             P.map(codomain => M.fun(domain, codomain))
104 |           )
105 |         )
106 |       )
107 |     )
108 |   ),
109 |   'a function type'
110 | )
111 | 
112 | /**
113 |  * @since 0.4.0
114 |  */
115 | export const type: P.Parser<C.Char, M.Type> = pipe(
116 |   fun,
117 |   P.alt(() => ref),
118 |   P.alt(() => tuple)
119 | )
120 | 
121 | /**
122 |  * @since 0.4.0
123 |  */
124 | export const types: P.Parser<C.Char, Array<M.Type>> = P.sepBy(
125 |   S.spaces,
126 |   pipe(
127 |     fun,
128 |     P.alt(() => unparametrizedRef),
129 |     P.alt(() => withParens(ref)),
130 |     P.alt(() => tuple)
131 |   )
132 | )
133 | 
134 | const pair: P.Parser<C.Char, { name: string; type: M.Type }> = pipe(
135 |   identifier,
136 |   P.chain(name =>
137 |     pipe(
138 |       S.fold([S.spaces, S.string('::'), S.spaces]),
139 |       P.apSecond(type),
140 |       P.map(type => ({ name, type }))
141 |     )
142 |   )
143 | )
144 | 
145 | const pairs: P.Parser<C.Char, Array<{ name: string; type: M.Type }>> = pipe(
146 |   S.fold([C.char('{'), S.spaces]),
147 |   P.apSecond(P.sepBy(comma, pair)),
148 |   P.apFirst(S.fold([S.spaces, C.char('}')]))
149 | )
150 | 
151 | const recordConstructor: P.Parser<C.Char, M.Constructor> = pipe(
152 |   identifier,
153 |   P.chain(name =>
154 |     pipe(
155 |       S.spaces,
156 |       P.apSecond(
157 |         pipe(
158 |           pairs,
159 |           P.map(pairs => M.constructor(name, pairs.map(({ name, type }) => M.member(type, some(name)))))
160 |         )
161 |       )
162 |     )
163 |   )
164 | )
165 | 
166 | const positionalConstructor: P.Parser<C.Char, M.Constructor> = pipe(
167 |   identifier,
168 |   P.chain(name =>
169 |     pipe(
170 |       S.spaces,
171 |       P.apSecond(
172 |         pipe(
173 |           types,
174 |           P.map(types => M.constructor(name, types.map(type => M.member(type))))
175 |         )
176 |       )
177 |     )
178 |   )
179 | )
180 | 
181 | /**
182 |  * @since 0.4.0
183 |  */
184 | export const constructor: P.Parser<C.Char, M.Constructor> = pipe(
185 |   recordConstructor,
186 |   P.alt(() => positionalConstructor)
187 | )
188 | 
189 | const equal = S.fold([S.spaces, C.char('='), S.spaces])
190 | 
191 | const unconstrainedParameterDeclaration: P.Parser<C.Char, M.ParameterDeclaration> = pipe(
192 |   identifier,
193 |   P.map(name => M.parameterDeclaration(name))
194 | )
195 | 
196 | const constrainedParameterDeclaration: P.Parser<C.Char, M.ParameterDeclaration> = pipe(
197 |   S.fold([C.char('('), S.spaces]),
198 |   P.apSecond(
199 |     pipe(
200 |       pair,
201 |       P.map(({ name, type }) => M.parameterDeclaration(name, some(type))),
202 |       P.apFirst(S.fold([S.spaces, C.char(')')]))
203 |     )
204 |   )
205 | )
206 | 
207 | export const parameterDeclaration = P.expected(
208 |   pipe(
209 |     unconstrainedParameterDeclaration,
210 |     P.alt(() => constrainedParameterDeclaration)
211 |   ),
212 |   'a parameter'
213 | )
214 | 
215 | const pipeParser = S.fold([S.spaces, C.char('|'), S.spaces])
216 | 
217 | /**
218 |  * @since 0.4.0
219 |  */
220 | export const data: P.Parser<C.Char, M.Data> = P.expected(
221 |   pipe(
222 |     S.string('data'),
223 |     P.chain(() =>
224 |       pipe(
225 |         S.spaces,
226 |         P.apSecond(
227 |           pipe(
228 |             identifier,
229 |             P.chain(name =>
230 |               pipe(
231 |                 S.spaces,
232 |                 P.apSecond(P.sepBy(S.spaces, parameterDeclaration)),
233 |                 P.apFirst(equal),
234 |                 P.chain(typeParameters =>
235 |                   pipe(
236 |                     P.sepBy1(pipeParser, constructor),
237 |                     P.map(constructors => M.data(name, typeParameters, constructors)),
238 |                     P.apFirst(S.spaces),
239 |                     P.apFirst(P.eof())
240 |                   )
241 |                 )
242 |               )
243 |             )
244 |           )
245 |         )
246 |       )
247 |     )
248 |   ),
249 |   'a data declaration'
250 | )
251 | 
252 | /**
253 |  * @since 0.4.0
254 |  */
255 | export function parse(s: string): Either<string, M.Data> {
256 |   return run(data, s)
257 | }
258 | 


--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
 1 | import * as E from 'fp-ts/lib/Either'
 2 | import { pipe } from 'fp-ts/lib/pipeable'
 3 | import { parse } from './haskell'
 4 | import { print } from './printer'
 5 | import { Options, defaultOptions } from './ast'
 6 | 
 7 | /**
 8 |  * @since 0.4.0
 9 |  */
10 | export function run(input: string, options: Options = defaultOptions): E.Either<string, string> {
11 |   return pipe(
12 |     parse(input),
13 |     E.map(print(options))
14 |   )
15 | }
16 | 


--------------------------------------------------------------------------------
/src/model.ts:
--------------------------------------------------------------------------------
  1 | import { NonEmptyArray } from 'fp-ts/lib/NonEmptyArray'
  2 | import { none, Option } from 'fp-ts/lib/Option'
  3 | 
  4 | /**
  5 |  * @since 0.4.0
  6 |  */
  7 | export type Identifier = string
  8 | 
  9 | /**
 10 |  * @since 0.4.0
 11 |  */
 12 | export interface Ref {
 13 |   readonly kind: 'Ref'
 14 |   readonly name: Identifier
 15 |   readonly parameters: Array<Type>
 16 | }
 17 | 
 18 | /**
 19 |  * @since 0.4.0
 20 |  */
 21 | export interface Tuple {
 22 |   readonly kind: 'Tuple'
 23 |   readonly types: Array<Type>
 24 | }
 25 | 
 26 | /**
 27 |  * @since 0.4.0
 28 |  */
 29 | export interface Fun {
 30 |   readonly kind: 'Fun'
 31 |   readonly domain: Type
 32 |   readonly codomain: Type
 33 | }
 34 | 
 35 | /**
 36 |  * @since 0.4.0
 37 |  */
 38 | export interface Unit {
 39 |   readonly kind: 'Unit'
 40 | }
 41 | 
 42 | /**
 43 |  * @since 0.4.0
 44 |  */
 45 | export type Type = Ref | Tuple | Fun | Unit
 46 | 
 47 | /**
 48 |  * @since 0.4.0
 49 |  */
 50 | export interface Member {
 51 |   readonly type: Type
 52 |   readonly name: Option<Identifier>
 53 | }
 54 | 
 55 | /**
 56 |  * @since 0.4.0
 57 |  */
 58 | export interface Constructor {
 59 |   readonly name: Identifier
 60 |   readonly members: Array<Member>
 61 | }
 62 | 
 63 | /**
 64 |  * @since 0.4.0
 65 |  */
 66 | export interface ParameterDeclaration {
 67 |   readonly name: Identifier
 68 |   readonly constraint: Option<Type>
 69 | }
 70 | 
 71 | /**
 72 |  * @since 0.4.0
 73 |  */
 74 | export interface Data {
 75 |   readonly name: Identifier
 76 |   readonly parameterDeclarations: Array<ParameterDeclaration>
 77 |   readonly constructors: NonEmptyArray<Constructor>
 78 | }
 79 | 
 80 | /**
 81 |  * @since 0.4.0
 82 |  */
 83 | export function ref(name: Identifier, parameters: Array<Type> = []): Type {
 84 |   return {
 85 |     kind: 'Ref',
 86 |     name,
 87 |     parameters
 88 |   }
 89 | }
 90 | 
 91 | /**
 92 |  * @since 0.4.0
 93 |  */
 94 | export function tuple(types: Array<Type>): Type {
 95 |   return {
 96 |     kind: 'Tuple',
 97 |     types
 98 |   }
 99 | }
100 | 
101 | /**
102 |  * @since 0.4.0
103 |  */
104 | export const unit: Type = { kind: 'Unit' }
105 | 
106 | /**
107 |  * @since 0.4.0
108 |  */
109 | export function fun(domain: Type, codomain: Type): Type {
110 |   return {
111 |     kind: 'Fun',
112 |     domain,
113 |     codomain
114 |   }
115 | }
116 | 
117 | /**
118 |  * @since 0.4.0
119 |  */
120 | export function member(type: Type, name: Option<Identifier> = none): Member {
121 |   return {
122 |     type,
123 |     name
124 |   }
125 | }
126 | 
127 | /**
128 |  * @since 0.4.0
129 |  */
130 | export function constructor(name: Identifier, members: Array<Member> = []): Constructor {
131 |   return {
132 |     name,
133 |     members
134 |   }
135 | }
136 | 
137 | /**
138 |  * @since 0.4.0
139 |  */
140 | export function parameterDeclaration(name: Identifier, constraint: Option<Type> = none): ParameterDeclaration {
141 |   return {
142 |     name,
143 |     constraint
144 |   }
145 | }
146 | 
147 | /**
148 |  * @since 0.4.0
149 |  */
150 | export function data(
151 |   name: Identifier,
152 |   parameterDeclarations: Array<ParameterDeclaration>,
153 |   constructors: NonEmptyArray<Constructor>
154 | ): Data {
155 |   return {
156 |     name,
157 |     parameterDeclarations,
158 |     constructors
159 |   }
160 | }
161 | 
162 | /**
163 |  * @since 0.4.0
164 |  */
165 | export function isNullary(c: Constructor): boolean {
166 |   return c.members.length === 0
167 | }
168 | 
169 | /**
170 |  * @since 0.4.0
171 |  */
172 | export function isPolymorphic(d: Data): boolean {
173 |   return d.parameterDeclarations.length > 0
174 | }
175 | 
176 | /**
177 |  * @since 0.4.0
178 |  */
179 | export function isSum(d: Data): boolean {
180 |   return d.constructors.length > 1
181 | }
182 | 
183 | /**
184 |  * @since 0.4.0
185 |  */
186 | export function isEnum(d: Data): boolean {
187 |   return d.constructors.every(isNullary)
188 | }
189 | 
190 | /**
191 |  * @since 0.4.0
192 |  */
193 | export function isRecursiveMember(m: Member, d: Data): boolean {
194 |   return m.type.kind === 'Ref' && m.type.name === d.name
195 | }
196 | 
197 | /**
198 |  * @since 0.4.0
199 |  */
200 | export function isRecursive(d: Data): boolean {
201 |   return d.constructors.some(c => c.members.some(m => isRecursiveMember(m, d)))
202 | }
203 | 


--------------------------------------------------------------------------------
/src/printer.ts:
--------------------------------------------------------------------------------
  1 | import * as ts from 'typescript'
  2 | import * as Ast from './ast'
  3 | import * as M from './model'
  4 | import * as R from 'fp-ts/lib/Reader'
  5 | import * as Mon from 'fp-ts/lib/Monoid'
  6 | import * as A from 'fp-ts/lib/Array'
  7 | import * as O from 'fp-ts/lib/Option'
  8 | import { pipe } from 'fp-ts/lib/pipeable'
  9 | 
 10 | /**
 11 |  * @since 0.4.0
 12 |  */
 13 | export interface Printer<A> extends R.Reader<Ast.Options, A> {}
 14 | 
 15 | /**
 16 |  * @since 0.4.0
 17 |  */
 18 | export function ast(ast: ts.Node): string {
 19 |   const printer = ts.createPrinter({
 20 |     newLine: ts.NewLineKind.LineFeed
 21 |   })
 22 |   const source = ts.createSourceFile('', '', ts.ScriptTarget.Latest)
 23 |   return printer.printNode(ts.EmitHint.Unspecified, ast, source)
 24 | }
 25 | 
 26 | /**
 27 |  * @since 0.4.0
 28 |  */
 29 | export function data(d: M.Data): Printer<string> {
 30 |   return pipe(
 31 |     Ast.data(d),
 32 |     R.map(declarations => declarations.map(ast).join('\n\n'))
 33 |   )
 34 | }
 35 | 
 36 | /**
 37 |  * @since 0.4.0
 38 |  */
 39 | export function constructors(d: M.Data): Printer<Array<string>> {
 40 |   return pipe(
 41 |     Ast.constructors(d),
 42 |     R.map(nodes => nodes.map(ast))
 43 |   )
 44 | }
 45 | 
 46 | /**
 47 |  * @since 0.4.0
 48 |  */
 49 | export function fold(d: M.Data): Printer<string> {
 50 |   return pipe(
 51 |     Ast.fold(d),
 52 |     R.map(functionDeclaration =>
 53 |       pipe(
 54 |         functionDeclaration,
 55 |         O.map(ast),
 56 |         O.getOrElse(() => '')
 57 |       )
 58 |     )
 59 |   )
 60 | }
 61 | 
 62 | /**
 63 |  * @since 0.4.0
 64 |  */
 65 | export function prisms(d: M.Data): Printer<Array<string>> {
 66 |   return pipe(
 67 |     Ast.prisms(d),
 68 |     R.map(nodes => nodes.map(ast))
 69 |   )
 70 | }
 71 | 
 72 | /**
 73 |  * @since 0.4.0
 74 |  */
 75 | export function eq(d: M.Data): Printer<Array<string>> {
 76 |   return pipe(
 77 |     Ast.eq(d),
 78 |     R.map(nodes => nodes.map(ast))
 79 |   )
 80 | }
 81 | 
 82 | /**
 83 |  * @since 0.4.0
 84 |  */
 85 | export function getMonoid<A>(M: Mon.Monoid<A>): Mon.Monoid<Printer<A>> {
 86 |   return {
 87 |     concat: (x, y) => e => M.concat(x(e), y(e)),
 88 |     empty: R.of(M.empty)
 89 |   }
 90 | }
 91 | 
 92 | const monoidPrinter: Mon.Monoid<Printer<Array<string>>> = getMonoid(A.getMonoid<string>())
 93 | 
 94 | /**
 95 |  * @since 0.4.0
 96 |  */
 97 | export function all(d: M.Data): Printer<Array<string>> {
 98 |   return Mon.fold(monoidPrinter)([
 99 |     pipe(
100 |       data(d),
101 |       R.map(A.array.of)
102 |     ),
103 |     constructors(d),
104 |     pipe(
105 |       fold(d),
106 |       R.map(s => [s])
107 |     ),
108 |     prisms(d),
109 |     eq(d)
110 |   ])
111 | }
112 | 
113 | /**
114 |  * @since 0.4.0
115 |  */
116 | export function print(options: Ast.Options): (d: M.Data) => string {
117 |   return d => all(d)(options).join('\n\n')
118 | }
119 | 


--------------------------------------------------------------------------------
/test/examples.ts:
--------------------------------------------------------------------------------
  1 | import * as M from '../src/model'
  2 | import { some } from 'fp-ts/lib/Option'
  3 | 
  4 | // data Option A = None | Some A
  5 | export const Option = M.data(
  6 |   'Option',
  7 |   [M.parameterDeclaration('A')],
  8 |   [M.constructor('None'), M.constructor('Some', [M.member(M.ref('A'))])]
  9 | )
 10 | 
 11 | // data Maybe A = Nothing | Just { value :: A }
 12 | export const Maybe = M.data(
 13 |   'Maybe',
 14 |   [M.parameterDeclaration('A')],
 15 |   [M.constructor('Nothing'), M.constructor('Just', [M.member(M.ref('A'), some('value'))])]
 16 | )
 17 | 
 18 | // data Either L R = Left L | Right R
 19 | export const Either = M.data(
 20 |   'Either',
 21 |   [M.parameterDeclaration('E'), M.parameterDeclaration('R')],
 22 |   [M.constructor('Left', [M.member(M.ref('E'))]), M.constructor('Right', [M.member(M.ref('R'))])]
 23 | )
 24 | 
 25 | // data These A B = Left { left :: A } | Right { right :: B } | Both { left :: A, right :: B }
 26 | export const These = M.data(
 27 |   'These',
 28 |   [M.parameterDeclaration('A'), M.parameterDeclaration('B')],
 29 |   [
 30 |     M.constructor('Left', [M.member(M.ref('A'), some('left'))]),
 31 |     M.constructor('Right', [M.member(M.ref('B'), some('right'))]),
 32 |     M.constructor('Both', [M.member(M.ref('A'), some('left')), M.member(M.ref('B'), some('right'))])
 33 |   ]
 34 | )
 35 | 
 36 | // data Tree A = Leaf | Node (Tree A) A (Tree A)
 37 | export const Tree = M.data(
 38 |   'Tree',
 39 |   [M.parameterDeclaration('A')],
 40 |   [
 41 |     M.constructor('Leaf'),
 42 |     M.constructor('Node', [
 43 |       M.member(M.ref('Tree', [M.ref('A')])),
 44 |       M.member(M.ref('A')),
 45 |       M.member(M.ref('Tree', [M.ref('A')]))
 46 |     ])
 47 |   ]
 48 | )
 49 | 
 50 | // data FooBarBaz = Foo | Bar | Baz
 51 | export const FooBarBaz = M.data('FooBarBaz', [], [M.constructor('Foo'), M.constructor('Bar'), M.constructor('Baz')])
 52 | 
 53 | // data User = User { name :: string, surname :: string, age :: number }
 54 | export const User = M.data(
 55 |   'User',
 56 |   [],
 57 |   [
 58 |     M.constructor('User', [
 59 |       M.member(M.ref('string'), some('name')),
 60 |       M.member(M.ref('string'), some('surname')),
 61 |       M.member(M.ref('number'), some('age'))
 62 |     ])
 63 |   ]
 64 | )
 65 | 
 66 | // data Constrained (A :: string) = Fetching | GotData A
 67 | export const Constrained = M.data(
 68 |   'Constrained',
 69 |   [M.parameterDeclaration('A', some(M.ref('string')))],
 70 |   [M.constructor('Fetching'), M.constructor('GotData', [M.member(M.ref('A'))])]
 71 | )
 72 | 
 73 | // data Tuple2 A B = Tuple2 (A, B)
 74 | export const Tuple2 = M.data(
 75 |   'Tuple2',
 76 |   [M.parameterDeclaration('A'), M.parameterDeclaration('B')],
 77 |   [M.constructor('Tuple2', [M.member(M.tuple([M.ref('A'), M.ref('B')]))])]
 78 | )
 79 | 
 80 | // data State S A = State S -> (A, S)
 81 | export const State = M.data(
 82 |   'State',
 83 |   [M.parameterDeclaration('S'), M.parameterDeclaration('A')],
 84 |   [M.constructor('State', [M.member(M.fun(M.ref('S'), M.tuple([M.ref('A'), M.ref('S')])))])]
 85 | )
 86 | 
 87 | // data Writer W A = Writer () -> (A, W)
 88 | export const Writer = M.data(
 89 |   'Writer',
 90 |   [M.parameterDeclaration('W'), M.parameterDeclaration('A')],
 91 |   [M.constructor('Writer', [M.member(M.fun(M.unit, M.tuple([M.ref('A'), M.ref('W')])))])]
 92 | )
 93 | 
 94 | // data Nullary = Nullary
 95 | export const Nullary = M.data('Nullary', [], [M.constructor('Nullary')])
 96 | 
 97 | // data NotAlignedNames = Ctor string
 98 | export const NotAlignedNames = M.data(
 99 |   'NotAlignedNames',
100 |   [],
101 |   [M.constructor('Ctor', [M.member(M.ref('string'), some('value'))])]
102 | )
103 | 


--------------------------------------------------------------------------------
/test/haskell.ts:
--------------------------------------------------------------------------------
  1 | import * as assert from 'assert'
  2 | import { parser, char as C, stream } from 'parser-ts'
  3 | import * as P from '../src/haskell'
  4 | import * as M from '../src/model'
  5 | import * as E from './examples'
  6 | import { right, left, isRight, isLeft } from 'fp-ts/lib/Either'
  7 | import { some } from 'fp-ts/lib/Option'
  8 | import { head } from 'fp-ts/lib/NonEmptyArray'
  9 | 
 10 | const assertSuccess = <A>(parser: parser.Parser<C.Char, A>, input: string, expected: A) => {
 11 |   const result = parser(stream.stream(input.split('')))
 12 |   if (isRight(result)) {
 13 |     assert.deepStrictEqual(result.right.value, expected)
 14 |   } else {
 15 |     throw new Error(`${result} is not a right`)
 16 |   }
 17 | }
 18 | 
 19 | const assertFailure = <A>(parser: parser.Parser<C.Char, A>, input: string, expected: string) => {
 20 |   const result = parser(stream.stream(input.split('')))
 21 |   if (isLeft(result)) {
 22 |     assert.deepStrictEqual(result.left.expected.join(', '), expected)
 23 |   } else {
 24 |     throw new Error(`${result} is not a left`)
 25 |   }
 26 | }
 27 | 
 28 | describe('Haskell parser', () => {
 29 |   it('identifier', () => {
 30 |     const parser = P.identifier
 31 |     assertSuccess(parser, 'a', 'a')
 32 |     assertSuccess(parser, 'a1', 'a1')
 33 |     assertSuccess(parser, 'a\n', 'a')
 34 |     assertSuccess(parser, 'a:b', 'a')
 35 |     assertFailure(parser, '', 'an identifier')
 36 |     assertFailure(parser, '1', 'an identifier')
 37 |   })
 38 | 
 39 |   it('parameterDeclaration', () => {
 40 |     const parser = P.parameterDeclaration
 41 |     assertSuccess(parser, 'A', M.parameterDeclaration('A'))
 42 |     assertSuccess(parser, '(A :: string)', M.parameterDeclaration('A', some(M.ref('string'))))
 43 |     assertSuccess(parser, '( A :: string )', M.parameterDeclaration('A', some(M.ref('string'))))
 44 |     assertFailure(parser, '(A)', 'a parameter')
 45 |     assertFailure(parser, '(A :: )', 'a parameter')
 46 |   })
 47 | 
 48 |   it('tuple', () => {
 49 |     const parser = P.tuple
 50 |     assertSuccess(parser, '(A, B)', M.tuple([M.ref('A'), M.ref('B')]))
 51 |     assertSuccess(parser, '()', M.unit)
 52 |     assertSuccess(parser, '(A)', M.ref('A'))
 53 |     assertFailure(parser, '(A,)', 'a tuple')
 54 |   })
 55 | 
 56 |   it('functionType', () => {
 57 |     const parser = P.fun
 58 |     assertSuccess(parser, 'A -> B', M.fun(M.ref('A'), M.ref('B')))
 59 |     assertSuccess(parser, 'A -> B -> C', M.fun(M.ref('A'), M.fun(M.ref('B'), M.ref('C'))))
 60 |     assertSuccess(parser, '(A -> B) -> C', M.fun(M.fun(M.ref('A'), M.ref('B')), M.ref('C')))
 61 |     assertFailure(parser, 'A -> ', 'a function type')
 62 |   })
 63 | 
 64 |   it('type', () => {
 65 |     const parser = P.type
 66 |     // type references
 67 |     assertSuccess(parser, 'T', M.ref('T'))
 68 |     assertSuccess(parser, 'T A', M.ref('T', [M.ref('A')]))
 69 |     assertSuccess(parser, 'T A B', M.ref('T', [M.ref('A'), M.ref('B')]))
 70 |     assertSuccess(parser, 'T ', M.ref('T'))
 71 |     assertSuccess(parser, 'T1', M.ref('T1'))
 72 |     assertSuccess(parser, 'T\n', M.ref('T'))
 73 |     assertSuccess(parser, 'T (A)', M.ref('T', [M.ref('A')]))
 74 |     assertSuccess(parser, 'T A (B)', M.ref('T', [M.ref('A'), M.ref('B')]))
 75 |     assertSuccess(parser, 'T (A B)', M.ref('T', [M.ref('A', [M.ref('B')])]))
 76 |     // tuples
 77 |     assertSuccess(parser, '(A, B)', M.tuple([M.ref('A'), M.ref('B')]))
 78 |     assertSuccess(parser, '(A, B, C)', M.tuple([M.ref('A'), M.ref('B'), M.ref('C')]))
 79 |     assertSuccess(parser, '(A, B, C D)', M.tuple([M.ref('A'), M.ref('B'), M.ref('C', [M.ref('D')])]))
 80 |     assertSuccess(parser, 'T (A, B)', M.ref('T', [M.tuple([M.ref('A'), M.ref('B')])]))
 81 |     // functions
 82 |     assertSuccess(parser, 'A -> B', M.fun(M.ref('A'), M.ref('B')))
 83 |     assertSuccess(parser, '(A, B) -> C', M.fun(M.tuple([M.ref('A'), M.ref('B')]), M.ref('C')))
 84 |     assertSuccess(parser, 'A -> (B, C)', M.fun(M.ref('A'), M.tuple([M.ref('B'), M.ref('C')])))
 85 |     assertSuccess(parser, 'T A -> B', M.ref('T', [M.fun(M.ref('A'), M.ref('B'))]))
 86 |     assertSuccess(parser, 'A -> B -> C', M.fun(M.ref('A'), M.fun(M.ref('B'), M.ref('C'))))
 87 |     assertSuccess(parser, '(A -> B) -> C', M.fun(M.fun(M.ref('A'), M.ref('B')), M.ref('C')))
 88 |   })
 89 | 
 90 |   it('type with parens', () => {
 91 |     const parser = P.type
 92 |     // type references
 93 |     assertSuccess(parser, '(T)', M.ref('T'))
 94 |     assertSuccess(parser, '( T )', M.ref('T'))
 95 |     // tuples
 96 |     // functions
 97 |     assertSuccess(parser, '(A -> B)', M.fun(M.ref('A'), M.ref('B')))
 98 |     assertSuccess(parser, 'T (A -> B)', M.ref('T', [M.fun(M.ref('A'), M.ref('B'))]))
 99 |     assertSuccess(parser, 'A -> (B -> C)', M.fun(M.ref('A'), M.fun(M.ref('B'), M.ref('C'))))
100 |   })
101 | 
102 |   it('constructor', () => {
103 |     const parser = P.constructor
104 |     // type references
105 |     assertSuccess(parser, 'None', head(E.Option.constructors))
106 |     assertSuccess(parser, 'Some A', E.Option.constructors[1])
107 |     assertSuccess(parser, 'Some (A)', E.Option.constructors[1])
108 |     assertSuccess(parser, 'T A B', M.constructor('T', [M.member(M.ref('A')), M.member(M.ref('B'))]))
109 |     assertSuccess(parser, 'T (A) B', M.constructor('T', [M.member(M.ref('A')), M.member(M.ref('B'))]))
110 |     assertSuccess(parser, 'T (A B)', M.constructor('T', [M.member(M.ref('A', [M.ref('B')]))]))
111 |     assertSuccess(parser, 'Node (Tree A) A (Tree A)', E.Tree.constructors[1])
112 |     assertSuccess(parser, 'User { name :: string, surname :: string, age :: number }', head(E.User.constructors))
113 |     // tuples
114 |     assertSuccess(parser, 'Tuple2 (A, B)', head(E.Tuple2.constructors))
115 |     // functions
116 |     assertSuccess(parser, 'State S -> (A, S)', head(E.State.constructors))
117 |   })
118 | 
119 |   it('data', () => {
120 |     const parser = P.data
121 |     // type references
122 |     assertSuccess(parser, 'data Option A = None | Some A', E.Option)
123 |     assertSuccess(parser, 'data Either E R = Left E | Right R', E.Either)
124 |     assertSuccess(parser, 'data Tree A = Leaf | Node (Tree A) A (Tree A)', E.Tree)
125 |     assertSuccess(parser, 'data User = User { name :: string, surname :: string, age :: number }', E.User)
126 |     // tuples
127 |     assertSuccess(parser, 'data Tuple2 A B = Tuple2 (A, B)', E.Tuple2)
128 |     assertFailure(
129 |       parser,
130 |       'data User = User { name :: string, age :: number, tags :: [number, number] }',
131 |       'a data declaration'
132 |     )
133 |     // functions
134 |     assertSuccess(parser, 'data State S A = State S -> (A, S)', E.State)
135 |   })
136 | 
137 |   it('parse', () => {
138 |     assert.deepStrictEqual(P.parse('data Option A = None | Some A'), right(E.Option))
139 |     assert.deepStrictEqual(
140 |       P.parse('data Option A = '),
141 |       left(
142 |         `> 1 | data Option A = ` +
143 |           `
144 |     |                 ^ Expected: a data declaration`
145 |       )
146 |     )
147 |   })
148 | })
149 | 


--------------------------------------------------------------------------------
/test/helpers.ts:
--------------------------------------------------------------------------------
 1 | import * as assert from 'assert'
 2 | import { defaultOptions, Options } from '../src/ast'
 3 | import * as P from '../src/printer'
 4 | 
 5 | export const assertPrinterEqual = <A, B>(
 6 |   f: (a: A) => P.Printer<B>,
 7 |   a: A,
 8 |   expected: B,
 9 |   options: Options = defaultOptions
10 | ) => {
11 |   const actual = f(a)(options)
12 |   assert.deepStrictEqual(actual, expected)
13 | }
14 | 


--------------------------------------------------------------------------------
/test/index.ts:
--------------------------------------------------------------------------------
 1 | import * as assert from 'assert'
 2 | import { run } from '../src'
 3 | import { defaultOptions } from '../src/ast'
 4 | 
 5 | describe('index', () => {
 6 |   it('run', () => {
 7 |     const s1 = run('data Option A = None | Some A', defaultOptions)
 8 |     const s2 = run('data Option A = None | Some A')
 9 |     assert.deepStrictEqual(s1, s2)
10 |   })
11 | })
12 | 


--------------------------------------------------------------------------------
/test/model.ts:
--------------------------------------------------------------------------------
 1 | import * as assert from 'assert'
 2 | import { isEnum } from '../src/model'
 3 | import * as E from './examples'
 4 | 
 5 | describe('model', () => {
 6 |   it('isEnum', () => {
 7 |     assert.strictEqual(isEnum(E.FooBarBaz), true)
 8 |     assert.strictEqual(isEnum(E.Option), false)
 9 |   })
10 | })
11 | 


--------------------------------------------------------------------------------
/test/printer.ts:
--------------------------------------------------------------------------------
  1 | import * as assert from 'assert'
  2 | import * as M from '../src/model'
  3 | import * as P from '../src/printer'
  4 | import * as E from './examples'
  5 | import { assertPrinterEqual } from './helpers'
  6 | import { defaultOptions, lenses } from '../src/ast'
  7 | 
  8 | describe('printer', () => {
  9 |   describe('literal encoding', () => {
 10 |     describe('data', () => {
 11 |       it('positional fields', () => {
 12 |         assertPrinterEqual(
 13 |           P.data,
 14 |           E.Option,
 15 |           `export type Option<A> = {
 16 |     readonly type: "None";
 17 | } | {
 18 |     readonly type: "Some";
 19 |     readonly value0: A;
 20 | };`
 21 |         )
 22 |         assertPrinterEqual(
 23 |           P.data,
 24 |           E.Either,
 25 |           `export type Either<E, R> = {
 26 |     readonly type: "Left";
 27 |     readonly value0: E;
 28 | } | {
 29 |     readonly type: "Right";
 30 |     readonly value0: R;
 31 | };`
 32 |         )
 33 |         assertPrinterEqual(
 34 |           P.data,
 35 |           E.Tree,
 36 |           `export type Tree<A> = {
 37 |     readonly type: "Leaf";
 38 | } | {
 39 |     readonly type: "Node";
 40 |     readonly value0: Tree<A>;
 41 |     readonly value1: A;
 42 |     readonly value2: Tree<A>;
 43 | };`
 44 |         )
 45 |       })
 46 | 
 47 |       it('record fields', () => {
 48 |         assertPrinterEqual(
 49 |           P.data,
 50 |           E.Maybe,
 51 |           `export type Maybe<A> = {
 52 |     readonly type: "Nothing";
 53 | } | {
 54 |     readonly type: "Just";
 55 |     readonly value: A;
 56 | };`
 57 |         )
 58 |       })
 59 | 
 60 |       it('constrained data', () => {
 61 |         assertPrinterEqual(
 62 |           P.data,
 63 |           E.Constrained,
 64 |           `export type Constrained<A extends string> = {
 65 |     readonly type: "Fetching";
 66 | } | {
 67 |     readonly type: "GotData";
 68 |     readonly value0: A;
 69 | };`
 70 |         )
 71 |       })
 72 | 
 73 |       it('tuple domain', () => {
 74 |         const data = M.data(
 75 |           'Tuple',
 76 |           [],
 77 |           [M.constructor('Tuple', [M.member(M.fun(M.tuple([M.ref('A'), M.ref('B')]), M.ref('C')))])]
 78 |         )
 79 |         assertPrinterEqual(
 80 |           P.data,
 81 |           data,
 82 |           `export type Tuple = {
 83 |     readonly value0: (tuple: [A, B]) => C;
 84 | };`
 85 |         )
 86 |       })
 87 | 
 88 |       it('function domain', () => {
 89 |         const data = M.data(
 90 |           'Function',
 91 |           [],
 92 |           [M.constructor('Function', [M.member(M.fun(M.fun(M.ref('A'), M.ref('B')), M.ref('C')))])]
 93 |         )
 94 |         assertPrinterEqual(
 95 |           P.data,
 96 |           data,
 97 |           `export type Function = {
 98 |     readonly value0: (f: (a: A) => B) => C;
 99 | };`
100 |         )
101 |       })
102 | 
103 |       it('tuple field', () => {
104 |         assertPrinterEqual(
105 |           P.data,
106 |           E.Tuple2,
107 |           `export type Tuple2<A, B> = {
108 |     readonly value0: [A, B];
109 | };`
110 |         )
111 |       })
112 | 
113 |       it('unit field', () => {
114 |         const data = M.data('Unit', [], [M.constructor('Unit', [M.member(M.unit)])])
115 |         assertPrinterEqual(
116 |           P.data,
117 |           data,
118 |           `export type Unit = {
119 |     readonly value0: undefined;
120 | };`
121 |         )
122 |       })
123 | 
124 |       it('function fields', () => {
125 |         assertPrinterEqual(
126 |           P.data,
127 |           E.Writer,
128 |           `export type Writer<W, A> = {
129 |     readonly value0: () => [A, W];
130 | };`
131 |         )
132 |         assertPrinterEqual(
133 |           P.data,
134 |           E.State,
135 |           `export type State<S, A> = {
136 |     readonly value0: (s: S) => [A, S];
137 | };`
138 |         )
139 |       })
140 | 
141 |       it('should handle only one constructor', () => {
142 |         assertPrinterEqual(
143 |           P.data,
144 |           E.User,
145 |           `export type User = {
146 |     readonly name: string;
147 |     readonly surname: string;
148 |     readonly age: number;
149 | };`
150 |         )
151 |       })
152 | 
153 |       it('should handle nullary constructors', () => {
154 |         assertPrinterEqual(
155 |           P.data,
156 |           E.FooBarBaz,
157 |           `export type FooBarBaz = {
158 |     readonly type: "Foo";
159 | } | {
160 |     readonly type: "Bar";
161 | } | {
162 |     readonly type: "Baz";
163 | };`
164 |         )
165 |       })
166 |     })
167 | 
168 |     describe('constructors', () => {
169 |       it('positional fields', () => {
170 |         assertPrinterEqual(P.constructors, E.Option, [
171 |           'export const none: Option<never> = { type: "None" };',
172 |           'export function some<A>(value0: A): Option<A> { return { type: "Some", value0 }; }'
173 |         ])
174 |         assertPrinterEqual(P.constructors, E.Either, [
175 |           'export function left<E, R>(value0: E): Either<E, R> { return { type: "Left", value0 }; }',
176 |           'export function right<E, R>(value0: R): Either<E, R> { return { type: "Right", value0 }; }'
177 |         ])
178 |         assertPrinterEqual(P.constructors, E.Tree, [
179 |           'export const leaf: Tree<never> = { type: "Leaf" };',
180 |           'export function node<A>(value0: Tree<A>, value1: A, value2: Tree<A>): Tree<A> { return { type: "Node", value0, value1, value2 }; }'
181 |         ])
182 |       })
183 | 
184 |       it('record fields', () => {
185 |         assertPrinterEqual(P.constructors, E.Maybe, [
186 |           'export const nothing: Maybe<never> = { type: "Nothing" };',
187 |           'export function just<A>(value: A): Maybe<A> { return { type: "Just", value }; }'
188 |         ])
189 |       })
190 | 
191 |       it('nullary constructors', () => {
192 |         assertPrinterEqual(P.constructors, E.FooBarBaz, [
193 |           'export const foo: FooBarBaz = { type: "Foo" };',
194 |           'export const bar: FooBarBaz = { type: "Bar" };',
195 |           'export const baz: FooBarBaz = { type: "Baz" };'
196 |         ])
197 |       })
198 | 
199 |       it('monomorphic constructors', () => {
200 |         assertPrinterEqual(P.constructors, E.User, [
201 |           'export function user(name: string, surname: string, age: number): User { return { name, surname, age }; }'
202 |         ])
203 |       })
204 | 
205 |       it('monomorphic nullary constructor', () => {
206 |         assertPrinterEqual(P.constructors, E.Nullary, ['export const nullary: Nullary = {};'])
207 |       })
208 | 
209 |       it('constrained data', () => {
210 |         assertPrinterEqual(P.constructors, E.Constrained, [
211 |           'export const fetching: Constrained<string> = { type: "Fetching" };',
212 |           'export function gotData<A extends string>(value0: A): Constrained<A> { return { type: "GotData", value0 }; }'
213 |         ])
214 |       })
215 |     })
216 |   })
217 | 
218 |   describe('fold', () => {
219 |     it('positional fields', () => {
220 |       assertPrinterEqual(
221 |         P.fold,
222 |         E.Option,
223 |         'export function fold<A, R>(onNone: () => R, onSome: (value0: A) => R): (fa: Option<A>) => R { return fa => { switch (fa.type) {\n    case "None": return onNone();\n    case "Some": return onSome(fa.value0);\n} }; }'
224 |       )
225 |     })
226 | 
227 |     it('record fields', () => {
228 |       assertPrinterEqual(
229 |         P.fold,
230 |         E.Maybe,
231 |         'export function fold<A, R>(onNothing: () => R, onJust: (value: A) => R): (fa: Maybe<A>) => R { return fa => { switch (fa.type) {\n    case "Nothing": return onNothing();\n    case "Just": return onJust(fa.value);\n} }; }'
232 |       )
233 |     })
234 | 
235 |     it('should not emit a fold if data is not a sum type', () => {
236 |       assertPrinterEqual(P.fold, E.User, '')
237 |     })
238 | 
239 |     it('should choose a good return type parameter', () => {
240 |       assertPrinterEqual(
241 |         P.fold,
242 |         E.Either,
243 |         'export function fold<E, R, R1>(onLeft: (value0: E) => R1, onRight: (value0: R) => R1): (fa: Either<E, R>) => R1 { return fa => { switch (fa.type) {\n    case "Left": return onLeft(fa.value0);\n    case "Right": return onRight(fa.value0);\n} }; }'
244 |       )
245 |     })
246 | 
247 |     it('should handle monomorphic data', () => {
248 |       assertPrinterEqual(
249 |         P.fold,
250 |         E.FooBarBaz,
251 |         'export function fold<R>(onFoo: () => R, onBar: () => R, onBaz: () => R): (fa: FooBarBaz) => R { return fa => { switch (fa.type) {\n    case "Foo": return onFoo();\n    case "Bar": return onBar();\n    case "Baz": return onBaz();\n} }; }'
252 |       )
253 |     })
254 |   })
255 | 
256 |   describe('prisms', () => {
257 |     it('should handle non sum types', () => {
258 |       assertPrinterEqual(P.prisms, E.User, [])
259 |     })
260 | 
261 |     it('should handle monomorphic data', () => {
262 |       assertPrinterEqual(P.prisms, E.FooBarBaz, [
263 |         'import { Prism } from "monocle-ts";',
264 |         'export const _Foo: Prism<FooBarBaz, FooBarBaz> = Prism.fromPredicate(s => s.type === "Foo");',
265 |         'export const _Bar: Prism<FooBarBaz, FooBarBaz> = Prism.fromPredicate(s => s.type === "Bar");',
266 |         'export const _Baz: Prism<FooBarBaz, FooBarBaz> = Prism.fromPredicate(s => s.type === "Baz");'
267 |       ])
268 |     })
269 |   })
270 | 
271 |   describe('eq', () => {
272 |     it('should handle monomorphic data', () => {
273 |       assertPrinterEqual(P.eq, E.FooBarBaz, [
274 |         'import { Eq, fromEquals } from "fp-ts/lib/Eq";',
275 |         'export function getEq(): Eq<FooBarBaz> { return fromEquals((x, y) => { if (x.type === "Foo" && y.type === "Foo") {\n    return true;\n} if (x.type === "Bar" && y.type === "Bar") {\n    return true;\n} if (x.type === "Baz" && y.type === "Baz") {\n    return true;\n} return false; }); }'
276 |       ])
277 |     })
278 | 
279 |     it('should handle monomorphic nullary', () => {
280 |       assertPrinterEqual(P.eq, E.Nullary, [])
281 |     })
282 | 
283 |     it('should handle non sum types', () => {
284 |       assertPrinterEqual(P.eq, E.User, [
285 |         'import { Eq, fromEquals } from "fp-ts/lib/Eq";',
286 |         'export function getEq(eqName: Eq<string>, eqSurname: Eq<string>, eqAge: Eq<number>): Eq<User> { return fromEquals((x, y) => { return eqName.equals(x.name, y.name) && eqSurname.equals(x.surname, y.surname) && eqAge.equals(x.age, y.age); }); }'
287 |       ])
288 |     })
289 | 
290 |     it('should handle recursive data structures', () => {
291 |       assertPrinterEqual(P.eq, E.Tree, [
292 |         'import { Eq, fromEquals } from "fp-ts/lib/Eq";',
293 |         'export function getEq<A>(eqNodeValue1: Eq<A>): Eq<Tree<A>> { const S: Eq<Tree<A>> = fromEquals((x, y) => { if (x.type === "Leaf" && y.type === "Leaf") {\n    return true;\n} if (x.type === "Node" && y.type === "Node") {\n    return S.equals(x.value0, y.value0) && eqNodeValue1.equals(x.value1, y.value1) && S.equals(x.value2, y.value2);\n} return false; }); return S; }'
294 |       ])
295 |     })
296 |   })
297 | 
298 |   describe('options', () => {
299 |     it('should handle custom tag names', () => {
300 |       const printer = P.print
301 |       assert.strictEqual(
302 |         printer(lenses.tagName.set('tag')(defaultOptions))(E.Option),
303 |         `export type Option<A> = {
304 |     readonly tag: "None";
305 | } | {
306 |     readonly tag: "Some";
307 |     readonly value0: A;
308 | };
309 | 
310 | export const none: Option<never> = { tag: "None" };
311 | 
312 | export function some<A>(value0: A): Option<A> { return { tag: "Some", value0 }; }
313 | 
314 | export function fold<A, R>(onNone: () => R, onSome: (value0: A) => R): (fa: Option<A>) => R { return fa => { switch (fa.tag) {
315 |     case "None": return onNone();
316 |     case "Some": return onSome(fa.value0);
317 | } }; }
318 | 
319 | import { Prism } from "monocle-ts";
320 | 
321 | export function _none<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.tag === "None"); }
322 | 
323 | export function _some<A>(): Prism<Option<A>, Option<A>> { return Prism.fromPredicate(s => s.tag === "Some"); }
324 | 
325 | import { Eq, fromEquals } from \"fp-ts/lib/Eq\";
326 | 
327 | export function getEq<A>(eqSomeValue0: Eq<A>): Eq<Option<A>> { return fromEquals((x, y) => { if (x.tag === "None" && y.tag === "None") {
328 |     return true;
329 | } if (x.tag === "Some" && y.tag === "Some") {
330 |     return eqSomeValue0.equals(x.value0, y.value0);
331 | } return false; }); }`
332 |       )
333 |     })
334 | 
335 |     it('should handle custom fold names', () => {
336 |       assertPrinterEqual(
337 |         P.fold,
338 |         E.Option,
339 |         `export function match<A, R>(onNone: () => R, onSome: (value0: A) => R): (fa: Option<A>) => R { return fa => { switch (fa.type) {
340 |     case "None": return onNone();
341 |     case "Some": return onSome(fa.value0);
342 | } }; }`,
343 |         lenses.foldName.set('match')(defaultOptions)
344 |       )
345 |     })
346 | 
347 |     it('should handle handlersName handlersStyle', () => {
348 |       assertPrinterEqual(
349 |         P.fold,
350 |         E.Option,
351 |         `export function fold<A, R>(clauses: {
352 |     onNone: () => R;
353 |     onSome: (value0: A) => R;
354 | }): (fa: Option<A>) => R { return fa => { switch (fa.type) {
355 |     case "None": return clauses.onNone();
356 |     case "Some": return clauses.onSome(fa.value0);
357 | } }; }`,
358 |         lenses.handlersStyle.set({ type: 'record', handlersName: 'clauses' })(defaultOptions)
359 |       )
360 |     })
361 |   })
362 | })
363 | 


--------------------------------------------------------------------------------
/test/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "noEmit": true,
 4 |     "sourceMap": true,
 5 |     "declaration": true,
 6 |     "module": "commonjs",
 7 |     "noImplicitReturns": false,
 8 |     "noUnusedLocals": true,
 9 |     "noUnusedParameters": true,
10 |     "noFallthroughCasesInSwitch": true,
11 |     "noEmitOnError": false,
12 |     "strict": true,
13 |     "target": "es5",
14 |     "moduleResolution": "node",
15 |     "forceConsistentCasingInFileNames": true
16 |   }
17 | }
18 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "outDir": "./lib",
 4 |     "declaration": true,
 5 |     "module": "commonjs",
 6 |     "noImplicitReturns": false,
 7 |     "noUnusedLocals": true,
 8 |     "noUnusedParameters": true,
 9 |     "noFallthroughCasesInSwitch": true,
10 |     "noEmitOnError": false,
11 |     "strict": true,
12 |     "target": "es5",
13 |     "moduleResolution": "node",
14 |     "forceConsistentCasingInFileNames": true,
15 |     "lib": ["es6"]
16 |   },
17 |   "include": ["./src/**/*"]
18 | }
19 | 


--------------------------------------------------------------------------------
/tslint.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "extends": "tslint-config-standard",
 3 |   "rules": {
 4 |     "space-before-function-paren": false,
 5 |     "no-use-before-declare": false,
 6 |     "variable-name": false,
 7 |     "quotemark": [true, "single", "jsx-double"],
 8 |     "ter-indent": false,
 9 |     "strict-boolean-expressions": true,
10 |     "forin": true,
11 |     "no-console": false,
12 |     "array-type": [true, "generic"]
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------