feature request: async derived properties

[joeybaker]

It would be great if it was possible to derive properties in an async way. The fn could accept a callback that called if the function returns undefined.

Use cases: debouncing derived properties, ajax calls, etc…

[HenrikJoreteg]

Can you elaborate a bit more? Perhaps include some code for how you wish it worked?

[joeybaker]

You bet:

…
derived: {
  // current behavior
  mySyncProperty: {
    deps: ['aProp']
    , fn: function deriveMySyncProperty(){
      return this.aProp + 1 // mySyncProperty now set
    }
  }
  // proposed async behavior
  , myAsyncProperty: {
    deps: ['aProp']
    , fn: _.debounce(function deriveMyAsyncProperty(done){
      expensiveComputation(this.aProp, function(err, res){
        if (err) done(err)
        else done(null, res) // myAsyncProperty now set to res
      })
    }, 500)
  }
}
…

[lukekarrys]

To chime in, I've found myself wanting to this for ajax calls:

drivingDistance: {
    deps: ['latitude', 'longitude'],
    fn: function (done) {
        fetchDrivingDistance(this.latitude + ',' + this.longitude, function (err, result) {
            // done could be error first
            done(err, result);
            // or just accept a value
            done(err ? 'Could not get driving distance' : 'Driving distance is ' + result);
        });
    }
}

This isn't too hard to achieve otherwise with some listeners and a session property, but I do like the idea of the syntax above.

[HenrikJoreteg]

Typically, with normal derived properties, everything happens synchronously. So we fire a change:property then when all the changes are done firing, including derived once, we fire a single change event. How would you expect this to event?

You could fire a late change:derivedAsync but would it also fire a change again at that time?

[joeybaker]

I would vote "yes" for a second change event. As you say, it's expected behavior that every time the state changes, we get a "change" event. That wouldn't be a problem for me.

[lukekarrys]

I think they should fire change events in order to have consistent behavior with other derived properties, but then you'll have an extra change event for each async derived prop which might lead to degrading perf.

I like the idea and the proposed syntax, but I'm closer to +0 on this since it could have some quirks like that.

[HenrikJoreteg]

You can achieve this same type of behavior by setting the result of your async function as a session property.

In some ways I think doing that would be preferable, albeit a bit more verbose. But doing so means we can also cleanly handle how to deal with the fact that derived properties can derive from each other.

It also allows you to easily manage your own cache of the results, since the result is simply set as session property and control how often your expensive operation occurs.

I'm hesitant to introduce this additional complexity to derived properties, they're not so simple as is :)

I'd say something like this would suffice:

session: {
    drivingDistance: 'string'
},
calculateDrivingDistance: function () {
    var self = this;
    fetchDrivingDistance(this.latitude + ',' + this.longitude, function (err, result) {
            self.drivingDistance = result;
    });
}

[HenrikJoreteg]

i think i'm going to close this for now. Thanks for the suggestion, though @joeybaker. Re-open if you disagree.

[joeybaker]

@HenrikJoreteg the only downside with the current approach is that you have to manually add change even listeners to run the calculateDrivingDistance method. The nice part about derived properties is that all of that happens for you. I think the benefit of the API I laid out is that it's totally backward compatible and solves a problem that at least two of us have had in a simple way. IMHO

[HenrikJoreteg]

Yeah, that's fair. I'll leave it open for discussion.

[HenrikJoreteg]

How would it deal with the fact that you'd still get model.drivingDistance === undefined until the callback was done. Because we have to return something synchronously when referenced as a property.