How to use the most.from function in most

var fileInfoArr = Js_dict.values($$event.target.files).map(AssetTreeNodeUtils$WonderEditor.convertFileJsObjectToFileInfoRecord);
  return Most.drain(Most.flatMap((function (fileResult) {
                      return Most.fromPromise(AssetTreeNodeUtils$WonderEditor.handleFileByType(fileResult));
                    }), Most.flatMap((function (fileInfo) {
                          return Most.fromPromise(new Promise((function (resolve, _) {
                                            var reader = new FileReader();
                                            Curry._2(FileReader$WonderEditor.onload, reader, (function (result) {
                                                    return resolve(/* record */[
                                                                /* name */fileInfo[/* name */0],
                                                                /* type_ */AssetTreeNodeUtils$WonderEditor.getUploadFileType(fileInfo[/* type_ */1]),
                                                                /* result */result
                                                              ]);
                                                  }));
                                            return AssetTreeNodeUtils$WonderEditor.readFileByType(reader, fileInfo);
                                          })));
                        }), Most.from(fileInfoArr)))).then((function () {
                return Promise.resolve(Curry._1(dispatchFunc, [
                                AppStore$WonderEditor.UpdateAction,
                                /* Update */[/* array */[/* Asset */2]]
                              ]));
              }));
}

function _convertImageArrayBufferDataToImageBitmapStream(imageArrayBufferIndexSizeDataArr, state) {
  return Most.flatMap((function (param) {
                var texture = param[3];
                return Most.map((function (imageBitmap) {
                              return _addSource(texture, imageBitmap, state);
                            }), Most.fromPromise(ImageBitmapRenderWorkerService$Wonderjs.createImageBitmapFromImageData(/* tuple */[
                                    param[0],
                                    param[1],
                                    param[2]
                                  ], (function (param) {
                                      return _getFlipYFunc(texture, param);
                                    }), state)));
              }), Most.from(imageArrayBufferIndexSizeDataArr));
}

function do$(listOfActions) {
  return from(listOfActions).forEach(x=>x())
}

.add('most', function(deferred) {
    runners.runMost(deferred, most.from(a).filter(even).map(add1).reduce(sum, 0));
  }, options)
  .add('rx 5', function(deferred) {

      .flatMap(({errors}) => most.from(errors.map(e => e.message)))
  )

.add('most', function(deferred) {
    runners.runMost(deferred, most.from(a).scan(sum, 0).reduce(passthrough, 0));
  }, options)
  .add('rx 5', function(deferred) {

};

function add3(a, b, c) {
  return a + b + c;
}
function add3Arr(arr) {
  return arr[0] + arr[1] + arr[2];
}

var xs1 = xs.fromArray(a);
var xs2 = xs.fromArray(a);
var xs3 = xs.fromArray(a);

var m1 = most.from(a);
var m2 = most.from(a);
var m3 = most.from(a);

var rx1 = rxjs.Observable.from(a);
var rx2 = rxjs.Observable.from(a);
var rx3 = rxjs.Observable.from(a);

suite
  .add('xstream', function(deferred) {
    runners.runXStream(deferred,
      xs.combine(xs1, xs2, xs3).map(add3Arr).filter(even));
  }, options)
  .add('most', function(deferred) {
    runners.runMost(deferred,
      most.combineArray(add3, [m1, m2, m3]).filter(even).drain());
  }, options)
  .add('rx 5', function(deferred) {
    runners.runRx5(deferred,

.add("most", function(defered) {
    most
      .from(testData)
      .map(add1)
      .map(double)
      .map(sub3)
      .observe(function(e) {
        if (e === result) {
          defered.resolve();
        }
      });
  }, {defer: true})

.add('most', function(deferred) {
    runners.runMost(deferred, most.from(a).map(most.from).switch().reduce(sum, 0));
  }, options)
  .add('rx 5', function(deferred) {

})

  let ops = []

  if (isFunction(controller.fn)) {
    ops.push(['map', [controller.fn]])
  } else if (isObject(controller.fn) && controller.fn['__instance__'] && !isEmpty(controller.fn['__instance__'].op)) {
    ops = controller.fn['__instance__'].op
  } else {
    throw new Error('Controller fn is neither a function nor an observable placeholder')
  }

  let internalLib = lib(db)

  controller.name = name
  controller.result = buildObservable(most.from(observable), internalLib, ops)
  controller.off = off
}