How to make sure a method is not called twice with the same argument?

Talking about JavaScript (or typescript), I'm trying to find a way to make sure that developers can't call a method multiple times with the same argument.

For example:

const foo = (name: string) => {}


foo("ABC") // ok

foo ("123") // ok

foo ("ABC") // should show an error in the IDE, as it was already called in the first interaction

Just to be clear, the error should be shown at "developing" (compilation?) time. I want developers to be aware of the mistake while coding, so the IDE should trigger the error.

How can I achieve it? Should I create a tslint error?
Please help

Edit: I may have not been 100% clear, but if no feature of JavaScript allows the above, then what also will do the job for me is probably a new custom tslint rule. If I'm not mistaken, rules can have a context where they can store some "cached" values. Hence, at development time, I should be able to see an error the same way we see other linting rules error in the IDE.

Can it be achieved? How can I create a new lint rules with a context that does the job?

Also, I don't mind if we do foo(x) and the rule is not able to detect what value x is, and I don't mind the order on which the function is called.

The rule has to be just smart enough to reckon simple cases where it can.

I don't think you can statically do that, but you can throw an error at runtime in development only:

const usedNames = []

const foo = (name: string) => {
  if (process.env.NODE_ENV === 'development') {
    if (usedNames.includes(name)) throw new Error(`Function already called with ${ name }.`)

    usedNames.push(name)
  }

  ...
}

The whole if (process.env.NODE_ENV === 'development') { ... } block won't be present in non-development builds.

Unfortunately, TypeScript or JavaScript doesn't have this kind of feature built-in. As far as I know, there's no mechanism within JavaScript or TypeScript that allows you to enforce a restriction at compile-time based on runtime values or usage. The languages simply aren't designed to keep track of this kind of usage.

Typically, a static type checker like TypeScript checks types based on static analysis, which doesn't involve executing or tracing the code. As a result, TypeScript can't provide checks that depend on the runtime behaviour of the code, like the order or frequency of function calls.

For catching these types of logical issues early, unit tests are often a better approach. You could write a test that asserts foo throws an error when called with the same argument twice, and then run your tests often during development. Alternatively, you could look into using a linter or static analysis tool that supports custom rules, but I don't think any existing tool can handle this specific case.

If you want to enforce a rule like this, your best bet might be to provide documentation or comments explaining the requirement, and to rely on developers to manually adhere to the requirement.

It's also possible that your use case could be better served with a different pattern or structure. If you find yourself needing to prevent developers from calling a method multiple times with the same argument, it might be worth considering a design that doesn't allow for that possibility in the first place

You may use chaining to list used arguments
https://tsplay.dev/WJpZrN

type conform<T, V, E> = T extends V ? T : { error: E }

type Chain<T> = {
  foo<V extends string>(
    name: conform<V, Exclude<V, T>, 'this argument is already used'>,
  ): Chain<T | V>
}

function chain(fn: (s: string) => void): Chain<never> {
  const c = {
    foo(s: string) {
      fn(s);
      return c;
    }
  };
  return c as any;
}

chain(console.log)
.foo('a') // ok
.foo('b') // ok
.foo('a') // Argument of type 'string' is not assignable to parameter
//   ~~~     of type '{ error: "this argument is already used"; }'.(2345)

let cc;
cc = chain(console.log)
cc = cc.foo('a'); // ok
cc = cc.foo('b'); // ok
cc = cc.foo('a'); // Argument of type 'string' is not assignable to parameter
//          ~~~     of type '{ error: "this argument is already used"; }'.(2345)

To ensure that developers can't call a method multiple times with the same argument, you can create a caching mechanism to keep track of the arguments that have already been passed to the function. One approach to achieve this in JavaScript is by using a closure to store the cache and check for duplicate arguments.

const createUniqueFunction = () => {
const cache = new Set();
const foo = (name) => {
if (cache.has(name)) {
console.error(`Error: "${name}" has already been used as an argument.`);
return;
}
// Do whatever you want to do with the argument here
console.log(`Processing argument: "${name}"`);
// Add the argument to the cache
cache.add(name);
};
return foo;
};
// Usage example:
const foo = createUniqueFunction();
foo("ABC"); // ok
foo("123"); // ok
foo("ABC"); // Error: "ABC" has already been used as an argument.

In this example, we use a closure to create the createUniqueFunction function, which returns the foo function. The cache variable inside the closure is a Set that stores the arguments passed to foo. Before processing the argument, we check if it already exists in the cache. If it does, we log an error message and return early without performing the operation.

By using this approach, calling foo multiple times with the same argument will result in an error message, preventing duplicate calls with the same argument.

Keep in mind that the above code will work as long as the foo function is created using createUniqueFunction. If you create another foo function separately, it will have its own independent cache. If you need to ensure uniqueness across multiple instances, you could explore other approaches like using a global cache or a custom data structure.