-> _

Author: mfix22

src/either.js

@@ -1,6 +1,6 @@
 class Either {
   constructor(x) {
-    this.$value = x
+    this._ = x
   }
 }
 
@@ -17,7 +17,7 @@ class Left extends Either {
   // ap() { return this }
   // ----- Monad (Either a)
   // chain() { return this }
-  // inspect() { return `Left(${this.$value})` }
+  // inspect() { return `Left(${this._})` }
   // ----- Traversable (Either a)
   // sequence(of) { return of(this) }
   // traverse(of, fn) { return of(this) }
@@ -26,27 +26,27 @@ class Left extends Either {
 class Right extends Either {
   constructor(x) {
     super(x)
-    this.$value = x
+    this._ = x
     this.isLeft = false
     this.isRight = true
     // ----- Functor (Either a)
     this.map = fn => Either.of(fn(x))
-    this.join = () => this.$value
+    this.join = () => this._
   }
   // ----- Applicative (Either a)
-  // ap(f) { return f.map(this.$value) }
+  // ap(f) { return f.map(this._) }
   // ----- Monad (Either a)
-  // chain(fn) { return fn(this.$value) }
-  // inspect() { return `Right(${this.$value})` }
+  // chain(fn) { return fn(this._) }
+  // inspect() { return `Right(${this._})` }
   // ----- Traversable (Either a)
   // sequence(of) { return this.traverse(of, identity) }
-  // traverse(of, fn) { fn(this.$value).map(Either.of) }
+  // traverse(of, fn) { fn(this._).map(Either.of) }
 }
 
 // ----- Pointed (Either a)
 Either.of = x => new Right(x)
 
-const either = (f, g) => e => (e.isLeft ? f(e.$value) : g(e.$value))
+const either = (f, g) => e => (e.isLeft ? f(e._) : g(e._))
 
 module.exports = {
   Either,

src/identity.js

@@ -6,12 +6,12 @@ class Identity {
     this.chain = fn => this.map(fn).join()
     this.join = () => x
   }
-  // inspect() { return `Identity(${this.$value})` }
+  // inspect() { return `Identity(${this._})` }
   // ----- Applicative Identity
-  // ap(f) { return f.map(this.$value) }
+  // ap(f) { return f.map(this._) }
   // ----- Traversable Identity
   // sequence(of) { return this.traverse(of, identity) }
-  // traverse(of, fn) { return fn(this.$value).map(Identity.of) }
+  // traverse(of, fn) { return fn(this._).map(Identity.of) }
 }
 
 // ----- Pointed Identity

src/maybe.js

@@ -1,24 +1,24 @@
 class Maybe {
   constructor(x) {
-    this.$value = x
+    this._ = x
     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}`; }
+  // inspect() { return `Maybe(${this._}`; }
   // ----- Applicative Maybe
-  // ap(f) { return this.nil ? this : f.map(this.$value) }
+  // ap(f) { return this.nil ? this : f.map(this._) }
   // ----- Monad Maybe
   // chain(fn) { return this.map(fn).join() }
   // ----- Traversable Maybe
   // sequence(of) { this.traverse(of, identity) }
-  // traverse(of, fn) { return this.nil ? of(this) : fn(this.$value).map(Maybe.of) }
+  // traverse(of, fn) { return this.nil ? of(this) : fn(this._).map(Maybe.of) }
 }
 // ----- Pointed Maybe
 Maybe.of = x => new Maybe(x)
 
-const maybe = v => f => m => (m.nil ? v : f(m.$value))
+const maybe = v => f => m => (m.nil ? v : f(m._))
 
 module.exports = {
   Maybe,