Creating re-usable matchers?

[davidyang]

First, thanks for this awesome library, really fun to think of solving problems using this pattern and improves discussion with non-technical people.

I have a pattern where I load a bunch of mappings from a file and then want to match lines from a CSV to those mappings. Here's a ChatGPT translated version of what I'm doing (it's written originally in ClojureScript) (where mappings is a cache of the mappings from a CSV.

I'm not too concerned about performance since this is a batch job handler but I was hoping to build up the matcher once and then re-use it with different values. Is this possible?

function visitCategory(practice, categoryJsSet) {
  // Converting the atom to a regular variable
  let matcher = tsp.match({ practice_key: practice, mapping: "visit-category", f1: categoryJsSet });

  // Converting the doseq loop to a forEach loop
  mappings.forEach(mapping => {
    // Updating the matcher using a function equivalent to swap!
    matcher = ((m) => {
      let pattern = ((mapping) => {
        // Simulating the update-vals function
        Object.keys(mapping).forEach(key => {
          mapping[key] = mapping[key].trim();
        });

        // Simulating the select-keys function
        const selectedKeys = ['practice_key', 'mapping', 'f1'];
        mapping = selectedKeys.reduce((acc, key) => {
          if (mapping[key] !== undefined) acc[key] = mapping[key];
          return acc;
        }, {});

        // Updating the 'f1' key
        mapping.f1 = mapping.f1 === "*" ? tsp.P._ : new Set([mapping.f1]);

        return mapping;
      })(mapping);

      // Adding the pattern to the matcher
      m.with(pattern, (_) => mapping.f2);

      return m;
    })(matcher);
  });

  // Handling the otherwise case
  matcher.otherwise(() => "Unknown");

  return matcher;
}

[gvergnaud]

This isn't possible in the current version because you need an input value to create a match expression and they are evaluated eagerly.

What you could do however is to return a function that takes your input:

const createMatcher = (...thingsToGenerateBranches) => {
    return function matcher(input) {
            let expr = match(input)
            // ... generate branches based on createMatcher's input
            return expr.otherwise(...)
    }
}