From: shevegen@... Date: 2018-08-18T17:59:21+00:00 Subject: [ruby-core:88546] [Ruby trunk Feature#14609] `Kernel#p` without args shows the receiver Issue #14609 has been updated by shevegen (Robert A. Heiler). I don't mind, personally. To me, the biggest improvement was that we could omit doing: require 'pp' ;) Since I did that a lot in my code. (I love pp; I think I use it more than just p) I personally have not been using (or needing) yield_self or tap so far, so the change would probably not be of immediate benefit to me; but probably also not require of me to change anything either. To the name "tapp" - that name is a bit weird. To me it reads as if we combine "tap" and then add a "p" to it. Reminds me of a joke proposal to condense "end" into "enddd" and such. :D To be fair, I consider the name yield_self to be also weird :D - but matz added an alias called "then" to it if I understand it correctly (though the semantic confuses me a bit as well ... but I don't really want to distract here since I don't really feel too strongly either way; picking good names is not always easy). On a side note, perhaps in the long run we could have something to "experiment" with - like new or changed features in ruby that have not been 100% approved in the sense of a name AND the associated functionality, so we can try them out for some time, which may help build a stronger opinion either way. (I mean this in general, not just in regards to #p here). It may still be best to ask matz again though. Syntax shortcuts (syntactic sugar) has always been an area in ruby where code changes has happened (e. g. yield_self to then, or omitting the end value for infinite ranges and so forth). ---------------------------------------- Feature #14609: `Kernel#p` without args shows the receiver https://bugs.ruby-lang.org/issues/14609#change-73607 * Author: ko1 (Koichi Sasada) * Status: Open * Priority: Normal * Assignee: matz (Yukihiro Matsumoto) * Target version: 2.6 ---------------------------------------- # Abstract `Kernel#p(obj)` prints obj as `inspect`ed. How about to show the receiver if an argument is not given? # Background We recently introduce `yield_self` which encourages block chain. https://zverok.github.io/blog/2018-01-24-yield_self.html Quoted from this article, we can write method chain with blocks: ``` construct_url .yield_self { |url| Faraday.get(url) }.body .yield_self { |response| JSON.parse(response) } .dig('object', 'id') .yield_self { |id| id || '' } .yield_self { |id| "server:#{id}" } ``` There is a small problem at debugging. If we want to see the middle values in method/block chain, we need to insert `tap{|e| p e}`. With above example, ``` construct_url .yield_self { |url| Faraday.get(url) }.body .yield_self { |response| JSON.parse(response) }.tap{|e| p e} # debug print .dig('object', 'id') .yield_self { |id| id || '' }.tap{|e| p e} # debug print .yield_self { |id| "server:#{id}" } ``` # Proposal `obj.p` shows same as `p(obj)`. We can replace `block{...}.tap{|e| p e}` to `block{...}.p` For above example, we can simply add `.p` at the end of line: ``` construct_url .yield_self { |url| Faraday.get(url) }.body .yield_self { |response| JSON.parse(response) }.p # debug print .dig('object', 'id') .yield_self { |id| id || '' }.p # debug print .yield_self { |id| "server:#{id}" } ``` # Compatibility issue (1) Shorthand for `nil` This spec change can introduce compatibility issue because `p` returns `nil` and do not output anything. That is to say, `p` is shorthand of `nil`. Some code-golfers use it. Maybe we can ignore them :p (2) make public method `Kernel#p` is private method, so if we typo `obj.x` to `obj.p` (not sure how it is feasible), it will be `NoMethodError` because of visibility. We need to change this behavior. # Note ## Past proposal and discussion Endoh-san proposed same idea 10+ years ago [ruby-dev:29736] in Japanese. I think we should revisit this idea because of `yield_self` introduction. At this thread, Matz said "simple `p` shows `p(self)`, it is not clear". [ruby-dev:30903] ``` p ���������������������������(p self���������������������������) self.p(obj) ���������������������������������������������(������)������������������������������������ ``` English translation: ``` What the behavior of (I feel strange that it is similar to `p(self)`): p What happen on self.p(obj) ``` ## pp If this proposal is accepted, we also need to change `pp` behavior. ## gems `tapp` method is provided by gem. https://github.com/esminc/tapp I'd thought to propose this method into core. But I found that `p` is more shorter than `tapp`. Disadvantage is `p` is too short and difficult to grep. -- https://bugs.ruby-lang.org/ Unsubscribe: