pass-function-as-arg

name	pass-function-as-arg
description	For generic algorithms: strategy pattern, callbacks, configurable behavior. Pass functions as parameters to customize algorithm behavior.

pass-function-as-arg

When to Use

• Algorithm should work with different implementations
• Strategy pattern: same algorithm, different strategies
• Callbacks for event handling
• Sorting/filtering with custom criteria
• Higher-order functions (map, filter, reduce)

When NOT to Use

• Only one implementation needed
• Function parameter adds complexity without benefit
• Object-oriented approach is clearer

The Pattern

Accept a function as a parameter to customize behavior.

def generic_algorithm(data, key=lambda x: x, filter_fn=lambda x: True):
    """Process data with customizable key and filter."""
    filtered = [x for x in data if filter_fn(x)]
    return sorted(filtered, key=key)

# Use with different strategies
result1 = generic_algorithm(items, key=lambda x: x.priority)
result2 = generic_algorithm(items, key=lambda x: -x.size, filter_fn=lambda x: x.active)

Example (from pytudes)

# Hill climbing with configurable objective (ngrams.py)
def hillclimb(x, objective_fn, neighbors_fn, steps=10000):
    """Search for x that maximizes objective_fn, using neighbors_fn to explore."""
    best = x
    best_score = objective_fn(x)

    for _ in range(steps):
        for neighbor in neighbors_fn(best):
            score = neighbor_score = objective_fn(neighbor)
            if score > best_score:
                best, best_score = neighbor, score
                break

    return best

# Use with specific objective and neighbor functions
decoded = hillclimb(initial_guess,
                   objective_fn=log_probability,
                   neighbors_fn=swap_adjacent_chars)

# Priority queue with custom key (AdventUtils.ipynb)
class PriorityQueue:
    def __init__(self, items=(), key=lambda x: x):
        self.key = key
        self.items = []
        for item in items:
            self.add(item)

    def add(self, item):
        heapq.heappush(self.items, (self.key(item), item))

# A* search with custom heuristic
frontier = PriorityQueue(initial_nodes, key=lambda n: n.cost + h(n))

# Tree generation with configurable pop strategy (Maze.ipynb)
def random_tree(nodes, neighbors, pop=deque.pop):
    """Pop strategy determines tree shape."""
    ...
    current = pop(frontier)  # DFS, BFS, or random based on pop function

Key Principles

1. Functions are values: Pass them like any other argument
2. Default identity: key=lambda x: x as sensible default
3. Name the role: objective_fn, neighbors_fn, key
4. Keep signatures simple: Callback should match expected interface
5. Document expected signature: What arguments, what return type?