Sorry folks if this was raised already, but google is not very
useful when asked for “ruby with” or “ruby map single object” …
Is there something like “with” already available? Let me give the
short implementation first so the gurus know right away what I am after:
module Kernel
def with
yield self
end
end
What does it do? It can glue an object and a block together. Just
append “.with {x block}” to your object. What’s that good for?
When I have an array (or range or similar) and I want to do
something with each member, I can already do that by simply adding
“.map {elem do_something_with(elem)}”. The result can be used
transparently within another calculation. #each, #map and #inject
are good candidates for something like that. So far, so good.
Take the following situation:
result= a_long_calculation_start …
… a_very_long_object_calculation …
… calculation_end
What can I do now if I have to apply a function on
“a_very_long_object_calculation” in the example above? Since
a_very_long_object_calculation is not an array, I cannot use
#each/#map/#inject. So let’s put the function call around the
calculation:
Solution 1:
result= a_long_calculation_start …
… function(a_very_long_object_calculation) …
… calculation_end
But what if “function” is an inplace calculation containing of if’s
and loops? Then I have to move all that away from the long object
calculation:
Solution 2:
intermediate= a_very_long_object_calculation
intermediate_result= function(intermediate)
result= a_long_calculation_start …
… intermediate_result …
… calculation_end
Obviously, while reaching the goal, the function is now ugly
disrupted. Even Solution 1 suffers from the fact that I have to at
least put some text into the expression before
a_very_long_object_calculation appears. What would be nice if I
could implement the inplace calculation inside of a block like with
#each, #map or #inject:
result= a_long_calculation_start …
… a_very_long_object_calculation.with{val function(val)} …
… calculation_end
With “with”, the following proportions are solved:

I can put arbitrary functions into the block following #with.

I don’t have to put additional characters before
a_very_long_object_calculation – succeeding calculations are behind
the preceding object calculation.
Am I the first to ask for something like this or is this already
implemented in a way that I couldn’t find it?
BTW: “with” could be renamed to something short and similar – f.e.
.smap (single map), so there could be a .seach (single each) as well
returning “self” after the yield. .sinject is not very useful.
module Kernel
def smap
yield self
end
def seach
yield self
self
end
end
Thanks,
 Matthias