VimUnDo@*Qy48}!['Ra3m(7 )P_P}7 "use strict";(var reduce = require("reducible/reduce")+var isError = require("reducible/is-error")/var isReduced = require("reducible/is-reduced")"var end = require("reducible/end")'var Eventual = require("eventual/type"))var deliver = require("eventual/deliver")%var defer = require("eventual/defer")#var when = require("eventual/when")F// All eventual values are reduced same as the values they realize to.Jreduce.define(Eventual, function reduceEventual(eventual, next, initial) {3 return when(eventual, function delivered(value) {' return reduce(value, next, initial) }, function failed(error) { next(error, initial) return error })})&function fold(source, next, initial) { /**K Fold is just like `reduce` with a difference that `next` reducer / folderK function it takes has it's parameters reversed. One always needs `value`,J but not always accumulated one. To avoid conflict with array `reduce` we have a `fold`. **/ var promise = defer(). reduce(source, function fold(value, state) {9 // If source is `end`-ed deliver accumulated `state`.5 if (value === end) return deliver(promise, state)/ // If is source has an error, deliver that.; else if (isError(value)) return deliver(promise, value) // Accumulate new `state`& try { state = next(value, state) }C // If exception is thrown at accumulation deliver thrown error.4 catch (error) { return deliver(promise, error) }( // If already reduced, then deliver.7 if (isReduced(state)) deliver(promise, state.value) return state }, initial)G // Wrap in `when` in case `promise` is already delivered to return an // actual value. return when(promise)}module.exports = fold5_&Pi%(4# if (isError(value)) throw value5_' Pl&(5 throw value5_'Ps&(5 deliver(value5_'Pw')6 ')55_(P(*7 (*65