Daggy

Library for creating tagged constructors.

daggy.getInstance(self, constructor)

Returns self if it’s an instanceof constructor, otherwise creates a new object with constructor‘s prototype.

Allows creating constructors that can be used with or without the new keyword but always have the correct prototype.

  1. function WrappedArray() {
  2.     var self = daggy.getInstance(this, WrappedArray);
  3.     self._array = [].slice.apply(arguments);
  4.     return self;
  5. }
  6. new WrappedArray(1, 2, 3) instanceof WrappedArray; // true
  7. WrappedArray(1, 2, 3) instanceof WrappedArray; // true

daggy.tagged(arguments)

Creates a new constructor with the given field names as arguments and properties. Allows instanceof checks with returned constructor.

  1. var Tuple3 = daggy.tagged('x', 'y', 'z');
  3. var _123 = Tuple3(1, 2, 3); // optional new keyword
  4. _123.x == 1 && _123.y == 2 && _123.z == 3; // true
  5. _123 instanceof Tuple3; // true

daggy.taggedSum(constructors)

Creates a constructor for each key in constructors. Returns a function with each constructor as a property. Allows instanceof checks for each constructor and the returned function.

  1. var Option = daggy.taggedSum({
  2.     Some: ['x'],
  3.     None: []
  4. });
  6. Option.Some(1) instanceof Option.Some; // true
  7. Option.Some(1) instanceof Option; // true
  8. Option.None instanceof Option; // true
  10. function incOrZero(o) {
  11.     return o.cata({
  12.         Some: function(x) {
  13.             return x + 1;
  14.         },
  15.         None: function() {
  16.             return 0;
  17.         }
  18.     });
  19. }
  20. incOrZero(Option.Some(1)); // 2
  21. incOrZero(Option.None); // 0