[PyCells] [cells-devel] Call for comment on Prospect of Lazy Cells Not Propagating Either

[Michael Naunton]

On Mon, 2006-09-11 at 15:33 -0400, Ken Tilton wrote:
> kt wrote:
> 
>          If A is eager and depends on B and A has an observer that
>         really really wants to stay on top of reality....
> 
> I just had Cells4 kinda thought: what if all Cells are (in some new
> respect) lazy unless observed (directly or indirectly thru someone
> that is observed)?

I was using Cells4 today :)

So, all cells are lazy.  Check.
Unless observed.  Check.
  Observed = I ask for a cells value explicitly (in which case it is
             transiently observed,) or a GUI, etc, subscribes to it.

This makes the implementation really easy:

class Cell:
  def invalidate( self ):
    if self.state != INVALID:
      if self.subscibed():
        invalidationSet.add( self )
      self.state = INVALID
      for x in self.dependents:
        x.invalidate()

  def set( self, v ):
    self.invalidate()
    self.val = v
    # dispatch invalidateSet stuff at some transactional boundary

> 
> btw, as radical as that change sounds, I am not sure it really rises
> to the level of "Cells4" -- I am suggesting this only because I think
> it is equivalent to Cells3 (assuming one is sane enough not to have
> side-effects inside rules) and merely automates the identification of
> which cells can be lazy (or looked at another way, automates the
> detection of the need for eagerness. 

Yep.  No side-effects, and life is simple.  Eagerness is just:

class Cell:
  def value( self ):
    inputs = [ x.value() for x in self.inputs ]
    self.val = self.calc( *inputs )
    self.state = VALID
    return self.val

> Then the explicit thing becomes supporting a new class of much rarer
> (methinks) "lazy" observer whose existence would not trigger
> eagerness.

Ah, but once you've eliminated side-effects, lazy observers become easy
to write and really useful.  Consider a tabbed panel GUI on an object
with same panel 1 = basic info, and panel 2 = expensive to compute
stuff.  The panels subscribe to the cells they care about, but when the
observer callbacks are called, they do something like:

class GuiElem:
  def myVal( self ):
    return self.myCell.value()

  def draw( self ):
    self.widget.draw( self.myVal() )

  def callback( self, aCell ):
    if self.isVisible():
      self.draw()

  def onActivate( self ):
    self.draw()

Lovely, no?  Maximal laziness - the only cost is establishing the cell
dependencies.  

> It would be interesting to see how much laziness ends up being deduced
> by this approach. The indirect eagerness (I am not observed, but I am
> called/used by someone who is) could get interesting. 
> 
> Jes thinkin out loud.

You just keep thinking, Butch.  That's what you're good at.

-- mmn