38 replies

Narrowing Arrays to Tuples Using Match

Suppose we want to write a function that takes an array as input and does different things for certain concrete sizes. Is there a way to narrow from arrays to tuples with

Match

Match

?

My first thought would be to try something the following this using

Match

Match

, but the array type doesn't get narrowed correctly, so

and

are inferred to have type

number | undefined

number | undefined

, leading to a compilation error:

const sumAtMostTwo = (numbers: number[]): number =>
  pipe(
    Match.value(numbers),
    Match.when([], () => 0),
    Match.when([Match.number], ([x]) => x),
    Match.when([Match.number, Match.number], ([x, y]) => x + y),
    Match.orElse(() => {
      throw new Error(`Expected at most 2 elements, got ${numbers.length}`);
    }),
  );

const sumAtMostTwo = (numbers: number[]): number =>
  pipe(
    Match.value(numbers),
    Match.when([], () => 0),
    Match.when([Match.number], ([x]) => x),
    Match.when([Match.number, Match.number], ([x, y]) => x + y),
    Match.orElse(() => {
      throw new Error(`Expected at most 2 elements, got ${numbers.length}`);
    }),
  );

Note that Python has native support for a similar-looking implementation using its built-in pattern matching:

def sum_at_most_two(numbers):
    match numbers:
        case []:
            return 0
        case [x]:
            return x
        case [x, y]:
            return x + y
        case _:
            raise ValueError(f"Expected at most 2 elements, got {len(xs)}")

def sum_at_most_two(numbers):
    match numbers:
        case []:
            return 0
        case [x]:
            return x
        case [x, y]:
            return x + y
        case _:
            raise ValueError(f"Expected at most 2 elements, got {len(xs)}")

---

As a note to the maintainers, a couple of proposals have surfaced in the ensuing thread:
- For homogeneous arrays, something like

Match.hasLength(2)

Match.hasLength(2)

could narrow from

number[]

number[]

[number, number]

[number, number]

by making use of the fact that

number[] & { length: 2 }

number[] & { length: 2 }

is equivalent to

[number, number]

[number, number]

in TypeScript.
- For heterogeneous arrays, a general-purpose

Match.tuple

Match.tuple

utility supporting arbitrary tuples of refinements could be useful, similar to the

Predicate.tuple

Predicate.tuple

utility that already exists for predicates.

Narrowing Arrays to Tuples Using Match

Suppose we want to write a function that takes an array as input and does different things for certain concrete sizes. Is there a way to narrow from arrays to tuples with

Match

Match

?

My first thought would be to try something the following this using

Match

Match

, but the array type doesn't get narrowed correctly, so

and

are inferred to have type

number | undefined

number | undefined

, leading to a compilation error:

const sumAtMostTwo = (numbers: number[]): number =>
  pipe(
    Match.value(numbers),
    Match.when([], () => 0),
    Match.when([Match.number], ([x]) => x),
    Match.when([Match.number, Match.number], ([x, y]) => x + y),
    Match.orElse(() => {
      throw new Error(`Expected at most 2 elements, got ${numbers.length}`);
    }),
  );

const sumAtMostTwo = (numbers: number[]): number =>
  pipe(
    Match.value(numbers),
    Match.when([], () => 0),
    Match.when([Match.number], ([x]) => x),
    Match.when([Match.number, Match.number], ([x, y]) => x + y),
    Match.orElse(() => {
      throw new Error(`Expected at most 2 elements, got ${numbers.length}`);
    }),
  );

Note that Python has native support for a similar-looking implementation using its built-in pattern matching:

def sum_at_most_two(numbers):
    match numbers:
        case []:
            return 0
        case [x]:
            return x
        case [x, y]:
            return x + y
        case _:
            raise ValueError(f"Expected at most 2 elements, got {len(xs)}")

def sum_at_most_two(numbers):
    match numbers:
        case []:
            return 0
        case [x]:
            return x
        case [x, y]:
            return x + y
        case _:
            raise ValueError(f"Expected at most 2 elements, got {len(xs)}")

---

As a note to the maintainers, a couple of proposals have surfaced in the ensuing thread:
- For homogeneous arrays, something like

Match.hasLength(2)

Match.hasLength(2)

could narrow from

number[]

number[]

[number, number]

[number, number]

by making use of the fact that

number[] & { length: 2 }

number[] & { length: 2 }

is equivalent to

[number, number]

[number, number]

in TypeScript.
- For heterogeneous arrays, a general-purpose

Match.tuple

Match.tuple

utility supporting arbitrary tuples of refinements could be useful, similar to the

Predicate.tuple

Predicate.tuple

utility that already exists for predicates.

Narrowing Arrays to Tuples Using Match

Similar Threads

Narrowing Arrays to Tuples Using Match

Similar Threads

Similar Threads

Similar Threads