I don’t understand how that could possibly be construed as a strawman, the entirety of my comments were responding to the substance of your blog post. Unless you are referring to the JS example, which I pointed out directly was intentionally wrong to make a point.

The fact that you have to think about any of this at all in order to use Ruby’s “first class functions” means you can only say it has them with a lot of disclaimers. As I put it in the post, “economy-class.” […] To be equally pedantic, we weren’t talking about methods, were we? We’re talking about first-class functions.

Ruby has first-class functions without any disclaimers. My critique of your argument is that you keep confusing method invocation for function execution and these are two entirely different language concepts.

To be explicitly clear: when I say Ruby has first-class functions, I am speaking of Procs and Lambdas. Those are functions. Methods are not. Two different things.

1. Assigning a function to a variable

greet = ->(name) { "Hello, #{name}!" }
greet.("John") # => "Hello, John!"

2. Passing a function as an argument

transform = ->(str, fn) { fn.(str) }
transform.("foo", -> { _1.reverse }) # => "oof"

It’s also worth mentioning that your example:

array.select {|number| number.even? }

You are demonstrating this property, which can also be written as

evens = proc { |number| number.even? }
array.send :select, &evens

Block arguments are Procs that are passed as arguments to methods. This is the most common way of using first-class functions in Ruby, and it’s one of the most unique language features.

3. Returned as a result of a function

curry = ->(fn, x) { ->(*args) { fn.(x, *args) } }
addition = ->(x, y) { x + y }
add_one = curry.(addition, 1)
add_one.(1) # => 2

4. Including a function in any data structure

transforms = {
  reverse: -> { _1.reverse },
  upcase: -> { _1.upcase }
}
transforms[:reverse].("foo") # => "oof"
transforms[:upcase].("foo") # => "FOO"

5. Composing multiple functions together

reverse = -> { _1.reverse }
upcase = -> { _1.upcase }
shout_in_reverse = reverse >> upcase
shout_in_reverse.("foo") # => "OOF"

6. Functions are closures

This isn’t strictly necessary to qualify as first-class, but I think it is the most common way to do it.

count = 0
incr = -> { count += 1 }
incr.() # => 1
count # => 1

Is that more clear? Functions in Ruby are invoked with call which has syntactic sugar .().

Second, methods are not functions.

1. Methods are not closures

count = 0
def incr = count += 1
incr() # NoMethodError: undefined method `+' for nil:NilClass

This happened because the execution binding of a method is the receiver, not the lexical scope. This is important because calling a method is essentially just syntactic sugar for send

This can be confusing in a REPL specifically, because it’s not clear from the above what you are actually doing. In a Ruby REPL, main is an instance of Object, and calling def is actually defining a new method on the Object class.

2. Method invocation is just send

dog = Object.new
def dog.bark = "woof!"
dog.bark # => "woof!"
dog.send :bark # => "woof!"

Method objects exist so that you can translate the method interface into a function interface, but you’re really just bundling up the receiver together with a message to send

bark = dog.method(:bark)
bark.() # => "woof!"

3. Methods can’t be detached from their receiver

A method is a type of message that an object can respond to. You can’t separate them (well, you can but UnboundMethod is not executable until it is bound to something)

A Ruby method is an implementation of the OOP idea of data and behavior existing together in a single object.

All methods have an implicit block argument (a Proc), which is a first-class function. The syntax of Ruby allows you to seamlessly combine methods and functions into a single interface, but there is no requirement that you do so.