--hoy1n60Sqvzvq/VUinT
Content-Type: text/plain
Content-Transfer-Encoding: quoted-printable

I'd like to announce a new version of lazy.rb -- this one offering
thread safety and transparent futures!

Here's the web site, complete with gem and tarball downloads, plus a bit
of documentation:

 http://moonbase.rydia.net/software/lazy.rb/

Bug reports would be very, very welcome.

== What is lazy.rb?

lazy.rb is a library providing transparent lazy evaluation and futures
for Ruby.  It provides a bag of clever tricks to help you avoid doing
expensive computations up front.

= Lazy Evaluation

Lazy evaluation simply refers to computations which are run on an
as-needed basis.  For example:

 x = promise { 3 + 5 }

Means that the block -- 3 + 5 -- won't actually be evaluated until
something tries to use x's value.

 p x # => #<Lazy::Promise computation=#<Proc:...>>

 # forces evaluation
 p x * 3 # => 24

 p x # => 8

You can also force evaluation using demand:

 x = promise { 3 + 5 }

 p x # => #<Lazy::Promise computation=#<Proc:...>>

 # forces evaluation
 p demand( x ) # => 8

 p x # => 8

It's a bit silly for 3 + 5, but it's handy for more intensive
calculations.  You can unconditionally promise a computation, yet only
pay for it if and when its result is actually used.

= Futures

Futures are blocks of code that are evaluated immediately, but in a
background thread.

 x = future { 3 + 5 }

 p x # => #<Lazy::Future computation=#<Proc:...>>

 # You could do other stuff here while
 # the computation ran in the background

 # blocks until the background thread completes
 p x * 3 # => 24
 
 p x # => 8

Again, silly for 3 + 5 perhaps, but I'm sure you can see how this might
come in handy for more involved computations.

= Other stuff

lazy.rb also includes support for circular programming, where a
computation is passed its own result:

 matryoshka = demand( promise { |result| [result] } )

 p matryoshka # => [[...]]

 p matryoshka.object_id # => -605506544

 p matryoshka.first.object_id # => -605506544

 p matryoshka.first.first.object_id # => -605506544

This works for both promises and futures, although it has the usual
limitations: if a computation tries to call methods on its own result,
it will diverge.

== What's new in 0.9.5?

- Optional support for multithreaded programs:

    require 'lazy/threadsafe' and you can safely use lazy evaluation in
    multithreaded programs.

- Futures:

    With thread support, it turned out that futures were really
    easy to implement atop promises -- just fire off a thread with the
    computation and return a promise to join the thread and grab its
    result.  So I implemented that.

== What happened to lazy streams from 0.2?

I ditched the lazy streams API for now.  It just wasn't working out.

== What next?

Except perhaps for lazy streams (which might end up becoming a separate
library), I think we're nearly feature-complete.  Ideas and suggestions
are very welcome, though.

 -mental

--hoy1n60Sqvzvq/VUinT
Content-Type: application/pgp-signature; name=signature.asc
Content-Description: This is a digitally signed message part

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.1 (GNU/Linux)

iD8DBQBD98ThSuZBmZzm14ERAsBEAKC3KiMZu7WOFk4B1uVo/C8KqKfzEACfbdXS
sPMwxcD9UxGUwXrmkuxjM6Eqy
-----END PGP SIGNATURE-----

--hoy1n60Sqvzvq/VUinT--