链式状态谓词实现问询：多参数谓词链执行逻辑开发

Great question—since your predicates have different parameter lists, the key is to wrap each predicate invocation (with its specific arguments) into a uniform, parameterless callable so you can iterate through them consistently. Here's how to pull this off, with practical examples in both Python and Java:

Core Idea #

The problem with varying parameters is that you can't store the predicates directly in a list (they don't share a common signature). By wrapping each predicate call into a "thunk" (a function with no arguments) that captures its target predicate and required parameters, you create a uniform interface to iterate over.

Example Implementation in Python #

Let's say you have these stateful predicates with different parameters (each may return True/False, throw exceptions, and have side effects):

def check_user_exists(user_id):
    # Side effect: e.g., logs the check, fetches user from DB
    user = fetch_user(user_id)
    if not user:
        raise ValueError(f"User {user_id} not found")
    return True

def check_permission(user_id, resource):
    # Side effect: updates permission check counter
    increment_permission_check_counter()
    return has_access(user_id, resource)

def check_resource_available(resource, quantity):
    # Side effect: reserves the resource if available
    if get_available_stock(resource) >= quantity:
        reserve_stock(resource, quantity)
        return True
    return False

Step 1: Wrap Predicates into Parameterless Callables

Use lambda or functools.partial to bind each predicate with its specific arguments:

from functools import partial

# Using partial (explicit and readable)
predicate_chain = [
    partial(check_user_exists, user_id=123),
    partial(check_permission, user_id=123, resource="report"),
    partial(check_resource_available, resource="report", quantity=3)
]

# Or using lambdas (concise)
predicate_chain = [
    lambda: check_user_exists(123),
    lambda: check_permission(123, "report"),
    lambda: check_resource_available("report", 3)
]

Step 2: Execute the Chain

Create a function to iterate through the wrapped callables, stopping on False or exceptions:

def execute_predicate_chain(predicates):
    for idx, predicate in enumerate(predicates):
        try:
            result = predicate()
            if not result:
                print(f"Predicate {idx+1} failed: returned False")
                return False
        except Exception as e:
            print(f"Predicate {idx+1} failed with exception: {str(e)}")
            # Optional: re-raise the exception if you want it to propagate
            # raise e
            return False
    print("All predicates passed successfully")
    return True

# Run the chain
execute_predicate_chain(predicate_chain)

Example Implementation in Java #

For statically typed languages like Java, use Supplier<Boolean> (a functional interface with a parameterless get() method):

import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;

public class PredicateChain {
    // Sample stateful predicates with varying parameters
    private static boolean checkUserExists(int userId) throws Exception {
        // Side effect: log or fetch user
        if (userId <= 0) throw new Exception("Invalid user ID");
        return true;
    }

    private static boolean checkPermission(int userId, String resource) {
        // Side effect: update audit log
        return userId == 123 && resource.equals("report");
    }

    private static boolean checkResourceAvailable(String resource, int quantity) {
        // Side effect: reserve stock
        return quantity <= 5;
    }

    public static void main(String[] args) {
        List<Supplier<Boolean>> predicateChain = new ArrayList<>();
        predicateChain.add(() -> {
            try {
                return checkUserExists(123);
            } catch (Exception e) {
                throw new RuntimeException(e); // Wrap checked exception
            }
        });
        predicateChain.add(() -> checkPermission(123, "report"));
        predicateChain.add(() -> checkResourceAvailable("report", 3));

        executeChain(predicateChain);
    }

    private static boolean executeChain(List<Supplier<Boolean>> predicates) {
        for (int i = 0; i < predicates.size(); i++) {
            try {
                boolean result = predicates.get(i).get();
                if (!result) {
                    System.out.printf("Predicate %d failed: returned false%n", i+1);
                    return false;
                }
            } catch (Exception e) {
                System.out.printf("Predicate %d failed with exception: %s%n", i+1, e.getMessage());
                return false;
            }
        }
        System.out.println("All predicates passed");
        return true;
    }
}

Key Notes #

• State Preservation: Since predicates run in sequence, any state changes (side effects) from earlier predicates are available to later ones. If you need to share explicit state between them, pass a context object (e.g., a dictionary in Python, a custom class in Java) when wrapping the predicates.
• Exception Handling: You can choose to catch exceptions and stop, or let them propagate (which will still stop the chain but bubble up the error to the caller).
• Flexibility: This approach works for any language that supports first-class functions or lambda expressions—you just need a way to create parameterless wrappers for your predicate calls.

内容的提问来源于stack exchange，提问作者user2185573