My first thought was, this looks like a type system, except you need to solve it yourself. In Typesecript, naively:
const main = ([a_, b_, c_]: [a, b, c, a]) => {
type SomeTuple = [a, b, c, a];
const X: a = a_;
const Y: Exclude // =
console.log(X, Y);
}
type Narrowable = string | number | bigint | boolean;
/*
Express the type of a value in a tuple that is not the type of the second parameter
For example:
- ValOfTupleExceptFor -> 6
- ValOfTupleExceptFor -> 1
*/
type ValOfTupleExceptFor = Tup extends [infer First, ...(infer Rest extends Narrowable[])]
? First extends Val
? Rest extends []
? never
: ValOfTupleExceptFor
: First
: never;
const NO_SOLUTION: unique symbol = Symbol('NO_SOLUTION')
const getValOfTupleExcluding = (tup: readonly Narrowable[], val: (typeof tup)[number]): ValOfTupleExceptFor => {
const [first, ...rest] = tup;
if (!first) {
return NO_SOLUTION as never;
}
if (first === val) {
return getValOfTupleExcluding(rest, val);
}
return first as ValOfTupleExceptFor;
}
const main = ([a_, b_, c_]: [a, b, c, a]) => {
const someTuple = [a_, b_, c_, a_] as const;
const X: a = a_;
// This still resolves to type 'never'
const Y: ValOfTupleExceptFor = getValOfTupleExcluding(someTuple, a_);
console.log(X, Y);
}
edit: TS playground link with some experiments if anyone's interested: http://tinyurl.com/3p2pzdtn