Comment implémenter un flux linéaire avec IO et Soit des foncteurs en programmation fonctionnelle avec javascript?

Question

Résultat: flux linéaire comme getFile(filename).map(parseJson).map(doOtherThings)...

Lorsque j'utilise Either lui-même, tout est agréable et facile

function doSomethingCrazyHere(){ 
    return "something crazy"; 
} 

function safeUnsureFunction(){ 
    try{ 
     return Right(doSomethingCrazyHere()); 
    }catch(e){ 
     return Left(e); 
    } 
} 

alors je peux juste faire le problème

safeUnsureFunction().map((result)=>{ 
    // result is just result from doSomethingCrazyHere function 
    // everything is linear now - I can map all along 
    return result; 
}) 
.map() 
.map() 
.map() 
.map(); 
// linear flow 

suivant est quand je m en utilisant IO comme:

function safeReadFile(){ 
    try{ 
    return Right(fs.readFileSync(someFile,'utf-8')); 
    }catch(e){ 
    return Left(error); 
    } 
} 

let pure=IO.from(safeReadFile).map((result)=>{ 
    // result is now Either 
    // so when I want to be linear I must stay here 
    // code from now on is not linear and I must generate here another chain 

    return result.map(IdontWant).map(ToGo).map(ThisWay).map(ToTheRightSideOfTheScreen); 
}) 
.map((result)=>{ 
    return result.map(This).map(Is).map(Wrong).map(Way); 
}) 
.map(IwantToBeLienearAgain) 
.map(AndDoSomeWorkHere) 
.map(ButMapFromIOreturnsIOallOverAgain); 

let unpure=function(){ 
    return pure.run(); 
} 

IO est-ce pour séparer les fonctions pures des fonctions pas si pures?

Donc, je veux séparer le fichier non lu avec aussi Soit la gestion des erreurs de fichier. Est-ce possible? Comment avoir un flux linéaire lors de l'utilisation de Métamorphoses dans les monades IO?

Y a-t-il des modèles de programmation fonctionnelle pour cela?

readFile(filename).map(JSON.parse).map(doSomethingElse)....

Answer 1

façon Seulement pour cela pourrait être d'ajouter safeRun méthode à la IO donc à la fin, nous aurons Either et nous allons récupérer grâce d'une erreur

class safeIO { 
    // ... 

    safeRun(){ 
    try{ 
     return Right(this.run()); 
    }catch(e){ 
     return Left(e); 
    } 
    } 

    //... 
} 

Au lieu de safeReadFile qui retourne Either nous devons utiliser normal readFile

function readFile(){ 
    return fs.readFileSync(someFile,'utf-8'); 
} 

let pure = safeIO.from(readFile) 
.map((result)=>{ 
    // result is now file content if there was no error at the reading stage 
    // so we can map like in normal IO 
    return result; 
}) 
.map(JSON.parse) 
.map(OtherLogic) 
.map(InLinearFashion); 

let unpure = function(){ 
    return pure.safeRun(); // -> Either Left or Right 
} 

ou prendre la logique try catch lui-même en dehors d'un IO à la fonction unpure sans aucune acteur de modification IO

let unpure = function(){ 
    try{ 
    return Right(pure.run()); 
    }catch(e){ 
    return Left(e); 
    } 
} 
unpure(); // -> Either