def proc_return
p = Proc.new {return "I am here..."}
puts p.call
"...but not here."
end

def lambda_return
p = lambda { return "I am here..." }
puts p.call
"...and I am here too."
end

def implicit_block
puts "Enter."
yield
puts "Exit."
end

def explicit_block &block
puts "Enter."
block.call
puts "Exit."
end

# Here we have a standard block of code that prints words from the "words" array.
puts "01 Blocks with do...end\n\n"
words = %w{one two three four five}
words.each do |word|
puts "[#{word}] "
end

# Here is another block of code, same as above, but using a more condensed syntax for blocks.
# NOTE: {} syntax takes precidence over do...end syntax and is great for one-liners and keeping your code condensed.
puts "\n02 Blocks with {}\n\n"
words.each {|word| puts "[#{word}] "}

# The following demonstrates a proc being created and returning a message. New procs, when returning, will exit their
# enclosing scope. Notice how the last string is not returned.
puts "\n03 Proc Return\n\n"
puts proc_return

# The following demonstrates a lambda being created and returned. Notice how returning from the lambda does not
# exit the enclosing method.
puts "\n04 Lamda Return\n\n"
puts lambda_return

# Demonstrates an implicit block call. Pay attention to the block being passed in and the "yeild" statement
# within the method.
puts "\n05 Implicit Block\n\n"
implicit_block {puts "In block."}

[one]
[two]
[three]
[four]
[five]

02 Blocks with {}

[one]
[two]
[three]
[four]
[five]

03 Proc Return

I am here...

04 Lamda Return

I am here...
...and I am here too.

05 Implicit Block

Enter.
In block.
Exit.

06 Explicit Block