|how do you know when to put a variable between pipes?|

A_Love_of_Surf · 11 October 2007 01:35

Hi i am at about page fifty in the pickaxe book, and i have a
question. I see a lot of examples of a block that starts with |
SomeVar> and I dont really understand how you know when you can do
this or what the value will be that is passed to the variable. What
is the name of this construct or the var that goes in pipes? Thank
you

Morton_Goldberg · 11 October 2007 02:27

In the PDF version of Pickaxe, this is explained beginning on p. 47 (p.50 in the printed text). Read the explanation that goes along with the fib_up_to example. More info can be found in Chapter 22 under the heading: Blocks, Closures, and Proc Objects.

A quick and dirty explanation is the the vertical bars at the beginning of a block delimit the block's formal arguments. When the block is evaluated by a yield expression, the actually arguments passed to the yield will be assigned to the formal arguments in a manner similar to a function call. Just as you can't call a function without knowing what arguments it takes, you must know what arguments a method accepting a block passes to the block in order to write a block for that method. It is a matter of documentation.

Regards, Morton

···

On Oct 10, 2007, at 9:35 PM, A Love of Surf wrote:

Hi i am at about page fifty in the pickaxe book, and i have a
question. I see a lot of examples of a block that starts with |
SomeVar> and I dont really understand how you know when you can do
this or what the value will be that is passed to the variable. What
is the name of this construct or the var that goes in pipes? Thank
you

7stud1 · 11 October 2007 02:46

A Love of Surf wrote:

Hi i am at about page fifty in the pickaxe book, and i have a
question. I see a lot of examples of a block that starts with
>SomeVar>
and I dont really understand how you know when you can do
this

Whenever a method specified to the left of the block has a yield
statement in its definition, the method is going to pass a value to the
block. For example:

def my_method
yield 10
end

my_method {|num| puts num * 2} #20

How do you know if one of ruby's methods has a yield statement in its
definition? You could look at the source code, but for now just
remember that when the book says that a method is an iterator, then the
method is going to send one or more values to a block. Or, if the book
introduces a method and also uses a block after the method call, then
you know the definition of the method has a yield statement in it, which
just means it is going to send one or more values to the block. What
you should be trying to figure out is:

1) what values the method call sends to the block

2) what the return value of method call is

The most common iterator is 'each'. When called on an array, each sends
each element of the array to the block one at a time.

You should make frequent use of the reference section in the back of the
book to look up methods and read about what values they send to a block,
and what the return value of the method call is.

or what the value will be that is passed to the variable.

It depends on how the method you call is defined:

def my_method
yield 20
yield 30
end

my_method {|num| puts num * 2} #40 60

What
is the name of this construct or the var that goes in pipes?

The construct is exactly like a method definition, and it is called a
"block". The thing in the pipes is the same thing as a parameter
variable in a method definition.

You are calling a method:

my_method

with a block specified on the right:

{|num| puts num * 2}

The block is just like a method, but it doesn't have a name.

Backing up a little, you can define methods that call each other like
this:

def my_method
calculate(10)
end

def calculate(num)
puts num * 2
end

my_method #20

The same thing is happening with a method call that is followed by a
block: you are calling a method that sends values to another method(the
block).

···

--
Posted via http://www.ruby-forum.com/\.

Dante_Regis · 11 October 2007 02:51

Another way to explain, complementing our friend Morton, is that when you
use a block, you are kind of inserting code inside another function. Let me
give you an example to help you understand.

Let's take the "each" method of an array. You use this method when you want
to do something with every item inside the array.

You could call something like:
my_string = ""
my_array.each do |foo|
puts foo
my_string += " AND #{foo}"
end

Now, why did we place that |foo| on the block? Imagine that the "each"
method on the array is implemented like this:

def each
   i = 0
   while i <= self.size
      current_item = self[i]
      yield(current_item)
   end
   self
end

Now notice two things: First, the "each" method itself has no parameters,
though it could have. They would have nothing to do with the pipes, though.
Second, look at the yield line. what yield do is to call the block that you
gave to this function. Since the yield is inside the while statement, it
will run as many times as there are items on your array. And, as i said it
is just like putting your piece of code inside the "each" (or any other)
method. It would be like you've written

def my_each
   my_string = ""
   i = 0
   while i <= self.size
      current_item = self[i]
      # ----
      puts current_item
      my_string += " AND #{foo}"
      # -----
   end
   self
end

Now, the actual values that the block will take will clearly depend on the
function that you are using. SInce yield can pass as many parameter as it
wants (you could have something like yield a, b, c, d, e, ...) you should
see the documentation of the function to know which values are passed to the
block.

It's obviously not a technical explanation, and some things are
intentionally wrong (the each method for array is implemented in C, for
instance), but maybe it helps you understand.

