Make classes smaller

Author: mfix22

src/either.js

@@ -5,18 +5,13 @@ class Either {
 }
 
 class Left extends Either {
-  get isLeft() {
-    return true
-  }
-  get isRight() {
-    return false
-  }
-  // ----- Functor (Either a)
-  map() {
-    return this
-  }
-  join() {
-    return this
+  constructor(x) {
+    super(x)
+    this.isLeft = true
+    this.isRight = false
+    // ----- Functor (Either a)
+    this.map = () => this
+    this.join = () => this
   }
   // ----- Applicative (Either a)
   // ap() { return this }
@@ -29,18 +24,14 @@ class Left extends Either {
 }
 
 class Right extends Either {
-  get isLeft() {
-    return false
-  }
-  get isRight() {
-    return true
-  }
-  // ----- Functor (Either a)
-  map(fn) {
-    return Either.of(fn(this.$value))
-  }
-  join() {
-    return this.$value
+  constructor(x) {
+    super(x)
+    this.$value = x
+    this.isLeft = false
+    this.isRight = true
+    // ----- Functor (Either a)
+    this.map = fn => Either.of(fn(x))
+    this.join = () => this.$value
   }
   // ----- Applicative (Either a)
   // ap(f) { return f.map(this.$value) }

src/identity.js

@@ -1,17 +1,10 @@
 class Identity {
   constructor(x) {
-    this.$value = x
-  }
-  // ----- Functor Identity
-  map(fn) {
-    return Identity.of(fn(this.$value))
-  }
-  // ----- Monad Identity
-  chain(fn) {
-    return this.map(fn).join()
-  }
-  join() {
-    return this.$value
+    // ----- Functor Identity
+    this.map = fn => Identity.of(fn(x))
+    // ----- Monad Identity
+    this.chain = fn => this.map(fn).join()
+    this.join = () => x
   }
   // inspect() { return `Identity(${this.$value})` }
   // ----- Applicative Identity

src/maybe.js

@@ -1,16 +1,10 @@
 class Maybe {
-  get nil() {
-    return this.$value === undefined
-  }
   constructor(x) {
     this.$value = x
-  }
-  // ----- Functor Maybe
-  map(fn) {
-    return this.nil ? this : Maybe.of(fn(this.$value))
-  }
-  join() {
-    return this.nil ? this : this.$value
+    this.nil = x === undefined
+    // ----- Functor Maybe
+    this.map = fn => (this.nil ? this : Maybe.of(fn(x)))
+    this.join = () => (this.nil ? this : x)
   }
   // inspect() { return `Maybe(${this.$value}`; }
   // ----- Applicative Maybe