FADt

Functional Abstract Data-types

This is a simple library for definining immutable data-only classes, no methods allowed. It also provides a "copy" method to create a modified copy of an instance with the provided changes applied.

A Simple Example

Step One: Define your data-types

const createDataType = require('fadt');
const isUndefined = require('lodash.isundefined');

const MyBaseDataType = createDataType(function (params) {
	if (!isUndefinedl(params.fooCount)) throw new TypeError('"fooCount" is required');
	
	this.fooCount = params.fooCount;
	this.isBar = params.isBar || false;
	this.bazDescription = params.bazDescription || 'This is some serious baz!';
});

const MyChildDataType = createDataType(function (params) {
	if (!isUndefined(params.subObject)) throw new TypeError('"subObject" is required');

	this.subObject = params.subObject;
	this.children = params.children || [];

	this.bazDescription = 'We only using the finest, artisinal baz'
}, MyBaseDataType);

Step Two: Use them

try {
  const myData = new MyBaseDataType({
    fooCount: 1,
    isBar: true,
    bazDescription: 'I am baz!'
  });

  console.log(`isBar(${myData.isBar}), ${myData.fooCount}`); // bar(true), 1

  const myNextData = myData.next({ isBar: false });

  console.log(`bar(${myNextData.isBar}), ${myNextData.fooCount}`); // bar(false), 1
} catch (e) {
  console.error(`Oh no! ${e.message}`);
}

API Reference

ADT

• ADT
  • ~createDataType(ctr, [ParentClass]) ⇒ function
  • ~Constructor : function

ADT~createDataType(ctr, [ParentClass]) ⇒ function

Generate Abstract Data Type constructor

Kind: inner method of ADT Returns: function - Constructor

| Param | Type | Description | | --- | --- | --- | | ctr | Constructor | constructor function for validating/setting given params | | [ParentClass] | function | constructor for parent class to inherit from |

ADT~Constructor : function

Kind: inner typedef of ADT Throws:

• TypeError error thrown for any type validation

| Param | Type | Description | | --- | --- | --- | | params | object | key/value parameters for instance consruction |

FAQ

Why are you using stinky, old ES5 class syntax? Get with the program and use the shiny, new ES2015 class syntax!

The astute reader will indeed notice that this library is using ES5 class syntax. The reason for this is that the base constructor needs to fire last, after all it's child classes have initialized in order to properly freeze the instance. ES2015 classes require that the super method be invoked before any other code in a constructor.