fix(readonly): exhaustive matching on readonly array #207
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
turtton
referenced
this pull request
in turtton/volglass
Mar 3, 2024
[](https://renovatebot.com) This PR contains the following updates: | Package | Change | Age | Adoption | Passing | Confidence | |---|---|---|---|---|---| | [ts-pattern](https://github.com/gvergnaud/ts-pattern) | [`^4.1.4` -> `^5.0.0`](https://renovatebot.com/diffs/npm/ts-pattern/4.1.4/5.0.6) | [](https://docs.renovatebot.com/merge-confidence/) | [](https://docs.renovatebot.com/merge-confidence/) | [](https://docs.renovatebot.com/merge-confidence/) | [](https://docs.renovatebot.com/merge-confidence/) | --- ### Release Notes <details> <summary>gvergnaud/ts-pattern (ts-pattern)</summary> ### [`v5.0.6`](https://github.com/gvergnaud/ts-pattern/releases/tag/v5.0.6) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/v5.0.5...v5.0.6) #### Close issue issues - Exhaustive matching fix for reas [https://github.com/gvergnaud/ts-pattern/issues/206](https://github.com/gvergnaud/ts-pattern/issues/206) - Fix incorrect JS docs [https://github.com/gvergnaud/ts-pattern/issues/196](https://github.com/gvergnaud/ts-pattern/issues/196) #### What's Changed - Update README.md by [@​ndstephens](https://github.com/ndstephens) in [https://github.com/gvergnaud/ts-pattern/pull/161](https://github.com/gvergnaud/ts-pattern/pull/161) - docs: add install instructions for bun and pnpm by [@​colinhacks](https://github.com/colinhacks) in [https://github.com/gvergnaud/ts-pattern/pull/186](https://github.com/gvergnaud/ts-pattern/pull/186) - build(deps-dev): bump postcss from 8.4.23 to 8.4.31 by [@​dependabot](https://github.com/dependabot) in [https://github.com/gvergnaud/ts-pattern/pull/199](https://github.com/gvergnaud/ts-pattern/pull/199) - build(deps-dev): bump [@​babel/traverse](https://github.com/babel/traverse) from 7.21.5 to 7.23.2 by [@​dependabot](https://github.com/dependabot) in [https://github.com/gvergnaud/ts-pattern/pull/200](https://github.com/gvergnaud/ts-pattern/pull/200) - fix(readonly): exhaustive matching on readonly array by [@​gvergnaud](https://github.com/gvergnaud) in [https://github.com/gvergnaud/ts-pattern/pull/207](https://github.com/gvergnaud/ts-pattern/pull/207) #### New Contributors - [@​ndstephens](https://github.com/ndstephens) made their first contribution in [https://github.com/gvergnaud/ts-pattern/pull/161](https://github.com/gvergnaud/ts-pattern/pull/161) - [@​colinhacks](https://github.com/colinhacks) made their first contribution in [https://github.com/gvergnaud/ts-pattern/pull/186](https://github.com/gvergnaud/ts-pattern/pull/186) **Full Changelog**: gvergnaud/ts-pattern@v5.0.5...v5.0.6 ### [`v5.0.5`](https://github.com/gvergnaud/ts-pattern/releases/tag/v5.0.5) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/v5.0.4...v5.0.5) #### Bug fixes The `P` module was mistakenly exposing some pattern methods that were intended to be namespaced by type. This release fixes this problem. If you happened to use on of those following methods, here is where to find them now: ```diff - P.between + P.number.between ``` ```diff - P.lt + P.number.lt ``` ```diff - P.gt + P.number.gt ``` ```diff - P.lte + P.number.lte ``` ```diff - P.gte + P.number.gte ``` ```diff - P.int + P.number.int ``` ```diff - P.finite + P.number.finite ``` ```diff - P.positive + P.number.positive ``` ```diff - P.negative + P.number.negative ``` ```diff - P.betweenBigInt + P.bigint.between ``` ```diff - P.ltBigInt + P.bigint.lt ``` ```diff - P.gtBigInt + P.bigint.gt ``` ```diff - P.lteBigInt + P.bigint.lte ``` ```diff - P.gteBigInt + P.bigint.gte ``` ```diff - P.positiveBigInt + P.bigint.positive ``` ```diff - P.negativeBigInt + P.bigint.negative ``` ### [`v5.0.4`](https://github.com/gvergnaud/ts-pattern/releases/tag/v5.0.4) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/v5.0.3...v5.0.4) #### What's Changed - 🐛 fix: Accept branded primitive types as patterns by [@​gvergnaud](https://github.com/gvergnaud) in [https://github.com/gvergnaud/ts-pattern/pull/180](https://github.com/gvergnaud/ts-pattern/pull/180) **Full Changelog**: gvergnaud/ts-pattern@v5.0.3...v5.0.4 ### [`v5.0.3`](https://github.com/gvergnaud/ts-pattern/releases/tag/v5.0.3) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/v5.0.2...v5.0.3) #### What's Changed - 🐛 fix: Allow re-exporting patterns from ES Modules by [@​gvergnaud](https://github.com/gvergnaud) in [https://github.com/gvergnaud/ts-pattern/pull/175](https://github.com/gvergnaud/ts-pattern/pull/175) **Full Changelog**: gvergnaud/ts-pattern@v5.0.2...v5.0.3 ### [`v5.0.2`](https://github.com/gvergnaud/ts-pattern/releases/tag/v5.0.2) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/7ccc1d3333e424391f0b8e0f1ec0055025448bda...v5.0.2) #### What's Changed - fix(P.infer): Fix inference of arrays containing tuples in gvergnaud/ts-pattern@c52af6a - refactoring: simplify selection types in gvergnaud/ts-pattern@1b7a36b - perf: runtime perf improvement in .with in gvergnaud/ts-pattern@9b27384 - fix: use `Symbol.for` to make sure two concurrent versions of ts-pattern are compatible with one-another in gvergnaud/ts-pattern@d6d2e23 - docs: fix typo by [@​juicyjusung](https://github.com/juicyjusung) in [https://github.com/gvergnaud/ts-pattern/pull/170](https://github.com/gvergnaud/ts-pattern/pull/170) #### New Contributors - [@​juicyjusung](https://github.com/juicyjusung) made their first contribution in [https://github.com/gvergnaud/ts-pattern/pull/170](https://github.com/gvergnaud/ts-pattern/pull/170) **Full Changelog**: gvergnaud/ts-pattern@v5.0.0...v5.0.2 ### [`v5.0.1`](https://github.com/gvergnaud/ts-pattern/compare/v5.0.0...7ccc1d3333e424391f0b8e0f1ec0055025448bda) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/v5.0.0...7ccc1d3333e424391f0b8e0f1ec0055025448bda) ### [`v5.0.0`](https://github.com/gvergnaud/ts-pattern/releases/tag/v5.0.0): ❤️ [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/v4.3.0...v5.0.0) ### TS-Pattern v5 is finally out ❤️ ### Breaking changes #### `.with` is now evaluated eagerly In the previous version of TS-Pattern, no code would execute until you called `.exhaustive()` or `.otherwise(...)`. For example, in the following code block, nothing would be logged to the console or thrown: ```ts // TS-Pattern v4 type Input = { type: 'ok'; value: number } | { type: 'error'; error: Error }; // We don't call `.exhaustive`, so handlers don't run. function someFunction(input: Input) { match(input) .with({ type: 'ok' }, ({ value }) => { console.log(value); }) .with({ type: 'error' }, ({ error }) => { throw error; }); } someFunction({ type: 'ok', value: 42 }); // nothing happens ``` In **TS-Pattern v5**, however, the library will execute the matching handler as soon as it finds it: ```ts // TS-Pattern v5 someFunction({ type: 'ok', value: 42 }); // logs "42" to the console! ``` Handlers are now evaluated **eagerly** instead of lazily. In practice, this shouldn't change anything as long as you always finish your pattern matching expressions by either `.exhaustive` or `.otherwise`. #### Matching on Maps and Sets Matching `Set` and `Map` instances using `.with(new Set(...))` and `.with(new Map(...))` is no longer supported. If you want to match specific sets and maps, you should now use the `P.map(keyPattern, valuePattern)` and `P.set(valuePattern)` patterns: ```diff - import { match } from 'ts-pattern'; + import { match, P } from 'ts-pattern'; const someFunction = (value: Set<number> | Map<string, number>) => match(value) - .with(new Set([P.number]), (set) => `a set of numbers`) - .with(new Map([['key', P.number]]), (map) => `map.get('key') is a number`) + .with(P.set(P.number), (set) => `a set of numbers`) + .with(P.map('key', P.number), (map) => `map.get('key') is a number`) .otherwise(() => null); ``` - The subpattern we provide in `P.set(subpattern)` should match all values in the set. - The value subpattern we provide in `P.map(keyPattern, subpattern)` should only match the values matching `keyPattern` for the whole `P.map(..)` pattern to match the input. ### New features #### chainable methods TS-Pattern v5's major addition is the ability to chain methods to narrow down the values matched by primitive patterns, like `P.string` or `P.number`. Since a few examples is worth a thousand words, here are a few ways you can use chainable methods: ##### P.number methods ```ts const example = (position: { x: number; y: number }) => match(position) .with({ x: P.number.gte(100) }, (value) => '🎮') .with({ x: P.number.between(0, 100) }, (value) => '🎮') .with( { x: P.number.positive().int(), y: P.number.positive().int(), }, (value) => '🎮' ) .otherwise(() => 'x or y is negative'); ``` Here is the full list of number methods: - `P.number.between(min, max)`: matches numbers between `min` and `max`. - `P.number.lt(max)`: matches numbers smaller than `max`. - `P.number.gt(min)`: matches numbers greater than `min`. - `P.number.lte(max)`: matches numbers smaller than or equal to `max`. - `P.number.gte(min)`: matches numbers greater than or equal to `min`. - `P.number.int()`: matches integers. - `P.number.finite()`: matches all numbers except `Infinity` and `-Infinity` - `P.number.positive()`: matches positive numbers. - `P.number.negative()`: matches negative numbers. ##### P.string methods ```ts const example = (query: string) => match(query) .with(P.string.startsWith('SELECT'), (query) => `selection`) .with(P.string.endsWith('FROM user'), (query) => `👯♂️`) .with(P.string.includes('*'), () => 'contains a star') // Methods can be chained: .with(P.string.startsWith('SET').includes('*'), (query) => `🤯`) .exhaustive(); ``` Here is the full list of string methods: - `P.string.startsWith(str)`: matches strings that start with `str`. - `P.string.endsWith(str)`: matches strings that end with `str`. - `P.string.minLength(min)`: matches strings with at least `min` characters. - `P.string.maxLength(max)`: matches strings with at most `max` characters. - `P.string.includes(str)`: matches strings that contain `str`. - `P.string.regex(RegExp)`: matches strings if they match this regular expression. ##### Global methods Some methods are available for all primitive type patterns: - `P.{..}.optional()`: matches even if this property isn't present on the input object. - `P.{..}.select()`: injects the matched value into the handler function. - `P.{..}.and(pattern)`: matches if the current pattern **and** the provided pattern match. - `P.{..}.or(pattern)`: matches if either the current pattern **or** the provided pattern match. ```ts const example = (value: unknown) => match(value) .with( { username: P.string, displayName: P.string.optional(), }, () => `{ username:string, displayName?: string }` ) .with( { title: P.string, author: { username: P.string.select() }, }, (username) => `author.username is ${username}` ) .with( P.instanceOf(Error).and({ source: P.string }), () => `Error & { source: string }` ) .with(P.string.or(P.number), () => `string | number`) .otherwise(() => null); ``` #### Variadic tuple patterns With TS-Pattern, you are now able to create array (or more accurately tuple) pattern with a variable number of elements: ```ts const example = (value: unknown) => match(value) .with( // non-empty list of strings [P.string, ...P.array(P.string)], (value) => `value: [string, ...string[]]` ) .otherwise(() => null); ``` Array patterns that include a `...P.array` are called **variadic tuple patterns**. You may only have a single `...P.array`, but as many fixed-index patterns as you want: ```ts const example = (value: unknown) => match(value) .with( [P.string, P.string, P.string, ...P.array(P.string)], (value) => `value: [string, string, string, ...string[]]` ) .with( [P.string, P.string, ...P.array(P.string)], (value) => `value: [string, string, ...string[]]` ) .with([], (value) => `value: []`) .otherwise(() => null); ``` Fixed-index patterns can also be set **after** the `...P.array` variadic, or on both sides! ```ts const example = (value: unknown) => match(value) .with( [...P.array(P.number), P.string, P.number], (value) => `value: [...number[], string, number]` ) .with( [P.boolean, ...P.array(P.string), P.number, P.symbol], (value) => `value: [boolean, ...string[], number, symbol]` ) .otherwise(() => null); ``` Lastly, argument of `P.array` is now optional, and will default to `P._`, which matches anything: ```ts const example = (value: unknown) => match(value) // 👇 .with([P.string, ...P.array()], (value) => `value: [string, ...unknown[]]`) .otherwise(() => null); ``` #### `.returnType` In TS-Pattern v4, the only way to explicitly set the return type of your `match` expression is to set the two `<Input, Output>` type parameters of `match`: ```ts // TS-Pattern v4 match< { isAdmin: boolean; plan: 'free' | 'paid' }, // input type number // return type >({ isAdmin, plan }) .with({ isAdmin: true }, () => 123) .with({ plan: 'free' }, () => 'Oops!'); // ~~~~~~ ❌ not a number. ``` the main drawback is that you need to set the ***input type*** explicitly ***too***, even though TypeScript should be able to infer it. In TS-Pattern v5, you can use the `.returnType<Type>()` method to only set the return type: ```ts match({ isAdmin, plan }) .returnType<number>() // 👈 new .with({ isAdmin: true }, () => 123) .with({ plan: 'free' }, () => 'Oops!'); // ~~~~~~ ❌ not a number. ``` #### What's Changed - TS-Pattern v5 base branch by [@​gvergnaud](https://github.com/gvergnaud) in [https://github.com/gvergnaud/ts-pattern/pull/139](https://github.com/gvergnaud/ts-pattern/pull/139) **Full Changelog**: gvergnaud/ts-pattern@v4.3.0...v5.0.0 ### [`v4.3.0`](https://github.com/gvergnaud/ts-pattern/releases/tag/v4.3.0) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/788c082e85c3e03374177b253f002fc11c38d059...v4.3.0) #### TS-Pattern and node16 TS-Pattern now fully supports `moduleResolution: node16`, with both ES and CommonJS modules. This resolves the long standing issue number [#​110](https://github.com/gvergnaud/ts-pattern/issues/110). Special thanks to [@​Andarist](https://github.com/Andarist) and [@​frankie303](https://github.com/frankie303) for helping me understand and fix this issue ❤️ #### What's Changed - build: better support moduleResolution: bundler by [@​gvergnaud](https://github.com/gvergnaud) in [https://github.com/gvergnaud/ts-pattern/pull/158](https://github.com/gvergnaud/ts-pattern/pull/158) - Gvergnaud/fix build for nodenext and commonjs by [@​gvergnaud](https://github.com/gvergnaud) in [https://github.com/gvergnaud/ts-pattern/pull/160](https://github.com/gvergnaud/ts-pattern/pull/160) **Full Changelog**: gvergnaud/ts-pattern@v4.2.2...v4.3.0 ### [`v4.2.3`](https://github.com/gvergnaud/ts-pattern/compare/v4.2.2...788c082e85c3e03374177b253f002fc11c38d059) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/v4.2.2...788c082e85c3e03374177b253f002fc11c38d059) ### [`v4.2.2`](https://github.com/gvergnaud/ts-pattern/releases/tag/v4.2.2) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/v4.2.1...v4.2.2) ##### Bug fixes: - Issue [#​142](https://github.com/gvergnaud/ts-pattern/issues/142): Fixes a type inference bug when the input type only has optional properties. [commit 3c36992](https://github.com/gvergnaud/ts-pattern/commit/3c36992) ### [`v4.2.1`](https://github.com/gvergnaud/ts-pattern/releases/tag/v4.2.1) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/v4.2.0...v4.2.1) #### Bug fixes This release fixes inference of `P.array` when the input is a readonly array (issue [#​148](https://github.com/gvergnaud/ts-pattern/issues/148)) ```ts declare const input: readonly { readonly title: string; readonly content: string; }[]; const output = match(input) .with( P.array({ title: P.string, content: P.string }), // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // Used to error, now works (posts) => 'a list of posts!' ) .otherwise(() => 'something else'); ``` ### [`v4.2.0`](https://github.com/gvergnaud/ts-pattern/releases/tag/v4.2.0) [Compare Source](https://github.com/gvergnaud/ts-pattern/compare/v4.1.4...v4.2.0) #### Features ##### Better inference for `match` and `.with` ##### match When using match with an inline array, it will now infer its type as tuple automatically, even when not using `as const`. This means that exhaustiveness checking will also improve in this case: ```ts function f(a: boolean, b: boolean) { // infered as `[boolean, boolean]` return ( match([a, b]) // we can pattern match on all cases .with([true, true], () => false) .with([false, true], () => true) .with([true, false], () => true) .with([false, false], () => false) // ✅ Failed in TS-pattern v4.1 but works in v4.2! .exhaustive() ); } ``` ##### `.with(...)` Thanks to the help of [@​Andarist](https://github.com/Andarist), this release fixes a long-standing issue of `.with`. Until now, patterns like `P.array`, `P.union` or `P.when` didn't have proper type inference when used in `.with()` directly. Here are a few behaviors that use to be incorrect and work now: ```ts match<'a' | 'b'>('a') .with(P.union('this is wrong'), x => x) // ~~~~~~~~~~~~~~~ // ❌ no longer type-check in v4.2 .otherwise(x => x) match<'a' | 'b'>('a') .with(P.array(123), x => x) // ~~~ // ❌ no longer type-check in v4.2 .otherwise(x => x) match<'a' | 'b'>('a') .with(P.when((x) => true), x => x) // 👆 // used to be of type `unknown`, now `'a' | 'b'` .otherwise(x => x) ``` This also fixes the following issue: [https://github.com/gvergnaud/ts-pattern/issues/140](https://github.com/gvergnaud/ts-pattern/issues/140) </details> --- ### Configuration 📅 **Schedule**: Branch creation - "after 1pm and before 5pm on Friday" in timezone Asia/Tokyo, Automerge - At any time (no schedule defined). 🚦 **Automerge**: Disabled by config. Please merge this manually once you are satisfied. ♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox. 🔕 **Ignore**: Close this PR and you won't be reminded about this update again. --- - [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check this box --- This PR has been generated by [Mend Renovate](https://www.mend.io/free-developer-tools/renovate/). View repository job log [here](https://developer.mend.io/github/turtton/volglass). <!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiIzNS4xMTcuMyIsInVwZGF0ZWRJblZlciI6IjM3LjgxLjMiLCJ0YXJnZXRCcmFuY2giOiJtYWluIn0=--> Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
](https://renovatebot.com){kind=link}
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Resolves #206