Function Matching: Map Caller Signatures to Overloaded Function Definitions

Question

## Problem

You are given a list of function definitions, each with a name and a typed parameter list. You are also given a list of call expressions, each with a function name and argument types. Implement a matcher that returns, for each call, the best matching definition — or `"NO_MATCH"` if none apply.

Matching rules (in priority order):
1. Exact type match on all positional arguments.
2. A parameter typed `"any"` matches any argument type.
3. If multiple definitions match, prefer the one with fewer `"any"` parameters.

```python
def match_function(
    definitions: list[dict],  # [{"name": str, "params": [str]}]
    calls: list[dict]         # [{"name": str, "args": [str]}]
) -> list[str]:               # definition id or "NO_MATCH" per call
    ...
```

```
Definitions:
  {"id": "f1", "name": "foo", "params": ["int", "str"]}
  {"id": "f2", "name": "foo", "params": ["any", "str"]}

Calls:
  {"name": "foo", "args": ["int", "str"]}  -> "f1"  (exact beats any)
  {"name": "foo", "args": ["float", "str"]}-> "f2"  (any matches float)
  {"name": "foo", "args": ["int", "int"]}  -> "NO_MATCH"
```

## Follow-ups

1. Add support for variadic parameters (`*args`) that match zero or more trailing arguments.
2. How do you handle ambiguous matches where two definitions tie on specificity?
3. Support subtype relationships: `int` is a subtype of `number`. How does this change your matching logic?
4. What data structure would you precompute to make repeated matching fast?

Function Matching: Map Caller Signatures to Overloaded Function Definitions

Question Details

Full Details

About This Question

Topics

More Confluent Interview Questions