From: "sawa (Tsuyoshi Sawada)" <noreply@...>
Date: 2022-04-15T09:30:01+00:00
Subject: [ruby-core:108256] [Ruby master Feature#18736] self-p for method chain

Issue #18736 has been updated by sawa (Tsuyoshi Sawada).


It just looks too ugly to me. What do you gain from passing the block to `sp` instead of the method that is originally supposed to handle it? The following conventional way is much more straightforward. (In addition, in your first example, why are you using `p ...` in one place instead of `sp`? It is inconsistent.)

```ruby
[1, 4, 9].tap{|x| p x}.map{|x| x**2}.tap{|x| p x}
#>> [1, 16, 81]
[1,2,3].tap{|x| p "my List = #{x}"}
#>>"my List = [1, 2, 3]"
[1,2,3].sum(-10).tap{|x| p x}
#>> -4
[1,2,3].map{|x| x**2}.tap{|x| p x}
#>>[1, 4, 9]
[1,2,3].sum("", &:to_s).tap{|x| p x}
#>>"123"
```

You may come to think that you rather want a method that would do `tap{|x| p x}`, but I think that was already proposed various times, and proposing that here would be a duplicate.

----------------------------------------
Feature #18736: self-p for method chain
https://bugs.ruby-lang.org/issues/18736#change-97273

* Author: aDAVISk (Akito D. Kawamura)
* Status: Open
* Priority: Normal
----------------------------------------
You may want to check object with `p` method at the middle of a method chain.
Here is my recomendation.
 
```ruby
class Object
  def sp(method=nil, *args, &block)
    if method
        Kernel.p self.public_send(method, *args, &block)
    elsif block_given?
        Kernel.p block.call(self)
    else
      Kernel.p self
    end
    return self
  end
end
```

Example of usage:
1) check itself in the middle of a method-call
```ruby
p [1,2,3].map{|x| x**2}.sp.map{|x| x**2}
```
- output
```
[1,4,9]
[1,16,81]
```
2) check its value in some string format
```ruby
[1,2,3].sp{|x| "my List = #{x}"}
```
- output
```
"my List = [1,2,3]"
```
3) check its sum with an initial value
```ruby
[1,2,3].sp(:sum,-10)
```
- output
```
-4
```
4) check its value with a `map` operation
```ruby
[1,2,3].sp(:map){|x| x**2}
```
- output
```
[1,4,9]
```
5) check its value connected in string
```ruby
[1,2,3].sp(:sum,""){|x| x.to_s}
```
- output
```
"123"
```

---
Your brush-up comments are welcomed. thx.



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>