如何对存储在变量中的函数/闭包执行case-match匹配？

Great question! Let’s break this down clearly—this is totally feasible, though the exact approach depends on the language you’re working with (I’ll focus on Swift and Scala since they have robust pattern matching for functions/closures, but the core ideas translate to other languages with similar features).

First, let’s cover the basics: matching functions or closures stored in variables based on their type or wrapped identity.

Basic Type-Based Matching #

If you just need to distinguish between functions/closures with different signatures, you can use type patterns in your case-match statements. This works well when you’re dealing with distinct function types stored in a variable of a flexible type (like Any in Swift or AnyRef in Scala).

For example, in Swift:

// Define distinct function types
typealias StringTransformer = (String) -> String
typealias IntCalculator = (Int, Int) -> Int

// Store a closure in a variable of type Any
var operation: Any = { (str: String) in str.uppercased() } as StringTransformer

// Match using type patterns
switch operation {
case let transformer as StringTransformer:
    print(transformer("hello")) // Output: HELLO
case let calculator as IntCalculator:
    print(calculator(5, 3)) // Won't trigger here
default:
    print("Unknown operation type")
}

In Scala, similar logic applies with pattern matching on function types:

val operation: Any = (str: String) => str.toUpperCase

operation match {
    case f: String => String => println(f("hello")) // HELLO
    case f: (Int, Int) => Int => println(f(5,3)) // No match here
    case _ => println("Unknown operation")
}

Targeting Specific Closures and Calling Them #

Matching raw closures by their identity (i.e., checking if two closures are the exact same instance) is only reliable for stateless closures or global functions—closures that capture variables create new instances every time they’re defined, so reference equality checks (like === in Swift) won’t work for them.

Instead, the most robust approach is to wrap your closures in a tagged type (like an enum, case class, or struct) that gives you an explicit way to identify and match them.

Example with Enums (Swift) #

// Wrap closures in an enum with associated values
enum Operation {
    case uppercase((String) -> String)
    case add((Int, Int) -> Int)
    case multiply((Int, Int) -> Int)
}

// Store a specific closure variant
var currentOp: Operation = .uppercase { $0.uppercased() }

// Match the enum case and call the closure
switch currentOp {
case .uppercase(let transformer):
    print(transformer("test")) // Output: TEST
case .add(let adder):
    print(adder(2, 3)) // Output: 5 (if currentOp was .add)
case .multiply(let multiplier):
    print(multiplier(4, 5)) // Output: 20 (if currentOp was .multiply)
}

Example with Case Classes (Scala) #

// Sealed trait to define a closed set of operations
sealed trait Calculation
case class Add(f: (Int, Int) => Int) extends Calculation
case class Multiply(f: (Int, Int) => Int) extends Calculation

val currentCalc: Calculation = Add(_ + _)

// Match the case class and invoke the closure
currentCalc match {
    case Add(sum) => println(sum(10, 20)) // 30
    case Multiply(product) => println(product(10, 20)) // No match here
}

If you need to distinguish between multiple closures of the same type, add an identifier (like a string ID) to your wrapper:

struct NamedClosure<T> {
    let id: String
    let closure: T
}

let greet = NamedClosure(id: "greet", closure: { (name: String) in "Hello, \(name)!" })
let farewell = NamedClosure(id: "farewell", closure: { (name: String) in "Goodbye, \(name)!" })

var currentClosure = greet

switch currentClosure.id {
case "greet":
    print(currentClosure.closure("Alice")) // Hello, Alice!
case "farewell":
    print(currentClosure.closure("Bob")) // Goodbye, Bob!
default:
    print("Unknown closure")
}

Is This Feasible? #

Absolutely! Here’s what to keep in mind:

• Type-based matching works for distinguishing functions with different signatures, but doesn’t help you tell apart closures of the same type.
• Wrapped tagged types are the most reliable way to target specific closures—they let you explicitly define matchable cases and avoid the pitfalls of closure reference equality.
• Some languages (like Python) don’t have native pattern matching for functions, but you can replicate this behavior using classes or dictionaries to tag and look up closures.

The core idea is that while raw functions/closures can be matched by type, wrapping them gives you precise control over identifying and invoking exactly the closure you need.

内容的提问来源于stack exchange，提问作者Mark A. Donohoe