From: hanmac@... Date: 2017-11-30T14:39:50+00:00 Subject: [ruby-core:84007] [Ruby trunk Feature#14145] Proposal: Better Method#inspect Issue #14145 has been updated by Hanmac (Hans Mackowiak). @zverok some changes for your code: use Method#owner to get the class/module where the method is defined that can make a difference for Singleton methods on a non-module object Thema: i think this change would be okay, but i am indifferent about the C-level funtions for my bindings i do overload the methods depending on the type and amount of parameters no need to show more of the code but this is the documenation block ~~~ cpp /* * call-seq: * contains?(x, y) -> bool * contains?(point) -> bool * contains?(rect) -> bool * * return true if the point or the rect is (not strictly) inside this rect * ===Arguments * * x and y are Integer * * pos is a WX::Point * * rect is a WX::Rect * ===Return value * bool * */ ~~~ as you guys can see there are different cases, because how ruby defines methods and use rb_scan_args, my function returns parameters also just [:rest] for most Ruby C-Api functions, there might be a way to make parameters return something useful, but that's probably not the case for all functions ---------------------------------------- Feature #14145: Proposal: Better Method#inspect https://bugs.ruby-lang.org/issues/14145#change-68089 * 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>