Issue #19300 has been updated by mame (Yusuke Endoh). Useless history talk. I once asked matz why Kernel exists. If I remember correctly, matz said the following. * In the beginning, there was a usage distinction of putting global function-like methods (exit, eval, etc.) in Kernel and method-like methods (clone, kind_of?, etc.) in Object. * However, this distinction was cumbersome to manage and had little advantage, so gradually everything was placed in Kernel. In ruby 0.49 (1994/07/18), the earliest code available, we can see this distinction. ```` rb_define_func(C_Kernel, "exit", Fexit, -2); rb_define_func(C_Kernel, "eval", Feval, 1); ... rb_define_method(C_Object, "is_kind_of", obj_is_kind_of, 1); rb_define_method(C_Object, "clone", Fobj_clone, 0); ```` However, there was already some confusion; `Kernel#class` and `Kernel#hash` were defined in Kernel. (Incidentally, a little interestingly, Kernel was a class, not a module, at that time.) After that, it looks like matz did some design trial and error; a new class called `Builtin` was introduced between Kernel and Object, and every global function-like methods were moved to Builtin. However this was eventually reverted. Then, everything was gradually moved to Kernel, as matz said. As of ruby 0.95 (1995/12/21), `Object#clone` moved to Kernel, and as of ruby 1.0-961125, `Object#is_kind_of` moved to Kernel (as `Kernel#kind_of?`). In ruby 1.0-971002, `Object#inspect`, which was maybe the last method defined directly under Object, was moved to Kernel. I don't know why rdoc introduced the trick to replace `rb_mKernel` with `rb_cObject`, but the author (Dave Thomas) maybe remembered how Kernel used to be. ---------------------------------------- Feature #19300: Move public methods from Kernel to Object https://bugs.ruby-lang.org/issues/19300#change-101067 * Author: zverok (Victor Shepelev) * Status: Rejected * Priority: Normal ---------------------------------------- In my understanding, `Kernel` is a container for methods that are perceived as "global", and are available inside every objects as its private methods, like `puts` ```ruby class A def foo = puts "foo" end a = A.new a.foo # prints "foo" a.puts 'bar' # private method `puts' called for #<A:0x00007f39a683db28> (NoMethodError) ``` There are, though, exactly three (if I am not missing something) methods that, **according to documentation**, break this intuition and belong to [Kernel](https://docs.ruby-lang.org/en/master/Kernel.html): * `clone` * `tap` * `then` All those methods are public method for a receiver, and they mostly make sense with an explicit receiver. The most confusing of them is `#clone`, which is close cousin of `#dup`, but it is [Kernel#clone](https://docs.ruby-lang.org/en/master/Kernel.html#method-i-clone) and [Object#dup](https://docs.ruby-lang.org/en/master/Object.html#method-i-dup). This state of things is mostly harmless in practical code, but very inconvenient for teaching, reasoning about the meaning of modules and objects, and lookup for documentation. **But**, in the description above, **according to documentation** is important statement. Because according to introspection, method definitions are spread differently: ```ruby puts "Public" Object.new .then { |o| o.methods.group_by { o.method(_1).owner } } .each { puts "#{_1}: #{_2.sort.join(', ')}" } puts puts "Private:" Object.new .then { |o| o.private_methods.group_by { o.method(_1).owner } } .each { puts "#{_1}: #{_2.sort.join(', ')}" } ``` Output: ``` Public Kernel: !~, <=>, ===, class, clone, define_singleton_method, display, dup, enum_for, eql?, extend, freeze, frozen?, hash, inspect, instance_of?, instance_variable_defined?, instance_variable_get, instance_variable_set, instance_variables, is_a?, itself, kind_of?, method, methods, nil?, object_id, private_methods, protected_methods, public_method, public_methods, public_send, remove_instance_variable, respond_to?, send, singleton_class, singleton_method, singleton_methods, tap, then, to_enum, to_s, yield_self BasicObject: !, !=, ==, __id__, __send__, equal?, instance_eval, instance_exec Private: Kernel: Array, Complex, Float, Hash, Integer, Rational, String, __callee__, __dir__, __method__, `, abort, at_exit, autoload, autoload?, binding, block_given?, caller, caller_locations, catch, eval, exec, exit, exit!, fail, fork, format, gem, gem_original_require, gets, global_variables, initialize_clone, initialize_copy, initialize_dup, iterator?, lambda, load, local_variables, loop, open, p, pp, print, printf, proc, putc, puts, raise, rand, readline, readlines, require, require_relative, respond_to_missing?, select, set_trace_func, sleep, spawn, sprintf, srand, syscall, system, test, throw, trace_var, trap, untrace_var, warn BasicObject: initialize, method_missing, singleton_method_added, singleton_method_removed, singleton_method_undefined ``` E.g., internally, `Object` doesn't have _any_ method defined, and is just a `BasicObject` with `Kernel` included. So, there are three questions/proposals: 1. Does this disposition has some internal sense, or it is more of a historical thing? 2. Can it be changed so that public methods belonged to `Object` instead of `Kernel`? 3. If the answer to (2) is "no", can at least docs for `clone`, `tap` and `then` be adjusted to follow other public methods in pretending they are `Object`'s features? -- https://bugs.ruby-lang.org/