static ‘empty’ value

README.md

@@ -129,22 +129,21 @@ A value which has a Semigroup must provide a `concat` method. The
 A value that implements the Monoid specification must also implement
 the Semigroup specification.
 
-1. `m.concat(m.empty())` is equivalent to `m` (right identity)
-2. `m.empty().concat(m)` is equivalent to `m` (left identity)
+1. `m.concat(m.constructor.empty)` is equivalent to `m` (right identity)
+2. `m.constructor.empty.concat(m)` is equivalent to `m` (left identity)
 
-#### `empty` method
+#### `empty` value
 
 ```hs
-empty :: Monoid m => () -> m
+empty :: Monoid m => m
 ```
 
-A value which has a Monoid must provide an `empty` method on itself or
-its `constructor` object. The `empty` method takes no arguments:
+A value which has a Monoid must provide an `empty` value on its
+`constructor` object:
 
-    m.empty()
-    m.constructor.empty()
+    m.constructor.empty
 
-1. `empty` must return a value of the same Monoid
+1. `empty` must be a value of the same Monoid
 
 ### Functor
 
@@ -563,7 +562,7 @@ be equivalent to that of the derivation (or derivations).
 [`bimap`]: #bimap-method
 [`chain`]: #chain-method
 [`concat`]: #concat-method
-[`empty`]: #empty-method
+[`empty`]: #empty-value
 [`equals`]: #equals-method
 [`extend`]: #extend-method
 [`extract`]: #extract-method

id.js

@@ -14,11 +14,7 @@ Id.prototype[fl.concat] = function(b) {
     return new Id(this.value[fl.concat](b.value));
 };
 
-// Monoid (value must also be a Monoid)
-Id[fl.empty] = function() {
-    return new Id(this.value[fl.empty] ? this.value[fl.empty]() : this.value.constructor[fl.empty]());
-};
-Id.prototype[fl.empty] = Id[fl.empty];
+// Monoid is not satisfiable since the type lacks a universal empty value
 
 // Foldable
 Id.prototype[fl.reduce] = function(f, acc) {

id_test.js

@@ -14,17 +14,18 @@ const semigroup = require('./laws/semigroup');
 const setoid = require('./laws/setoid');
 const traversable = require('./laws/traversable');
 
-const {tagged} = require('daggy');
 const {of, empty, concat, equals, map} = require('.');
 
 const Id = require('./id');
 
 // Special type of sum for the type of string.
-const Sum = tagged('v');
+const Sum = function Sum(v) {
+    if (!(this instanceof Sum)) return new Sum(v);
+    this.v = v;
+};
 Sum[of] = (x) => Sum(x);
-Sum[empty] = () => Sum('');
+Sum[empty] = Sum('');
 Sum.prototype[of] = Sum[of];
-Sum.prototype[empty] = Sum[empty];
 Sum.prototype[map] = function(f) {
     return Sum(f(this.v));
 };
@@ -90,8 +91,8 @@ exports.monad = {
 };
 
 exports.monoid = {
-    leftIdentity: test((x) => monoid.leftIdentity(Id[of](Sum[empty]()))(equality)(Sum[of](x))),
-    rightIdentity: test((x) => monoid.rightIdentity(Id[of](Sum[empty]()))(equality)(Sum[of](x)))
+    leftIdentity: test((x) => monoid.leftIdentity(Sum)(equality)(x)),
+    rightIdentity: test((x) => monoid.rightIdentity(Sum)(equality)(x))
 };
 
 // Semigroup tests are broken otherwise for this.

laws/monoid.js

@@ -7,23 +7,23 @@ const {of, empty, concat} = require('..');
 
 ### Monoid
 
-1. `m.concat(m.empty())` is equivalent to `m` (right identity)
-2. `m.empty().concat(m)` is equivalent to `m` (left identity)
+1. `m.concat(m.constructor.empty)` is equivalent to `m` (right identity)
+2. `m.constructor.empty.concat(m)` is equivalent to `m` (left identity)
 
 **/
 
 const rightIdentity = t => eq => x => {
-    const a = t[of](x)[concat](t[empty]());
+    const a = t[of](x)[concat](t[empty]);
     const b = t[of](x);
     return eq(a, b);
 };
 
 const leftIdentity = t => eq => x => {
-    const a = t[empty]()[concat](t[of](x));
+    const a = t[empty][concat](t[of](x));
     const b = t[of](x);
     return eq(a, b);
 };
 
 module.exports = { rightIdentity
-                 , leftIdentity 
-                 };
+                 , leftIdentity
+                 };