Value Assignment and Deferment with Lambdas/Procs

When assigning a variable with a raw value the outcome is as you would expect.

greeting = "hello"
# => "hello"
puts greeting
# hello

Now while learning about assigning methods to variables I used to wonder if I was assigning the result value from the method, or simply pointing to the method to be run when the variable was called upon.  To show what happen I will use Time.now for the method being assigned to the value since it changes every second.

x = Time.now
# => 2015-02-27 00:51:04 -0500 
x
# => 2015-02-27 00:51:04 -0500 
x
# => 2015-02-27 00:51:04 -0500 

As you can see the variable x saved the value from Time.now and didn’t call the Time.now method when accessed later.  To show that this is a method being called I’ll show the same done from a block and a method.

y = begin Time.now end
# => 2015-02-27 00:54:19 -0500 
y
# => 2015-02-27 00:54:19 -0500 
y
# => 2015-02-27 00:54:19 -0500 

def the_time; Time.now end
# => :the_time 
z = the_time
# => 2015-02-27 00:55:18 -0500 
z
# => 2015-02-27 00:55:18 -0500 
z
# => 2015-02-27 00:55:18 -0500

As you can see a regular block and method run once when being assigned to a variable and the variable stores the value itself.  Well what if you wanted the variable to always get the value by running the method?

Deferred with Lambdas and Procs

When you assign either a lambda or a proc to a variable then it is available to execute later.  The one thing to note is that you will need to use either .[] or .call methods on the variable to execute the lambda/proc.

a = lambda {Time.now}
# => #<Proc:0x00000002ba0660@(irb):69 (lambda)> 
a[]
# => 2015-02-27 01:01:25 -0500 
a.call
# => 2015-02-27 01:01:29 -0500 
a.call
# => 2015-02-27 01:01:31 -0500 

b = proc {Time.now}
# => #<Proc:0x000000027811b0@(irb):76> 
b[]
# => 2015-02-27 01:04:26 -0500 
b[]
# => 2015-02-27 01:04:27 -0500 
b.call
# => 2015-02-27 01:04:29 -0500

So now the code we want to run when we access the variable runs each time.  Each of these can also be assigned to a constant within a class.

class Foo
  LAMBDA = lambda {Time.now}
  PROC = proc {Time.now}
  STABBYPROC = ->{Time.now}
  BEGINBLOCK = begin Time.now end

  def Foo.the_time
    Time.now
  end
  METHODBLOCK = Foo.the_time
end

Foo::LAMBDA[]
# => 2015-02-27 01:26:11 -0500 
Foo::LAMBDA[]
# => 2015-02-27 01:26:15 -0500 
Foo::PROC[]
# => 2015-02-27 01:26:28 -0500 
Foo::PROC[]
# => 2015-02-27 01:26:28 -0500 
Foo::STABBYPROC[]
# => 2015-02-27 01:26:34 -0500 
Foo::STABBYPROC[]
# => 2015-02-27 01:26:35 -0500 
Foo::BEGINBLOCK
# => 2015-02-27 01:24:27 -0500 
Foo::BEGINBLOCK
# => 2015-02-27 01:24:27 -0500 
Foo::METHODBLOCK
# => 2015-02-27 01:24:27 -0500 
Foo::METHODBLOCK
# => 2015-02-27 01:24:27 -0500

With this you see the same rules apply.  But what I think is really cool is now you can see a class constant also work as a method with lambdas and procs.

Summary

This was a short one.  I only recently came across the ability to have constants be methods you could call.  I really like using lambda in this way.  I’ve decided to use lambda constants for internal methods in my PolyBelongsTo project.  So they are methods available in the project, but their purpose was for internal use.  Methods I’ve intended for more general use are standards methods and easily accessible.  The reason I chose to go about it this way is that it’s a bit unusual to see a constant lambda out in the wild.  So I felt that would be more of an intention indicator.  Yes I know; it defies the very meaning of the word constant.  I expect there may be some people who may be adamant against this kind of use of constants in open source.  You’re more than welcome to share why it’s important to you.  For me, I’m just a Ruby programmer enjoying the beauty and flexibility that Ruby gives me.

If you haven’t been using lambdas and procs yet then I believe that this shows you some of the value they provide.  There are times you need to defer work to be done.

Have fun!  Please feel free to comment, share, subscribe to my RSS Feed, and follow me on twitter @6ftdan!

God Bless!
-Daniel P. Clark

Image by David via the Creative Commons Attribution-NonCommercial-NoDerivs 2.0 Generic License.