From: ko1@... Date: 2019-03-11T06:30:17+00:00 Subject: [ruby-core:91754] [Ruby trunk Feature#14145] Proposal: Better Method#inspect Issue #14145 has been updated by ko1 (Koichi Sasada). Discussion at dev-meeting https://bugs.ruby-lang.org/issues/15614: * eregon and ko1 want to show `source_location`. * with parameters? or without parameters? * ko1: I think parameters are too long to show with `source_location` * matz: `source_location` is longer than parameters. * several people are positive to show both. * znz: `Proc#inspect` shows `source_lcoation`, so I want to know it on Method, too. other discussion: * how about to show rdoc entry? * github url? * show source code? * extend by clicking is cool, like on Jupyter environment. * extensible with gem? * really useful to know parameters? ---------------------------------------- Feature #14145: Proposal: Better Method#inspect https://bugs.ruby-lang.org/issues/14145#change-77030 * Author: zverok (Victor Shepelev) * Status: Open * Priority: Normal * Assignee: * Target version: ---------------------------------------- The idea: When investigating (in example scripts, debugger or console) the library you are unfamiliar with, Ruby's reflection is very useful mechanism to understand "what it can": classes, modules, their constants, methods and so on. I propose to expose a bit more information Ruby has internally in `Method#inspect`: ```ruby # before: some_interesting_object.method(:foo) # => #<Method Klass#foo> # after: some_interesting_object.method(:foo) # => #<Method Klass#foo(first_arg, *other_args, keyword_arg:)> ``` Dead-naive implementation: ```ruby class Method def signature recv = case receiver when Module "#{receiver.name}." else "#{receiver.class}#" end parameters.map.with_index { |(type, name), i| case type when :req then "#{name || "param#{i+1}"}" when :opt then "#{name || "param#{i+1}"} = <default>" when :keyreq then "#{name || "kw#{i+1}"}:" when :key then "#{name || "kwparam#{i+1}"}: <default>" when :rest then "*#{name || "rest"}" when :keyrest then "**#{name || "kwrest"}" end }.join(', ').prepend("#{recv}#{name}(") << ")" end def inspect "#<#{self.class.name} #{signature}>" end end ``` This works "sub-optimal" for methods implemented in C, yet pretty decently for Ruby-implemented methods: ```ruby # C method, default param names [1,2,3].method(:at) # => #<Method Array#at(param1)> # Ruby method, proper param names CGI.method(:escape) # => #<Method CGI.escape(string)> Addressable::URI.method(:parse) # => #<Method Addressable::URI.parse(uri)> Addressable::URI.method(:join) => #<Method Addressable::URI.join(*uris)> # We can't extract default values, but at least we can say they are there Addressable::URI.method(:heuristic_parse) # => #<Method Addressable::URI.heuristic_parse(uri, hints = <default>)> ``` If the proposal is accepted, I am ready to implement it properly in C (for all callable objects: `Method`, `UnboundMethod`, `Proc`) -- 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>