如何为curried或partial applicated函数定义Fluent API？通用工具实现思路咨询

Great question! Building a fluent API for curried or partially applied functions is such a smart way to make your code more readable while keeping all the flexibility of currying. Let’s walk through how to pull this off, including a reusable tool that works across different use cases.

First, let’s align on the basics:

• Curried functions: Functions that take one argument at a time, returning a new function until all arguments are provided.
• Partial application: Pre-filling some arguments of a function, returning a new function that takes the remaining ones.
• Fluent API: A pattern where each method call returns the same (or a new) object, allowing you to chain calls together (e.g., obj.doX().doY().doZ()).

The goal is to wrap your curried/partial functions in an object that lets you chain argument additions and trigger execution cleanly.

1. Build a Fluent Wrapper for Argument Tracking #

The core of your tool will be a wrapper that keeps track of applied arguments and exposes chainable methods. Here’s a minimal JavaScript example to illustrate:

function createFluentCurry(baseFn) {
  let appliedArgs = [];

  const wrapper = {
    // Add one or more arguments to the partial call
    with: (...args) => {
      appliedArgs = [...appliedArgs, ...args];
      return wrapper; // Return self to keep the chain alive
    },
    // Execute the final function with all collected arguments
    execute: () => {
      let result = baseFn;
      // Apply arguments one by one (works for curried functions)
      for (const arg of appliedArgs) {
        result = result(arg);
        // Stop early if the result is no longer a function
        if (typeof result !== 'function') break;
      }
      appliedArgs = []; // Reset for reuse
      return result;
    },
    // Reset collected arguments if you want to start fresh
    reset: () => {
      appliedArgs = [];
      return wrapper;
    }
  };

  // Optional: Make the wrapper callable like a function for shorthand
  return new Proxy(wrapper, {
    apply: (target, _, args) => {
      if (args.length) return target.with(...args);
      return target.execute();
    }
  });
}

How to Use It #

// Example curried function: adds three numbers
const curriedAdd = a => b => c => a + b + c;

// Create our fluent wrapper
const fluentAdd = createFluentCurry(curriedAdd);

// Chain calls fluently
const result1 = fluentAdd.with(1).with(2).with(3).execute(); // 6
const result2 = fluentAdd.with(10, 20).with(30).execute(); // 60

// Shorthand using the proxy (call like a function)
const result3 = fluentAdd(5)(10)(15); // 30

2. Add Flexibility for Different Scenarios #

To make this tool reusable across more cases, add features that handle common edge cases and use cases:

Support Async Functions #

Add an option to handle curried functions that return promises:

function createFluentCurry(baseFn, options = {}) {
  const { isAsync = false } = options;
  let appliedArgs = [];

  const wrapper = {
    // ... (keep existing .with(), .reset() methods)
    execute: () => {
      let result = baseFn;
      for (const arg of appliedArgs) {
        result = result(arg);
        if (typeof result !== 'function') break;
      }
      appliedArgs = [];
      return isAsync ? Promise.resolve(result) : result;
    },
    executeAsync: async () => wrapper.execute()
  };

  // ... (proxy setup)
}

// Usage with async curried function
const curriedFetch = url => options => fetch(url, options);
const fluentFetch = createFluentCurry(curriedFetch, { isAsync: true });

async function getApiData() {
  const response = await fluentFetch
    .with('https://api.example.com/data')
    .with({ method: 'GET' })
    .executeAsync();
  const data = await response.json();
  console.log(data);
}

Add Argument Validation #

Let users pass a validation function to ensure arguments meet requirements:

function createFluentCurry(baseFn, options = {}) {
  const { validateArg = () => true } = options;
  let appliedArgs = [];

  const wrapper = {
    with: (...args) => {
      args.forEach(arg => {
        if (!validateArg(arg)) {
          throw new Error(`Invalid argument: ${arg} (must be a number)`);
        }
      });
      appliedArgs = [...appliedArgs, ...args];
      return wrapper;
    },
    // ... (other methods)
  };

  // ... (proxy setup)
}

// Usage with validation
const fluentAdd = createFluentCurry(curriedAdd, {
  validateArg: arg => typeof arg === 'number'
});
fluentAdd.with('not a number'); // Throws error

Support Context Binding #

Add a .bind() method to set the this context for functions that rely on it:

const wrapper = {
  bind: (thisArg) => {
    this.context = thisArg;
    return wrapper;
  },
  execute: () => {
    let result = baseFn.bind(this.context || null);
    // ... (apply arguments)
  }
};

3. Handle Edge Cases #

Don’t forget to account for these common edge cases:

• Curried functions that return non-functions early: The wrapper checks if result is a function after each argument application, so it stops and returns the final value correctly.
• Reusing the same wrapper: The .execute() and .reset() methods clear the collected arguments, so you don’t get cross-contamination between calls.
• Variable-length curried functions: The wrapper doesn’t assume a fixed number of arguments, so it works for functions that accept any number of inputs.

• Wrapper pattern is king: The wrapper acts as a state holder for applied arguments, letting you chain calls without losing context.
• Prioritize readability: Use intuitive method names like .with() and .execute() to make the API feel natural.
• Build for flexibility: Add optional features (async support, validation, binding) so the tool works for most of your use cases without rewriting it.

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