Thanks for the comment. I saw that Sun forum threa...

2010-02-22T08:23:47.399-05:00

Thanks for the comment. I saw that Sun forum thread that you mentioned, but one part of smarks' reply stood out:

"HOWEVER I recommend that you DO NOT USE the "bind lazy" construct. Its semantics are ill-defined, especially in the presence of triggers, and there are bugs in it. If you rely on it you will probably get yourself into trouble. We certainly have. It's undocumented for a reason."

I'm not convinced that lazy evaluation of bound expressions would improve performance in practice: if you're binding an expression, particularly in a UI, you'll be evaluating that expression on a regular basis (eg, whenever the GUI is repainted). In such cases, you don't want to check that expression to see what has changed, or worse, re-evaluating the entire expression.

I think the JavaFx team would be better served by making "lazy" a separate keyword, with different semantics: "bind" would imply propagation, "lazy" would imply evaluation. For example, you could specify a function parameter as "lazy," and the argument would not be evaluated unless it's referenced -- perhaps never, if it's in the "wrong" place in an "if" or conditional expression.

---

And a comment for people reading these comments and wondering what they mean: they belong on the next posting.

Hi Keith, About lazy evaluation... I've been ...

2010-02-20T09:33:42.951-05:00

Hi Keith,

About lazy evaluation... I've been puzzled on this topic for a while too. Although it's not documented (well? / at all?), JavaFX 1.2 does appear to have some support for lazy evaluation.

Here is an example of a lazy vs non-lazy bind:

=== CODE ===

class NonLazy {
public var x: Number = 0;
public def y: Number = bind x on replace {
println("NonLazy y has been replaced!");
}
}

class Lazy {
public var x: Number = 0;
public def y: Number = bind lazy x on replace {
println("Lazy y has been replaced!");
}
}

println("-- Creating nonLazy --");
def nonLazy = NonLazy { }
println("About to set nonLazy.x");
nonLazy.x = 42;
println("About to query nonLazy.y");
def nonLazyY = nonLazy.y;
println("nonLazy.y = {nonLazyY}");

println("-- Creating lazy (laze) --");
def laze = Lazy { }
println("About to set laze.x");
laze.x = 42;
println("About to query lazy.y");
def lazyY = laze.y;
println("laze.y = {lazyY}");

=== CODE ===

If you execute it, you should get the following output:

-- Creating nonLazy --
NonLazy y has been replaced!
About to set nonLazy.x
NonLazy y has been replaced!
About to query nonLazy.y
nonLazy.y = 42.0
-- Creating lazy (laze) --
About to set laze.x
About to query lazy.y
Lazy y has been replaced!
laze.y = 42.0

As you can see, the lazy y value is not replaced until it is queried.

It's also possible to use the lazy keyword with a bound function (again just after the bind keyword), with similar results. Remember to declare the function itself as bound, as described here by Jonathan Giles:
http://jonathangiles.net/blog/?p=460

There is a little discussion of lazy binding on this Sun forum topic:
http://forums.sun.com/thread.jspa?threadID=5427223
In particular, Amy Fowler and Chris Oliver both have public examples that use the lazy keyword (linked from the first post).

I hope the above helps. Let's hope that the JavaFX team are listening and improve their documentation! :-)

Jonathan Merritt.

Comments on blog.kdgregory.com: JavaFx: Interesting Language Features

Thanks for the comment. I saw that Sun forum threa...

Hi Keith, About lazy evaluation... I've been ...