Any non-reserved ident sequence, with dots and/or square brackets.

We have a little bit more than that. this, MetaProperty, super and PrivateIdentifier can also involve this. (see PatternMatchingMemberExpression)

slide 6

Function is invoked with (subject, {matchType:“boolean”}).

it's f(subject, hint, receiver) right now. e.g. f(subject, "boolean", thisValue)

If return value is true (not truthy!), same as returning [].

slide 16. we don't have this in the spec, and I think this behavior might be a footgun. if a function returns true, you should use it like f: .... Use it like f(...): ... is always an error

current in spec: https://tc39.es/proposal-pattern-matching/#sec-invoke-custom-matcher

Slide 4: use of - as separator in

0/+0/-0 only exception - 0 compares with SameValueZero

Is mildly confusing as it could be read as -0. I suggest changing this to an em-dash or using :

IMO, a good topic order for these slides might be:

1. match syntax overview
2. Literal constant patterns (i.e., "Primitive Patterns")
3. Reference patterns (variable references and member references)
4. Object patterns
5. Array patterns
6. Discards/void patterns
7. Extractors
8. Combinator patterns (and/or/not/parens)
9. Variable declaration patterns (i.e., let/const/var) - calling them "Binding Patterns" is mildly confusing as JS already has something else called a binding pattern
10. if patterns
11. Semantics of custom matchers
12. Future syntax

This order progressively builds in complexity while leveraging key information from previous slides. For example if patterns really need and to be meaningful. Oftentimes, so do let patterns.

Here's another way to write Option that lets you avoid having to write new in the match examples:

class Option {
    static #none = new this();
    #value;
    constructor(value) { this.#value = value; }
    static Some(value) { return new Option(value); }
    static None() { return Option.#none; }
    static {
        this.Some[Symbol.customMatcher] = function (s, hint) {
            if (s && #value in s && s !== Option.#none) {
                return hint === "boolean" ? true : [s.#value];
            }
            return false;
        };
        this.None[Symbol.customMatcher] = function (s, hint) {
            if (s === Option.#none) {
                return hint === "boolean" ? true : [];
            }
            return false;
        };
    }
}