list.filter is ok! Filtering is an action that applies to a list

false.not is borderline but if read as false.negate it makes sense (negating is an action that applies to a Boolean value). That wording screws the chaining though.

5.times is where the pattern breaks: times is not an action that applies to a number (nor an action at all). It’s the block the one that should repeat/iterate - but Ruby breaks the rule there and blocks are not an object (!). If they were you could block.repeat(5) which IMO is cleaner.

I think I feel you. However, I think you have conceptually loaded "method" with more meaning. I think a less loaded way to think of the object/method is that the object is the first argument to the method that is called on it. So

    5.times { puts 'hi' }

    times(5) { puts 'hi' }

    my_function = -> { puts 'hi' } 
    repeat_times(5, &my_function)

After my foray into functional programming, I actually ended up appreciating Ruby more, because it lets you have it both ways: program your computer directly, and harness functional concepts. Since computer hardware is not functional I don't want the extra ceremony and abstraction over it for the sake of purity.

All that said, going back and forth between Ruby and Elixir really conceptually crystallized for me that the method call receiver is basically just the first argument to the method, accessible with the keyword `self` (which in Python is made explicit for example).

There is a bit of personal preference in what "applies to a number", but I see what you mean.

As a slight correction, a block is indeed an object! They are received by methods as an instance of the Proc class:

  def inspects_block(&block)
    puts block
    puts block.class
  end
  inspects_block { "foo" }
  # => #<Proc:0x0000000000000000>
  # => Proc

  class Proc
    def repeat(n)
      n.times { self.call }
    end
  end
  ->{ puts("foo") }.repeat(3)
  # => foo
  # => foo
  # => foo

Blocks are actually instances of the Proc class. There are helper methods to handle blocks passed to methods in a lightweight manner but you can also accept the block as a method argument, e.g.,

  class Integer
    def times(&blk)
      i = 0
      while i < self
        blk.call(i)
        i += 1
      end
    end
  end

Fun fact - there's no Boolean class in Ruby. True is an instance of TrueClass and false is an instance of FalseClass

Hmm, but that's not really a "breakage" in ruby, it's more an aesthetic argument over which objects should have which logic. It's like naming things. Smalltalk (& ruby) has 'select'. Everyone else uses 'filter'.

To some, 5.times seems very readable & logical. It's like arguing over the "right" colour scheme to use while coding (BTW, the correct answer is solarised light, but with black foreground text!!)