Hope this helps

A_Love_of_Surf · 11 October 2007 06:05

Thank you so much for your help, I was having a tough time with that
but you cleared it up for me.

···

On Oct 10, 7:46 pm, 7stud -- <dol...@excite.com> wrote:

A Love of Surf wrote:

> Hi i am at about page fifty in the pickaxe book, and i have a
> question. I see a lot of examples of a block that starts with
> >SomeVar>
> and I dont really understand how you know when you can do
> this

Whenever a method specified to the left of the block has a yield
statement in its definition, the method is going to pass a value to the
block. For example:

def my_method
  yield 10
end

my_method {|num| puts num * 2} #20

How do you know if one of ruby's methods has a yield statement in its
definition? You could look at the source code, but for now just
remember that when the book says that a method is an iterator, then the
method is going to send one or more values to a block. Or, if the book
introduces a method and also uses a block after the method call, then
you know the definition of the method has a yield statement in it, which
just means it is going to send one or more values to the block. What
you should be trying to figure out is:

1) what values the method call sends to the block

2) what the return value of method call is

The most common iterator is 'each'. When called on an array, each sends
each element of the array to the block one at a time.

You should make frequent use of the reference section in the back of the
book to look up methods and read about what values they send to a block,
and what the return value of the method call is.

> or what the value will be that is passed to the variable.

It depends on how the method you call is defined:

def my_method
  yield 20
  yield 30
end

my_method {|num| puts num * 2} #40 60

> What
> is the name of this construct or the var that goes in pipes?

The construct is exactly like a method definition, and it is called a
"block". The thing in the pipes is the same thing as a parameter
variable in a method definition.

You are calling a method:

my_method

with a block specified on the right:

{|num| puts num * 2}

The block is just like a method, but it doesn't have a name.

Backing up a little, you can define methods that call each other like
this:

def my_method
  calculate(10)
end

def calculate(num)
  puts num * 2
end

my_method #20

The same thing is happening with a method call that is followed by a
block: you are calling a method that sends values to another method(the
block).

--
Posted viahttp://www.ruby-forum.com/.

Dante_Regis · 11 October 2007 02:52

My example was wrong. Where it reads

def my_each
   my_string = ""
   i = 0
   while i <= self.size
      current_item = self[i]
      # ----
      puts current_item
      my_string += " AND #{foo}"
      # -----
   end
   self
end

it should read

def my_each
   my_string = ""
   i = 0
   while i <= self.size
      current_item = self[i]
      # ----
      puts current_item
      my_string += " AND #{current_item}"
      # -----
   end
   self
end

···

On 10/10/07, Dante Regis <dante.regis@gmail.com> wrote:

Another way to explain, complementing our friend Morton, is that when you
use a block, you are kind of inserting code inside another function. Let me
give you an example to help you understand.

Let's take the "each" method of an array. You use this method when you
want to do something with every item inside the array.

You could call something like:
my_string = ""
my_array.each do |foo|
  puts foo
  my_string += " AND #{foo}"
end

Now, why did we place that |foo| on the block? Imagine that the "each"
method on the array is implemented like this:

def each
   i = 0
   while i <= self.size
      current_item = self[i]
      yield(current_item)
   end
   self
end

Now notice two things: First, the "each" method itself has no parameters,
though it could have. They would have nothing to do with the pipes, though.
Second, look at the yield line. what yield do is to call the block that you
gave to this function. Since the yield is inside the while statement, it
will run as many times as there are items on your array. And, as i said it
is just like putting your piece of code inside the "each" (or any other)
method. It would be like you've written

def my_each
   my_string = ""
   i = 0
   while i <= self.size
      current_item = self[i]
      # ----
      puts current_item
      my_string += " AND #{foo}"
      # -----
   end
   self
end

Now, the actual values that the block will take will clearly depend on the
function that you are using. SInce yield can pass as many parameter as it
wants (you could have something like yield a, b, c, d, e, ...) you should
see the documentation of the function to know which values are passed to the
block.

It's obviously not a technical explanation, and some things are
intentionally wrong (the each method for array is implemented in C, for
instance), but maybe it helps you understand.

Hope this helps

Topic		Replies	Views
Confusion with block local variable declaration with block variable declaration within the pipe `\|` ruby-talk	16	216	11 March 2013
Assigning a block to a variable in Ruby ruby-talk	29	203	17 December 2005
New to Ruby. Specific syntax question ruby-talk	7	133	17 July 2008
\|song\| Not documented in Pickaxe Book ruby-talk	10	136	22 December 2006
Block.call vs. yield ruby-talk	43	272	30 April 2003

|how do you know when to put a variable between pipes?|

Related topics