Bdtjtk

In functional programming with types you often can restrict types in your application to provided values of input.

However I'm at a loss in how to do this with TypeScript with the possible values of the keys for a Map.

Consider the following:

const match = <T, V, R>(p : (x : V) => T, ... c : Array< [T, (x : V) => R] >) : (x : V) => R => {

  const cases = new Map(c);

  return (x : any) => cases.get(p(x))(x);

}

A more human readable format:

const match = <Row, Value, ReturnType>(p : (x : Value) => Row, ...c : Array< [Row, (x : Value) => ReturnType] >) : (x : Value) => ReturnType => {

  const cases = new Map(c);

  return x => cases.get(p(x))(x);

}

However there is a problem with this notation as it isn't actually doing what is intended to be done:

match(x => Math.random() > 0.5 ? "foo" : "bar", ["baz", x => x])

This should, in a sufficiently advanced Typing system be able to be an error, however in TypeScript it is not detecting that the "foo" or "bar" values are not any of the expected values and would actually cause the code to throw.

A more in depth example:

const validDouble = match( x => x * 2,

[4, x => "four"],

[6, x => "six"]

)



validDouble(4) // TS ERROR: 8 is not a valid value for Type ROW (4 | 6)

validDouble(2) // "four", no TS Error

I know I can't enforce the rest parameter to be a forced value of arrays(I could however wrap it in an enforced array and require extra characters from the developer), but I am curious if there is a way to enforce that the values in the row match the output values in the predicate function?

EDIT: Yes I know this throws on a non matching input. That logic is EASY to insert with conditionals or try catches and turning this into a matchMaybe, however this example was simplified because that has no impact or implication on the typing system available in TypeScript

Ok here is the fixed function (may need some tidy-up and probably improvements).

const match = <

Row extends string | number,

Value,

ReturnType,

V extends (x: Value) => ReturnType,

C extends [...[Row, V]],

>

(

predicate: (x: Value) => Row,

...c: C & [...[Row, V]]

): (x: Value) => ReturnType => {



const cases = new Map<Row, V>(c);



return x =>

// put a runtime check below instead of asserting 

    // non-undefined value with `!` 

    cases.get(predicate(x))!(x)

}



match(x => 'baz', ["baz", (x: any) => x]) // ok

match(x => 'qwe', ["baz", (x: any) => x]) // err

match(x => 'qwe', ["baz", (x: any) => x], ["qwe", (x: any) => x]) //ok

Playground

The first problem was that rest parameter should be a tuple. The second problem was to place type parameters correctly so that everything infers correctly.

P.S. Complex types in typescript are hard. I feel lack of the documentation on type parameters, hence I always feel inconfidence about them (I think others do as well).