Use map instead of compose

Author: mfix22

index.js

@@ -90,19 +90,26 @@ class Mapper {
         Maybe.of(mapping.field)
           .chain(getMapSpec(this.config.mapDelimiter))
           .chain(([sourceField, targetField]) =>
-            compose(
-              maybe(accum)(
-                assign(targetField, this.config.objDelimiter).bind(this, accum)
-              ),
-              Maybe.of,
-              /* End user-land transforms */
-              ...this.config.postFilters,
-              getMappingFilter(mapping.type, this.config.types),
-              ...this.config.preFilters,
-              /* Begin user-land transforms */
-              map(field => get(field, this.config.objDelimiter)(curr))
-              /* Fields passed to user functions */
-            )(sourceField, mapping, this.config, curr, accum)
+            Either.of(sourceField)
+              .map(map(field => get(field, this.config.objDelimiter)(curr)))
+              .map(_ =>
+                compose(
+                  /* End user-land transforms */
+                  ...this.config.postFilters,
+                  getMappingFilter(mapping.type, this.config.types),
+                  ...this.config.preFilters
+                  /* Begin user-land transforms */
+                )(_, mapping, this.config, curr, accum)
+              )
+              .map(Maybe.of)
+              .chain(
+                maybe(accum)(
+                  assign(targetField, this.config.objDelimiter).bind(
+                    this,
+                    accum
+                  )
+                )
+              )
           ),
       next
     )

src/either.js

@@ -12,11 +12,11 @@ class Left extends Either {
     // ----- Functor (Either a)
     this.map = () => this
     this.join = this.map
+    // ----- Monad (Either a)
+    this.chain = () => this
   }
   // ----- Applicative (Either a)
   // ap() { return this }
-  // ----- Monad (Either a)
-  // chain() { return this }
   // inspect() { return `Left(${this._})` }
   // ----- Traversable (Either a)
   // sequence(of) { return of(this) }
@@ -32,11 +32,11 @@ class Right extends Either {
     // ----- Functor (Either a)
     this.map = fn => Either.of(fn(x))
     this.join = () => x
+    // ----- Monad (Either a)
+    this.chain = fn => fn(x)
   }
   // ----- Applicative (Either a)
   // ap(f) { return f.map(this._) }
-  // ----- Monad (Either a)
-  // chain(fn) { return fn(this._) }
   // inspect() { return `Right(${this._})` }
   // ----- Traversable (Either a)
   // sequence(of) { return this.traverse(of, identity) }