Josh Burgess joshburgess

At work, I just spent the last few weeks exploring and evaluating every format I could find, and my number one criteria was whether they supported sum types. I was especially interested in schema languages in which I could describe my types and then some standard specifies how to encode them using an on-the-wire format, usually JSON.

Swagger represents sum types like Scala does, using subtyping. So you have a parent type EitherIntString with two subtypes Left and Right represented as {"discriminator": "Left", value: 42} and {"discriminator": "Right", value": "foo"}. Unfortunately, unlike in Scala in which the parent type is abstract and cannot be instantiated, in Swagger it looks like the parent type is concrete, so when you specify that your input is an EitherIntString, you might receive {"discriminator": "EitherIntString"} instead of one of its two subtypes.
JSON-schema supports unions, which isn't quite the same thing as sum types because

tsc && node main.js

Technical overview

A basic `Option` type

// Option.ts

// definition
export class None {
  readonly tag: 'None' = 'None'

This is a port of the RemoteData type from Kris Jenkins article „How Elm Slays a UI Antipattern“ to TypeScript with TsMonad. There have been ports to Flow and JavaScript as well.

	// @flow

	// type-level dictionary URI -> type constructor
	export type URI2HKT<U, L, A> = {
	Identity: Identity<A>
	// other type constructors here...
	// Option: Option<A>,
	// Either: Either<L, A>,
	// Foo: Foo<U, L, A>
	}

	/*
	* Concept for emulating higher-kinded types using Flow. Instead of passing
	* a type that has not been applied to parameters, this pattern passes
	* a type-level function that will map a parameter type to the desired
	* higher-kinded type applied to the given parameter.
	*
	* @flow
	*/

	// a higher-kinded type is represented indirectly via a type-level function from

	import { Monad, Monad1 } from 'fp-ts/lib/Monad'
	import { HKT, URIS, Type } from 'fp-ts/lib/HKT'
	import { liftA2 } from 'fp-ts/lib/Apply'
	import { flatten } from 'fp-ts/lib/Chain'
	import { Newtype, iso } from 'newtype-ts'

	// Adapted from https://tech.iheart.com/why-fp-its-the-composition-f585d17b01d3

	//
	// newtypes

	type Init<T extends any[], TTail extends any[] = TailArray<T>> = CastArray<{
	[K in keyof TTail]: T[keyof T & K];
	}>

	type PotentialArgs<T extends any[], TResult extends any[] = T> = {
	"continue": PotentialArgs<Init<T>, TResult \| Init<T>>;
	"end": TResult;
	}[T extends [] ? "end" : "continue"]

	type Args<T extends Function> =

	/*
	Slaying a UI Anti Pattern in ReasonML
	Based on Kris Jenkins original writing.
	http://blog.jenkster.com/2016/06/how-elm-slays-a-ui-antipattern.html
	*/
	type remoteData 'e 'a =
	\| NotAsked
	\| Loading
	\| Failure 'e
	\| Success 'a;

	// Types:
	type Just<T> = { Just: T }
	type Nothing = {}
	type Maybe<T> = Just<T> \| Nothing

	type Left<L> = { Left: L }
	type Right<R> = { Right: R }
	type Either<L, R> = Left<L> \| Right<R>

	// For convenience:

Josh Burgess joshburgess

Technical overview

A basic Option type

A basic `Option` type