This is a problem because Python treats methods and functions differently. You can pass functions to other functions. But you can’t pass instance methods.

In Ruby, you can pass "TLDMs" by passing the symbol corresponding to their name, and calling send() on the symbol to call the method. Likewise, you can pass the object and the symbol in order to pass a method around.

Ruby lacks list comprehensions

Ruby does have the select method, which is semantically equivalent. List comprehensions are syntactic sugar for select (and I'll freely admit that Ruby can have a pretty bitter syntax at times, so maybe the sugar is justified).

I should also mention that this is false:

    >>> x = 'a'
    >>> def call(f): return f()
    ... 
    >>> call(x.capitalize)
    'A'

map(str.capitalize, ['a', 'b', 'c'])

... you have to understand far too much of Python's implementation (for example, that str is not a function, but a class that kindof acts like a function) to program. I still think that methods + functions = a pain point in Python.

    >>> type(str)
    <type 'type'>

  class Foo
    def bar
      p 'baz'
    end
  end

  bar = Foo.new.method(:bar).to_proc

  3.times &bar

  [1,2,3].each(&method(:puts))
  #instead of
  [1,2,3].each {|i| puts i }

Regarding TLDMs, how do you propose mapping a TLDM over an array? For example:

  def transform(x)
    # implementation ...
  end

  list = [1, 2, 3]

  # doesn't work ...
  list.map &transform

    def transform(x)
      x * 2
    end
    
    list = [1, 2, 3]
    
    p list.map &method(:transform)

    [1,2,3].map{ |x| x * 2 }

    transform = lambda { |x| x * 2 }
    [1,2,3].map(&transform)

You're right in that list comprehensions are semantically equivalent to combining map and select, not just select.

    alias :m :method

Yes, you can:

    >>> map(str.capitalize, ['alpha', 'beta', 'gamma'])
    ['Alpha', 'Beta', 'Gamma']

    >>> import operator
    >>> map(operator.methodcaller("capitalize"), your_list)

If join() was not a string method then it would have to belong in some mixin that you slap onto your iterators, and that increases code complexity.

Also, you can do things like map(operator.methodcaller("capitalize"), iterator_of_strings), but that is probably bad style.

And in Ruby you can do your_object.method("foo") to turn your method into a lambda.

Admittedly, the join syntax is somewhat counter-intuitive and arguably ugly, but it does the job without defining new built-in functions or adding extra syntax. If you really can't stand the syntax, you can always do this:

    # old style way of joining strings
    import string
    string.join([1,2,3], ' ')

    str.join(' ', [1,2,3])

In [1]: x = [1,2,3]

In [2]: y = [4,5,6]

In [3]: x + y

Out[3]: [1, 2, 3, 4, 5, 6]

Why use 6 [join()] characters when you can use 1 :)

Even if you disagree, the line between methods and functions in Python really isn't standardized.

reduce(operator.add, list_of_lists)

You can not say sum(), sadly, because it forces a restriction that you only sum numbers.

  >>> sum([['a', 'b', 'c'], ['d', 'e', 'f']], [])
  ['a', 'b', 'c', 'd', 'e', 'f']

http://docs.python.org/library/functions.html#sum

  >>> import itertools
  >>> [l for l in itertools.chain(*[['a', 'b', 'c'], ['d', 'e', 'f']])]
  ['a', 'b', 'c', 'd', 'e', 'f']

  >>> from itertools import chain
  >>> list_of_lists = [['a', 'b', 'c'], ['d', 'e', 'f']]
  >>> list(chain(*list_of_lists))
  ['a', 'b', 'c', 'd', 'e', 'f']

   >>> from itertools import chain
   >>> chain(*[['a', 'b', 'c'], ['d', 'e', 'f']])

Proc calling is built directly into the language via the yield keyword and it's by far the most common way to call Procs.

More importantly (and annoyingly), if I define a top-level method with def—let’s call those top-level def methods (TLDMs)—Ruby won’t let me pass it as a block to any other method.

First, you can indeed pass a method as an argument using &method(:method_name). Secondly, it's rare to pass around named methods in Ruby (http://news.ycombinator.com/item?id=1141245) because Procs/blocks are flexible enough to make it almost always unnecessary. See also: http://yehudakatz.com/2010/02/21/ruby-is-not-a-callable-orie...

Capitalizing things only makes sense on a string. Having a builtin function that could capitalize any input doesn't work, so it's better to explicitly make it clear that it's a string related function. If, for some reason, you're allergic to list comprehensions, you could always do map(lambda s: s.capitalize(), strlist).

Similarly, the string module has a join function, whose definition is: return sep.join(words). The standard ''.join() is unfortunate and unobvious to the newcomer, but it's idiomatic, and there probably are unusual cases where calling a non-method join doesn't work.

  You could always do map(lambda s: s.capitalize(), strlist)

The two essays I've written are essentially describing what is natural in each language, not what is strictly possible.

[1] http://allthingsprogress.com/posts/the-ugliness-of-python

Hook as a term is more used in a callback context.