Lab

Registry

REGISTRY-101 Easy · Build ~15 min

An add-in’s function says #NAME?

The workbook’s formula engine knows SUM and MAX from a switch. Users now enable add-ins: the units add-in brings INCHES (feet to inches) and the inventory add-in brings REORDER (what to order to reach a target stock). The engine has to find their functions, and every add-in yet to come, without knowing any of them. As in every spreadsheet, a function’s name ignores case: =sum(1, 2) is SUM.

Every add-in function shows #NAME? in the cells that use it, and the function picker never lists one. Supporting each add-in by adding a branch to the engine means a release of the spreadsheet for every add-in.

Reproduce

new Workbook([units]).evaluate("INCHES", [3]) should be 36. Today it is #NAME?, and so is evaluate("sum", [1, 2]), which should be 3.

Acceptance criteria

Opening a workbook registers the built-ins, SUM and MAX, then every function of every add-in, in the order given; the formula engine finds a function by its name and knows none of them.
Names ignore case: a function is found in any spelling, and the picker lists each name once, in capitals, in alphabetical order.
A name that is already taken, in any spelling, is refused and recorded as “add-in: already registered: NAME”; the function registered first stays, and setup carries on with the rest.
A name nobody registered evaluates to #NAME?.

Check work runs these cases against your code once you sign in.

Not run:An add-in’s function is found by name
workbook = new Workbook([{ id: "units", functions: [["INCHES", feet × 12]] }]); workbook.evaluate("INCHES", [3]); workbook.evaluate("sum", [1, 2])
Not run:Names ignore case
workbook = new Workbook([{ id: "units", functions: [["INCHES", feet × 12]] }]); workbook.evaluate("inches", [2]); workbook.evaluate("Inches", [1]); workbook.evaluate("Max", [4, 9, 2])
Not run:An add-in no brief mentions is found too
workbook = new Workbook([{ id: "shipping", functions: [["CRATES", crates of six]] }]); workbook.evaluate("CRATES", [13]); workbook.functionNames().join(", ")
Not run:The picker lists every name once, in order
workbook = new Workbook([{ id: "units", functions: [["INCHES", feet × 12]] }, { id: "inventory", functions: [["REORDER", what to order to reach a target]] }]); workbook.functionNames().join(", "); workbook.evaluate("reorder", [2, 5]); checkRefused(workbook.refused)
Not run:An add-in’s MAX is refused and the built-in stays
workbook = new Workbook([{ id: "inventory", functions: [["REORDER", what to order to reach a target], ["Max", its first argument]] }]); workbook.evaluate("MAX", [1, 9]); checkRefused(workbook.refused); workbook.evaluate("REORDER", [2, 5])
Not run:A name another add-in took, in another spelling, is refused
workbook = new Workbook([{ id: "units", functions: [["INCHES", feet × 12]] }, { id: "measure", functions: [["inches", its first argument]] }]); workbook.evaluate("INCHES", [1]); checkRefused(workbook.refused); workbook.functionNames().join(", ")
Not run:A name nobody registered is #NAME?
workbook = new Workbook([{ id: "units", functions: [["INCHES", feet × 12]] }]); workbook.evaluate("REORDER", [2, 5]); workbook.evaluate("SUMS", [1])
Not run:A workbook without add-ins
workbook = new Workbook([]); workbook.functionNames().join(", "); checkRefused(workbook.refused); workbook.evaluate("SUM", [5, 6])

Notes

Each case opens one workbook with some add-ins, then prints each step’s result joined by “ | ”: a value, #NAME?, the picker’s list joined by “, ”, or what setup refused joined by “; ” (none if nothing).
The checker brings its own add-ins and formulas, including one no brief mentions. Keep the AddIn and Formula types, the Workbook’s name, how it is opened, and the names of evaluate, functionNames and refused (Go: OpenWorkbook, Evaluate, FunctionNames, Refused; Rust: Workbook::open, evaluate, function_names, refused); the checker calls them.
Compare names in ASCII capitals; the cases use only ASCII names.

Hints

Reference answerTry the cases first

type Formula = (args: number[]) => number;
// An add-in the user enabled, and the functions it brings: [name, formula].
type AddIn = { id: string; functions: [string, Formula][] };

// The built-in functions every workbook has.
const sum: Formula = (args) => args.reduce((total, n) => total + n, 0);
const maxOf: Formula = (args) => Math.max(...args);

// The registry: each function under its name in capitals, so =sum and
// =SUM are one function.
class FunctionRegistry {
  private entries = new Map<string, Formula>();

  register(name: string, formula: Formula): void {
    const key = name.toUpperCase();
    if (this.entries.has(key)) throw new Error(`already registered: ${key}`);
    this.entries.set(key, formula);
  }

  resolve(name: string): Formula | undefined {
    return this.entries.get(name.toUpperCase());
  }

  names(): string[] {
    return [...this.entries.keys()].sort();
  }
}

// A workbook: setup fills its registry, and the formula engine looks names up.
class Workbook {
  private functions = new FunctionRegistry();
  // What setup refused, as "add-in: reason".
  refused: string[] = [];

  constructor(addIns: AddIn[]) {
    this.functions.register('SUM', sum);
    this.functions.register('MAX', maxOf);
    for (const addIn of addIns) {
      for (const [name, formula] of addIn.functions) {
        try {
          this.functions.register(name, formula);
        } catch (error) {
          this.refused.push(`${addIn.id}: ${(error as Error).message}`);
        }
      }
    }
  }

  evaluate(name: string, args: number[]): string {
    const formula = this.functions.resolve(name);
    return formula ? String(formula(args)) : '#NAME?';
  }

  functionNames(): string[] {
    return this.functions.names();
  }
}

The switch knew every function by heart, so a function nobody wrote a branch for could never be found. The fix gives the workbook a registry: setup writes the built-ins and then each add-in’s functions into one map, and the engine’s only job is to look the formula’s name up. The engine now knows no function by name, which is why the checker’s own shipping add-in, mentioned in no brief, works too. Spreadsheet names ignore case, so the key is the name in capitals, used the same way when registering and when looking up; a map keyed by the spelling an add-in happened to use would hold SUM and Sum as two functions. That same key is what makes the duplicate check work: the inventory add-in’s Max is a second MAX, refused with a reason that names the add-in, and the built-in stays. Setup carries on after a refusal because an add-in’s one bad name should not cost the user every other function; the next level asks whether a half-installed add-in is really better.

Sign in to run your code

Read the brief and the starter here. With a free account you can edit it, run the sample, step through it and check your work, and your progress is kept.

type Formula = (args: number[]) => number;
// An add-in the user enabled, and the functions it brings: [name, formula].
type AddIn = { id: string; functions: [string, Formula][] };

// The built-in functions every workbook has.
const sum: Formula = (args) => args.reduce((total, n) => total + n, 0);
const maxOf: Formula = (args) => Math.max(...args);

// A workbook: it loads the add-ins the user enabled and evaluates formulas.
class Workbook {
  // What setup refused, as "add-in: reason". Nothing is refused yet.
  refused: string[] = [];

  constructor(addIns: AddIn[]) {
    // The add-ins are loaded, but nothing records their functions.
  }

  // The formula engine: one branch per function it knows.
  evaluate(name: string, args: number[]): string {
    switch (name) {
      case 'SUM':
        return String(sum(args));
      case 'MAX':
        return String(maxOf(args));
      default:
        return '#NAME?';
    }
  }

  // The function picker's list.
  functionNames(): string[] {
    return ['MAX', 'SUM'];
  }
}