See "Adaptive Functional Programming" by Acar et al. http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.61.2257 Doesn't talk about OO specifically, but rather how to make "updatable" computations in a mutable language. There's a Haskell implementation, too. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Adaptive -- ryan 2008/12/28 frantisek kocun :

Still nobody? Maybe I didn't write it clear. So one more time:

I have a list of numbers (say Int) numberList = [1:Int,2,3,1,2,6,7,8] and a number sumOfNumberList = sum numberList and here comes the question. Imagine the list numberLists is mutable (that's why in topic is "not Haskell question") so the calculation doesn't occur only once but every time something changed in the list (listener pattern). (If the lis tis java List and Int is java Integer, every acces to list should trigger event to its listeners, but if I use list of another objects e.g. Item with value, every access to list should trigger event to its listeners as well as every modification of object Item should triggers its listeners (list) and that in turn triggers its listeners) How to make transformation of often used functions (map, sum, forall, filter, exists) to listeners in OO language? Is there anything (any tool, any paper, any blog...) about it?

Thanks

Fero

PS If nobody answers I really stop asking non Haskell questions in this mailling list:)

_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

On 2008 Dec 28, at 17:22, frantisek kocun wrote:

"We present techniques for incremental computing by introducing adaptive functional programming. As an adaptive program executes, the underlying system represents the data and control dependences in the execution in the form of a dynamic dependence graph. When the input to the program changes, a change propagation algorithm updates the output and the dynamic dependence graph by propagating changes through the graph and re-executing code where necessary. Adaptive programs adapt their output to any change in the input, small or large."

I find myself thinking this sounds like a reactive programming technique. Am I being obvious (or oblivious :) or is there something to look at here for reactive UIs? -- brandon s. allbery [solaris,freebsd,perl,pugs,haskell] allbery@kf8nh.com system administrator [openafs,heimdal,too many hats] allbery@ece.cmu.edu electrical and computer engineering, carnegie mellon university KF8NH

2008/12/28 Luke Palmer :

Adaptive programming is sortof the opposite of reactive programming, the way I see it. Adaptive is imperative (that's the best word I have for it), i.e. you have a bunch of variables and your code decides which one to change. Whereas reactive programming, at the very heart (i.e. I would expect every reactive semantics to obey this), is declarative. That is, the way something behaves depends only on where it was defined, and not at all on how it is used.

I'm not sure I agree with this analysis; Reactive can be implemented on top of Adaptive, and vice versa. Yes, adaptive sort-of about mutation, but if you take a time step as "some input variables updated", you can easily see how a Reactive event stream implements an adaptive computation. Similarily, Conal's implementation of Reactive is mostly about how futures interact; it's easy to see how futures can be implemented as Adaptive objects on top of input sources showing the current time and the other inputs to the system. In fact I think if you look at Magnus Carlsson's Haskell Adaptive package, I think you'll find that there isn't really much mention of mutation at all, except at the point of "update the inputs and tell me what output I get". This is much the same as Reactive where some underlying system is updating the inputs (mouse position, keyboard events, etc.) and giving you the new output. -- ryan