[#4766] Wiki — "Glen Stampoultzis" <trinexus@...>

21 messages 2000/09/04
[#4768] RE: Wiki — "NAKAMURA, Hiroshi" <nahi@...> 2000/09/04

Hi, Glen,

[#4783] Re: Wiki — Masatoshi SEKI <m_seki@...> 2000/09/04

[#4785] Re: Wiki — "NAKAMURA, Hiroshi" <nakahiro@...> 2000/09/05

Howdy,

[#4883] Re-binding a block — Dave Thomas <Dave@...>

16 messages 2000/09/12

[#4930] Perl 6 rumblings -- RFC 225 (v1) Data: Superpositions — Conrad Schneiker <schneik@...>

Hi,

11 messages 2000/09/15

[#4936] Ruby Book Eng. translation editor's questions — Jon Babcock <jon@...>

20 messages 2000/09/16

[#5045] Proposal: Add constants to Math — Robert Feldt <feldt@...>

15 messages 2000/09/21

[#5077] Crazy idea? infix method calls — hal9000@...

This is a generalization of the "in" operator idea which I

17 messages 2000/09/22

[#5157] Compile Problem with 1.6.1 — Scott Billings <aerogems@...>

When I try to compile Ruby 1.6.1, I get the following error:

15 messages 2000/09/27

[ruby-talk:4810] Re: Piping in Ruby?

From: schneik@...
Date: 2000-09-06 18:22:19 UTC
List: ruby-talk #4810

[Resending to ruby-talk ML; the original _newsgroup_ post seems to have
disappeared _before_ reaching comp.lang.ruby.]

Dave Thomas wrote:

> In the second case, the trick is the collect method:
>
>    list.grep(/fred/).collect {|i| convert(i)} .each {|i| code... }
>
> Collect takes an enumerable collection and returns a new array where
> each element is some mapping of the original collection. You can then
> further process that resulting array. In the example above I've used
> 'each', just as you did in your original. In reality, you can keep
> expanding this array pipeline indefinitely
>
>    list.collect {|i| doThing1(i) } .
>         collect {|i| doThing2(i) } .
>         collect {|i| doThing3(i) } .
>         collect {|i| doThing4(i) } .
>         collect {|i| doThing5(i) } ... etc

This looked like such a cool way to "compile" a variable sequence of text
processing tasks specified from a GUI that I just had to try it out.
However I was surprised by the results.

====================================================
# cat x.rb
#!/usr/bin/env ruby

def x(list)
    p list

    p list.collect { |i| i.sub(/.*/, "1_#{$&}_1") }

    p list.collect { |i| i.sub(/.*/, "1_#{$&}_1") } .
           collect { |i| i.sub(/.*/, "2_#{$&}_2") }

    print "\n"
end

x( %w(a) )
x( %w(a b c d) )
====================================================

====================================================
# ruby -w x.rb
["a"]
["1__1"]
["2_a_2"]

["a", "b", "c", "d"]
["1__1", "1_a_1", "1_b_1", "1_c_1"]
["2_d_2", "2_1_d_1_2", "2_1_a_1_2", "2_1_b_1_2"]

====================================================

What am I overlooking here? Nested iterator sequencing? Variable scoping
and lifetime?

In the unlikely case that I'm not missing something that should be utterly
obvious,

====================================================
# ruby -v
ruby 1.6.0 (2000-08-31) [rs6000-aix4.3.2.0]
====================================================

Conrad Schneiker
(This note is unofficial and subject to improvement without notice.)



In This Thread

Prev Next