Sollte Maybe.map den abgebildeten Wert respektieren?

Question

Für eine Maybe.Just Monade, wenn wir es mit einer Funktion zurückgeben Null zurückgibt, wird es immer noch zurückgeben Nur mit Null innerhalb, aber ich denke, es sollte nichts sein, sonst verlor es seine Kraft gegen Null zu schützen. Habe ich recht, oder gibt es einen anderen Grund, so zu sein?

Maybe.fromNuallable({noname: ''}) // return Just({noname: ''}) 
.map(prop('name')) // return Just(undefined), but I think it should return Nothing() 
.map(x=>x.length) // failed here 

ich alle Implementierungen (falktale und ramda.fantasy) kontrolliert von Maybe.map, ist es die folgenden:

Just.prototype.map = function(f) { 
    return this.of(f(this.value)); 
}; 

Answer 1

Nun, ich könnte falsch sein, aber map kommt von Funktoren. Es handelt sich also bei einfachen Morphismen nicht um kleisli Pfeile. Sie müssen bind und irgendeine Art von Funktion verwenden, die eine Monade

// maybeProp:: String -> A -> Maybe[B] 
const maybeProp = name => val => Maybe.fromNullable(val[name]) 

Maybe 
    .fromNullable({noname: ''}) 
    .bind(maybeProp('name')) 
    .map(x => x.length) 

Answer 2

Hier gibt eine stark vereinfachte Implementierung des Maybe (aka Option) Datentyp für den Unterricht:

class Option { 
 
    constructor(x) { this.x = x } 
 
    isNone() { return this.x === null || this.x === undefined } 
 
    map(f) { return this.isNone() ? this : this.of(f(this.x)) } 
 
    ap(ftor) { return this.isNone() ? this : ftor.map(this.x) } 
 
    of(x) { return Option.of(x) } 
 
    flatten() { return this.isNone() ? this : this.x } 
 
    chain(mf) { return this.isNone() ? this : this.map(mf).flatten() } 
 
} 
 

 
Option.of = x => new Option(x); 
 

 
const o = new Option({}), 
 
p = new Option({name: "foo"}); 
 

 
const prop = key => o => new Option(o[key]), 
 
len = prop("length"); 
 

 
// 
 
let r1 = o.map(prop("name")).map(x => x.map(len)), 
 
r2 = p.map(prop("name")).map(x => x.map(len)); 
 

 
console.log(r1); 
 
console.log(r2); 
 

 
let r3 = o.chain(prop("name")).chain(len); 
 
r4 = p.chain(prop("name")).chain(len); 
 

 
console.log(r3); 
 
console.log(r4);

• o und p sind Option Typen und implementieren die Funktors, applicative Funktors und Monade Schnittstelle
• prop und len sind Kleisli Pfeile das heißt Funktionen, die eine Monade (nämlich ein Option Monade in diesem Fall)
• zurück, wenn Sie sich bewerben prop/len-o/p über ihren Funktors Schnittstelle (map), dann ist dies einen verschachtelten Option Typen ergibt (siehe r1/r2)
• dieses Verhalten Sie Kleisli Pfeile über chain (die monadische Interface), das ist eine Folge vonanwenden müssen vermeiden (Siehe r3/r4)und flatten
• jede Funktion, die zurückkehren könnte null/undefined soll einen Option Typen zurückgeben, so dass dieses Verhalten