persistent-class v1.1.1
persistent-class
Persistent datastructures. Loosely based on the ES2015 class specification.
About
This is an opinionated tool for constructing lightweight persistent data structures, kinda like the Records from ImmutableJS, made using ECMAScript 6 Classes.
You can define and extend them. What you get will always be immutable.
Example
Here is a little comparison between using a persistent class compared to a plain one:
const point = new Point(1, 2)
const persistentPoint = new PersistentPoint(1, 2)
persistentPoint.x = 3 // Does not mutate the object. Throws error in strict mode
point.moveX(1).toString() === persistentPoint.moveX(1).toString() //Both implementation support fluent API
point.toString() //'(2, 2)' // The Value is mutated in the operation above
persistentPoint.toString() //'(1, 2)' // Values remain unchanged
Tutorial
The library exports a Persistent Class Constructor:
const Persistent = require('persistent-class').Persistent
Define a persistent class by extending it:
const PersistentPoint = class extends Persistent {
Addding a constructor
Create a constructor for your persistent class by calling the super function with a plain object containing the object's properties and returning the result:
Plain:
const Point = class {
constructor(x, y) {
this.x = x;
this.y = y;
}
...
Persistent:
const PersistentPoint = class extends Persistent {
constructor(x, y) {
return super({x, y})
}
...
Defining methods
Methods can apply modifications to the object's properties by calling the low level set
method with a modification object containing the new values of changed properties. This method generates a new version of the object. Return the result to create a fluent API.
Plain:
moveX(amount) {
this.x = this.x + amount;
return this
}
moveY(amount) {
this.y = this.y + amount;
return this
}
toString() {
return '(' + this.x + ', ' + this.y + ')';
}
})
Persistent:
moveX(amount) {
return this.set({x: amount + this.x})
}
moveY(amount) {
return this.set({y: amount + this.y})
}
toString() {
return '(' + this.x + ', ' + this.y + ')';
}
}
Using Custom factory Functions
You can create persistent objects with vanilla prototype-based inheritance.
Just create your object using the provided prototype
or use the create
function to create a class-like record structure.
const create = require('persistent-class').create
const pPoint = create({
constructor(x, y) {
return this.set({x, y})
},
moveX(amount) {
return this.set({x: amount + this.x})
},
moveY(amount) {
return this.set({y: amount + this.y})
},
toString() {
return '(' + this.x + ', ' + this.y + ')';
}
})
##Project Status
It is just a few lines of code and is well-tested.