3

First the motivation for this question: anyone who uses persistent data structures and a gui runs into this problem. So, my questions is kind of: do people just work it out on a case by case basis, or are their libraries, utilities, frameworks, something that abstracts the general case to make it easier to do.

The specific language I'm targeting is Scala, but I think this is a general question related to persistent data structures.

Let's say you have a large data structure displayed in a complex gui with trees, tables, property sheets, etc. Various user or system actions result in modifications to the data structure.

Is there a general strategy for handling notifications to tell the gui to update itself?

One of the intriguing ideas with persistent data structures is one could handle undo/redo by just switching between roots. That works for the data, but is there a general mechanism for telling listeners (eg. a gui) about the change if one were to switch roots?

My understanding is that it needs to be incremental--I need to know what changed. I can't just tell everything to do a complete refresh of the gui since that could be very expensive (and some controls don't handle it well (or at all) because of maintaining gui state).

mentics
  • 6,852
  • 5
  • 39
  • 93

2 Answers2

0

You'd update the GUI at the same time you switch roots, since if the structure is truly persistent, then any change deep down in the structure will incur a new root. That, however, will be done imperatively (or in some kind of monadic construction; I've never done GUI programming in Haskell).

E.g., if your GUI code is imperative/OO but uses a persistent State structure:

// poor man's zipper for unbounded undo/redo
var curState : State
var prevStates : List[State]
var nextStates : List[State]

def undo = {
    val prev = prevStates.head
    prevStates = prevStates.tail
    nextStates = curState :: nextStates
    curState = prev
    updateGui(curState)
}
Fred Foo
  • 355,277
  • 75
  • 744
  • 836
  • Ah, I see I missed something important in the question. The guis I have worked with generally expect incremental updates. Refreshing the entire gui could be extremely expensive. The call to updateGui(curState)--that's the magic I'm trying to figure out how to do that in a reasonable fashion. – mentics Mar 24 '11 at 20:36
  • @taotree: the obvious solution would be to store the differences between states (e.g. `UserAction` objects, or some transformation of them) with the actual undo list. – Fred Foo Mar 24 '11 at 20:39
  • Yes, one could roll one's own solution for that. My question is if there is some commonly used detailed approach. This is a path many have already gone down I would expect, and I'm wondering if someone has already designed a good solution for it as opposed to me reinventing the wheel. – mentics Mar 25 '11 at 20:08
0

See this question about Functional Reactive Programming in Scala. And also see the Cells menifesto and the Wikipedia article about FRP for background.

And read the paper "Deprecating Observer Pattern using Scala.React": http://lamp.epfl.ch/~imaier/pub/DeprecatingObserversTR2010.pdf mentioned on an answer by magicduncan on the above SO question.

Community
  • 1
  • 1
peterhil
  • 1,536
  • 1
  • 11
  • 18