Alternatives to `implements`?

[LeaVerou]

Part of the committee feedback was that implements conflicts with TS. Opening this issue to brainstorm potential alternative names. Note that whatever word we use should be consistent between:

• Class head (class C implements P)
• Sub-protocols (requires foo implements Q)
• Operator (obj implements P)
• Imperative method Protocol.implement(obj, P)

One idea is use, which is both self-explanatory and shorter:

• class C uses P
• requires foo uses Q
• obj uses P
• Protocol.use(obj, P)

Other ideas:

• with (but may conflict with existing with() {} block
• ??

[ljharb]

with is invalid syntax in strict mode, but in sloppy mode i suspect it would work, but be undesirable since it's got such a negative association.

uses imo doesn't make sense unless there's something provided, and not all protocols will provide something.

satisfies would be good, but TS has stolen that one too :-/

AI suggestions include conforms to (multi-word spaced operators would be a first, though); fulfills (which overlaps with Promise); realizes; models; meets; matches (although this would be a better fit for pattern matching).

[LeaVerou]

with is invalid syntax in strict mode, but in sloppy mode i suspect it would work, but be undesirable since it's got such a negative association.

I was assuming it's an actual WithStatement that is not allowed, not literally the with keyword. But yes, the negative association is a valid argument.

uses imo doesn't make sense unless there's something provided, and not all protocols will provide something.

True.

satisfies would be good, but TS has stolen that one too :-/

AI suggestions include conforms to (multi-word spaced operators would be a first, though); fulfills (which overlaps with Promise); realizes; models; meets; matches (although this would be a better fit for pattern matching).

satisfies makes no sense if there are no required members. Same with conformsto, or fulfills.

[samualtnorman]

TypeScript's type system should know what type P is so it shouldn't be an issue for TypeScript.
non type-checking TypeScript compilers can check if P comes from one of these and know for sure it can be stripped:

• type P = …
• interface P { …
• import type { P } from …

if the compiler sees that it comes from a protocol P { …, it knows for sure it shouldn't be stripped.

in the case the compiler can't see a P definition anywhere, it should default to not stripping the implements P and assume it comes ambiently.

in the case where one of TypeScript's Interop Constraints flags are switched on, it could require an explicit class C implements type P { … to disambiguate for non-type-checking compilers.

---

this sort of problem wouldn't be a new one for TypeScript as the ambigious

import { Foo } from "bar"

export { Foo }

exists.

[Andrewmat]

Hello! If implements is really out of table, I'd suggest applies, it is similar in intent. I saw that rust uses impl which can be an alternative. I like the suggested meets too.

Multi word keywords can be inspired by instanceofand be joined without spaces, ts also has keyof and typeof as examples.

[DarkWiiPlayer]

class HelloWorld {
  implements Foo;
  implements Bar;
  implements Baz;
}