Ruby – When to use lambda, when to use Proc.new

lambdaprocruby

In Ruby 1.8, there are subtle differences between proc/lambda on the one hand, and Proc.new on the other.

What are those differences?
Can you give guidelines on how to decide which one to choose?
In Ruby 1.9, proc and lambda are different. What's the deal?

Best Answer

Another important but subtle difference between procs created with lambda and procs created with Proc.new is how they handle the return statement:

In a lambda-created proc, the return statement returns only from the proc itself
In a Proc.new-created proc, the return statement is a little more surprising: it returns control not just from the proc, but also from the method enclosing the proc!

Here's lambda-created proc's return in action. It behaves in a way that you probably expect:

def whowouldwin

  mylambda = lambda {return "Freddy"}
  mylambda.call

  # mylambda gets called and returns "Freddy", and execution
  # continues on the next line

  return "Jason"

end


whowouldwin
#=> "Jason"

Now here's a Proc.new-created proc's return doing the same thing. You're about to see one of those cases where Ruby breaks the much-vaunted Principle of Least Surprise:

def whowouldwin2

  myproc = Proc.new {return "Freddy"}
  myproc.call

  # myproc gets called and returns "Freddy", 
  # but also returns control from whowhouldwin2!
  # The line below *never* gets executed.

  return "Jason"

end


whowouldwin2         
#=> "Freddy"

Thanks to this surprising behavior (as well as less typing), I tend to favor using lambda over Proc.new when making procs.

Ruby 1.9 - Major Features

Performance
Threads/Fibers
Encoding/Unicode
gems is (mostly) built-in now
if statements do not introduce scope in Ruby.

What's changed?

Single character strings.

Ruby 1.9

irb(main):001:0> ?c
=> "c"

Ruby 1.8.6

irb(main):001:0> ?c
=> 99

String index.

Ruby 1.9

irb(main):001:0> "cat"[1]
=> "a"

Ruby 1.8.6

irb(main):001:0> "cat"[1]
=> 97

{"a","b"} No Longer Supported

Ruby 1.9

irb(main):002:0> {1,2}
SyntaxError: (irb):2: syntax error, unexpected ',', expecting tASSOC

Ruby 1.8.6

irb(main):001:0> {1,2}
=> {1=>2}

Action: Convert to {1 => 2}

`Array.to_s` Now Contains Punctuation

Ruby 1.9

irb(main):001:0> [1,2,3].to_s
=> "[1, 2, 3]"

Ruby 1.8.6

irb(main):001:0> [1,2,3].to_s
=> "123"

Action: Use .join instead

Colon No Longer Valid In When Statements

Ruby 1.9

irb(main):001:0> case 'a'; when /\w/: puts 'word'; end
SyntaxError: (irb):1: syntax error, unexpected ':',
expecting keyword_then or ',' or ';' or '\n'

Ruby 1.8.6

irb(main):001:0> case 'a'; when /\w/: puts 'word'; end
word

Action: Use semicolon, then, or newline

Block Variables Now Shadow Local Variables

Ruby 1.9

irb(main):001:0> i=0; [1,2,3].each {|i|}; i
=> 0
irb(main):002:0> i=0; for i in [1,2,3]; end; i
=> 3

Ruby 1.8.6

irb(main):001:0> i=0; [1,2,3].each {|i|}; i
=> 3

`Hash.index` Deprecated

Ruby 1.9

irb(main):001:0> {1=>2}.index(2)
(irb):18: warning: Hash#index is deprecated; use Hash#key
=> 1
irb(main):002:0> {1=>2}.key(2)
=> 1

Ruby 1.8.6

irb(main):001:0> {1=>2}.index(2)
=> 1

Action: Use Hash.key

`Fixnum.to_sym` Now Gone

Ruby 1.9

irb(main):001:0> 5.to_sym
NoMethodError: undefined method 'to_sym' for 5:Fixnum

Ruby 1.8.6

irb(main):001:0> 5.to_sym
=> nil

