What is the difference between a higher-order function and a class?

Question

I was going through the basics of functional programming , and eventually came accross the concept of higher-order functions . I saw an example in this video by Corey Schafer (starts at 11:00), which shows a Python function that can wrap messages in arbitrary HTML tags:

def html_tag(tag):
    def wrap_text(msg):
        print('<{0}>{1}</{0}>'.format(tag, msg))

    return wrap_text

print_h1 = html_tag('h1')
print_h1('Test Headline!')
print_h1('Another Headline!')

print_p = html_tag('p')
print_p('Test Paragraph!')

Output:

<h1>Test Headline!</h1>
<h1>Another Headline!</h1>
<p>Test Paragraph!</p>

I get that it gives you the flexibility of re-using the same function for different purposes (different tags, in this example). But you could achieve the same result using Python classes , too:

class HTML_tag:
    def __init__(self, tag):
        self.tag = tag
    
    def wrap_text(self, msg):
        print('<{0}>{1}</{0}>'.format(self.tag, msg))

print_h1 = HTML_tag('h1')
print_h1.wrap_text('Test Headline!')
print_h1.wrap_text('Another Headline!')

print_p = HTML_tag('p')
print_p.wrap_text('Test Paragraph!')

Output:

<h1>Test Headline!</h1>
<h1>Another Headline!</h1>
<p>Test Paragraph!</p>

The higher-order function approach definitely looks cleaner, but apart from the aesthetics, are there any other reasons I might want to prefer a higher-order function over a class? Eg, regarding aspects like

• Performance
• Memory
• ...

Answer 1

Higher order functions take and/or return functions. Let's look at both cases.

Taking a function as a parameter

Here, a HOF is definitely the way to go. The class version amounts to a HOF with extra steps. For the class version, you need to have pre-negotiated the key the function is callable on. It's really a useless wrapper around the meat of what you're trying to accomplish.

HOF

def my_map(fn, arr):
  result = []
  for a in arr:
    result.append(fn(a))
  return result

my_map(lambda a: a + 1, [1, 2, 3]) # [2, 3, 4]

Class version

def my_map(inst, arr):
  result = []
  for a in arr:
    result.append(inst.fn(a))
  return result

class my_mapper:
  def fn(self, a):
    return a + 1

my_map(my_mapper(), [1, 2, 3]) # [2, 3, 4]

Returning a function

In both versions here, what we're doing is creating an encapsulation of some value a , and a function that works over it.

I think that a class is generally useful if you want more than one function to be defined over some data, when the encapsulated data can change (you're encoding a state machine), or when you expect operations to be specific to your class (ie. users of your class need to know the operations defined over the class).

I would use a function that returns a function, when what I'm doing amounts to partial application, (I have a function that takes multiple parameters, and I want to preapply some, like 'add'). I would also use functools.partial to do this.

def adder(a):
  return lambda b: a + b

class adder_class:
  def __init__(self, a):
    self.a = a

  def add(self, b):
    return a + b

Ultimately, whether it's best to use a HOF or a class will become clear from context.