(Cont'd) Ruby 1.9

# Find an argument value by name or index.
def [](index)
  lookup(index.to_sym)
end

svn.ruby-lang.org/repos/ruby/trunk/lib/rake.rb

Hash Keys Now Unordered

Ruby 1.9

irb(main):001:0> {:a=>"a", :c=>"c", :b=>"b"}
=> {:a=>"a", :c=>"c", :b=>"b"}

Ruby 1.8.6

irb(main):001:0> {:a=>"a", :c=>"c", :b=>"b"}
=> {:a=>"a", :b=>"b", :c=>"c"}

Order is insertion order

Stricter Unicode Regular Expressions

Ruby 1.9

irb(main):001:0> /\x80/u
SyntaxError: (irb):2: invalid multibyte escape: /\x80/

Ruby 1.8.6

irb(main):001:0> /\x80/u
=> /\x80/u

`tr` and `Regexp` Now Understand Unicode

Ruby 1.9

unicode(string).tr(CP1252_DIFFERENCES, UNICODE_EQUIVALENT).
  gsub(INVALID_XML_CHAR, REPLACEMENT_CHAR).
  gsub(XML_PREDEFINED) {|c| PREDEFINED[c.ord]}

`pack` and `unpack`

Ruby 1.8.6

def xchr(escape=true)
  n = XChar::CP1252[self] || self
  case n when *XChar::VALID
    XChar::PREDEFINED[n] or 
      (n>128 ? n.chr : (escape ? "&##{n};" : [n].pack('U*')))
  else
    Builder::XChar::REPLACEMENT_CHAR
  end
end
unpack('U*').map {|n| n.xchr(escape)}.join

`BasicObject` More Brutal Than `BlankSlate`

Ruby 1.9

irb(main):001:0> class C < BasicObject; def f; Math::PI; end; end; C.new.f
NameError: uninitialized constant C::Math

Ruby 1.8.6

irb(main):001:0> require 'blankslate'
=> true
irb(main):002:0> class C < BlankSlate; def f; Math::PI; end; end; C.new.f
=> 3.14159265358979

Action: Use ::Math::PI

Delegation Changes

Ruby 1.9

irb(main):002:0> class C < SimpleDelegator; end => nil irb(main):003:0> C.new('').class => String

Ruby 1.8.6

irb(main):002:0> class C < SimpleDelegator; end => nil irb(main):003:0> C.new('').class => C irb(main):004:0>

~~Defect 17700~~

Use of $KCODE Produces Warnings

Ruby 1.9

irb(main):004:1> $KCODE = 'UTF8'
(irb):4: warning: variable $KCODE is no longer effective; ignored
=> "UTF8"

Ruby 1.8.6

irb(main):001:0> $KCODE = 'UTF8'
=> "UTF8"

`instance_methods` Now an Array of Symbols

Ruby 1.9

irb(main):001:0> {}.methods.sort.last
=> :zip

Ruby 1.8.6

irb(main):001:0> {}.methods.sort.last
=> "zip"

Action: Replace instance_methods.include? with method_defined?

Source File Encoding

Basic

# coding: utf-8

Emacs

# -*- encoding: utf-8 -*-

Shebang

#!/usr/local/rubybook/bin/ruby
# encoding: utf-8

Real Threading

Race Conditions
Implicit Ordering Assumptions
Test Code

What's New?

Alternate Syntax for Symbol as Hash Keys

Ruby 1.9

{a: b}

redirect_to action: show

Ruby 1.8.6

{:a => b}

redirect_to :action => show

Block Local Variables

Ruby 1.9

[1,2].each {|value; t| t=value*value}

Inject Methods

Ruby 1.9

[1,2].inject(:+)

Ruby 1.8.6

[1,2].inject {|a,b| a+b}

`to_enum`

Ruby 1.9

short_enum = [1, 2, 3].to_enum
long_enum = ('a'..'z').to_enum
loop do
  puts "#{short_enum.next} #{long_enum.next}"
end

No block? Enum!

Ruby 1.9

e = [1,2,3].each

Lambda Shorthand

Ruby 1.9

p = -> a,b,c {a+b+c}
puts p.(1,2,3)
puts p[1,2,3]

Ruby 1.8.6

p = lambda {|a,b,c| a+b+c}
puts p.call(1,2,3)

Complex Numbers

Ruby 1.9

Complex(3,4) == 3 + 4.im

Decimal Is Still Not The Default

Ruby 1.9

irb(main):001:0> 1.2-1.1
=> 0.0999999999999999

Regex “Properties”

Ruby 1.9

/\p{Space}/

Ruby 1.8.6

/[:space:]/

Splat in Middle

Ruby 1.9

def foo(first, *middle, last)

(->a, *b, c {p a-c}).(*5.downto(1))

Fibers

Ruby 1.9

f = Fiber.new do
  a,b = 0,1
  Fiber.yield a
  Fiber.yield b
  loop do
    a,b = b,a+b
    Fiber.yield b
  end
end
10.times {puts f.resume}

Break Values

Ruby 1.9

match =
   while line = gets
     next if line =~ /^#/
     break line if line.find('ruby')
   end

“Nested” Methods

Ruby 1.9

def toggle
  def toggle
    "subsequent times"
  end
  "first time"
end

HTH!

Python – No Multiline Lambda in Python: Why not

Guido van Rossum (the inventor of Python) answers this exact question himself in an old blog post.
Basically, he admits that it's theoretically possible, but that any proposed solution would be un-Pythonic:

"But the complexity of any proposed solution for this puzzle is immense, to me: it requires the parser (or more precisely, the lexer) to be able to switch back and forth between indent-sensitive and indent-insensitive modes, keeping a stack of previous modes and indentation level. Technically that can all be solved (there's already a stack of indentation levels that could be generalized). But none of that takes away my gut feeling that it is all an elaborate Rube Goldberg contraption."

Best Answer

Related Solutions

Ruby – the difference between Ruby 1.8 and Ruby 1.9

Ruby 1.9 - Major Features

What's changed?

Single character strings.

String index.

{"a","b"} No Longer Supported

Array.to_s Now Contains Punctuation

Colon No Longer Valid In When Statements

Block Variables Now Shadow Local Variables

Hash.index Deprecated

Fixnum.to_sym Now Gone

Hash Keys Now Unordered

Stricter Unicode Regular Expressions

tr and Regexp Now Understand Unicode

pack and unpack

BasicObject More Brutal Than BlankSlate

Delegation Changes

Use of $KCODE Produces Warnings

instance_methods Now an Array of Symbols

Source File Encoding

Basic

Emacs

Shebang

Real Threading

What's New?

Alternate Syntax for Symbol as Hash Keys

Block Local Variables

Inject Methods

to_enum

No block? Enum!

Lambda Shorthand

Complex Numbers

Decimal Is Still Not The Default

Regex “Properties”

Splat in Middle

Fibers

Break Values

“Nested” Methods

Python – No Multiline Lambda in Python: Why not

Related Topic

`Array.to_s` Now Contains Punctuation

`Hash.index` Deprecated

`Fixnum.to_sym` Now Gone

`tr` and `Regexp` Now Understand Unicode

`pack` and `unpack`

`BasicObject` More Brutal Than `BlankSlate`

`instance_methods` Now an Array of Symbols

`to_enum`