cleanup: remove Opaque and UnwrapOpaque

Author: ethanresnick

index.d.ts

@@ -36,7 +36,7 @@ export type {UndefinedOnPartialDeep} from './source/undefined-on-partial-deep';
 export type {ReadonlyDeep} from './source/readonly-deep';
 export type {LiteralUnion} from './source/literal-union';
 export type {Promisable} from './source/promisable';
-export type {Opaque, UnwrapOpaque, Tagged, GetTagMetadata, UnwrapTagged} from './source/opaque';
+export type {Tagged, GetTagMetadata, UnwrapTagged} from './source/tagged';
 export type {InvariantOf} from './source/invariant-of';
 export type {SetOptional} from './source/set-optional';
 export type {SetReadonly} from './source/set-readonly';

readme.md

@@ -151,8 +151,8 @@ Click the type names for complete docs.
 - [`UndefinedOnPartialDeep`](source/undefined-on-partial-deep.d.ts) - Create a deep version of another type where all optional keys are set to also accept `undefined`.
 - [`ReadonlyDeep`](source/readonly-deep.d.ts) - Create a deeply immutable version of an `object`/`Map`/`Set`/`Array` type. Use [`Readonly<T>`](https://www.typescriptlang.org/docs/handbook/utility-types.html#readonlytype) if you only need one level deep.
 - [`LiteralUnion`](source/literal-union.d.ts) - Create a union type by combining primitive types and literal types without sacrificing auto-completion in IDEs for the literal type part of the union. Workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).
-- [`Tagged`](source/opaque.d.ts) - Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf). (This replaces the previous [`Opaque`](source/opaque.d.ts) type, which is now deprecated.)
-- [`UnwrapTagged`](source/opaque.d.ts) - Get the untagged portion of a tagged type created with `Tagged`. (This replaces the previous [`UnwrapOpaque`](source/opaque.d.ts) type, which is now deprecated.)
+- [`Tagged`](source/tagged.d.ts) - Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d) that can support [multiple tags](https://github.com/sindresorhus/type-fest/issues/665) and [per-tag metadata](https://medium.com/@ethanresnick/advanced-typescript-tagged-types-improved-with-type-level-metadata-5072fc125fcf).
+- [`UnwrapTagged`](source/tagged.d.ts) - Get the untagged portion of a tagged type created with `Tagged`.
 - [`InvariantOf`](source/invariant-of.d.ts) - Create an [invariant type](https://basarat.gitbook.io/typescript/type-system/type-compatibility#footnote-invariance), which is a type that does not accept supertypes and subtypes.
 - [`SetOptional`](source/set-optional.d.ts) - Create a type that makes the given keys optional.
 - [`SetReadonly`](source/set-readonly.d.ts) - Create a type that makes the given keys readonly.
@@ -345,8 +345,8 @@ type ShouldBeNever = IfAny<'not any', 'not never', 'never'>;
 - `RequireOnlyOne` - See [`RequireExactlyOne`](source/require-exactly-one.d.ts)
 - `AtMostOne` - See [`RequireOneOrNone`](source/require-one-or-none.d.ts)
 - `AllKeys` - See [`KeysOfUnion`](source/keys-of-union.d.ts)
-- `Branded` - See [`Tagged`](source/opaque.d.ts)
-- `Opaque` - See [`Tagged`](source/opaque.d.ts)
+- `Branded` - See [`Tagged`](source/tagged.d.ts)
+- `Opaque` - See [`Tagged`](source/tagged.d.ts)
 
 ## Tips
 

source/exact.d.ts

@@ -1,5 +1,5 @@
 import type {ArrayElement, ObjectValue} from './internal';
-import type {Opaque, TagContainer} from './opaque';
+import type {TagContainer} from './tagged';
 import type {IsEqual} from './is-equal';
 import type {KeysOfUnion} from './keys-of-union';
 

source/invariant-of.d.ts

@@ -1,5 +1,3 @@
-import type {Opaque} from './opaque';
-
 declare const invariantBrand: unique symbol;
 
 /**

source/opaque.d.ts renamed to source/tagged.d.ts

@@ -6,119 +6,6 @@ export type TagContainer<Token> = {
 
 type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{[K in Token]: TagMetadata}>;
 
-/**
-Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for runtime values that would otherwise have the same type. (See examples.)
-
-The generic type parameters can be anything.
-
-Note that `Opaque` is somewhat of a misnomer here, in that, unlike [some alternative implementations](https://github.com/microsoft/TypeScript/issues/4895#issuecomment-425132582), the original, untagged type is not actually hidden. (E.g., functions that accept the untagged type can still be called with the "opaque" version -- but not vice-versa.)
-
-Also note that this implementation is limited to a single tag. If you want to allow multiple tags, use `Tagged` instead.
-
-[Read more about tagged types.](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d)
-
-There have been several discussions about adding similar features to TypeScript. Unfortunately, nothing has (yet) moved forward:
-	- [Microsoft/TypeScript#202](https://github.com/microsoft/TypeScript/issues/202)
-	- [Microsoft/TypeScript#15408](https://github.com/Microsoft/TypeScript/issues/15408)
-	- [Microsoft/TypeScript#15807](https://github.com/Microsoft/TypeScript/issues/15807)
-
-@example
-```
-import type {Opaque} from 'type-fest';
-
-type AccountNumber = Opaque<number, 'AccountNumber'>;
-type AccountBalance = Opaque<number, 'AccountBalance'>;
-
-// The `Token` parameter allows the compiler to differentiate between types, whereas "unknown" will not. For example, consider the following structures:
-type ThingOne = Opaque<string>;
-type ThingTwo = Opaque<string>;
-
-// To the compiler, these types are allowed to be cast to each other as they have the same underlying type. They are both `string & { __opaque__: unknown }`.
-// To avoid this behaviour, you would instead pass the "Token" parameter, like so.
-type NewThingOne = Opaque<string, 'ThingOne'>;
-type NewThingTwo = Opaque<string, 'ThingTwo'>;
-
-// Now they're completely separate types, so the following will fail to compile.
-function createNewThingOne (): NewThingOne {
-	// As you can see, casting from a string is still allowed. However, you may not cast NewThingOne to NewThingTwo, and vice versa.
-	return 'new thing one' as NewThingOne;
-}
-
-// This will fail to compile, as they are fundamentally different types.
-const thingTwo = createNewThingOne() as NewThingTwo;
-
-// Here's another example of opaque typing.
-function createAccountNumber(): AccountNumber {
-	return 2 as AccountNumber;
-}
-
-function getMoneyForAccount(accountNumber: AccountNumber): AccountBalance {
-	return 4 as AccountBalance;
-}
-
-// This will compile successfully.
-getMoneyForAccount(createAccountNumber());
-
-// But this won't, because it has to be explicitly passed as an `AccountNumber` type.
-getMoneyForAccount(2);
-
-// You can use opaque values like they aren't opaque too.
-const accountNumber = createAccountNumber();
-
-// This will compile successfully.
-const newAccountNumber = accountNumber + 2;
-
-// As a side note, you can (and should) use recursive types for your opaque types to make them stronger and hopefully easier to type.
-type Person = {
-	id: Opaque<number, Person>;
-	name: string;
-};
-```
-
-@category Type
-@deprecated Use {@link Tagged} instead
-*/
-export type Opaque<Type, Token = unknown> = Type & TagContainer<Token>;
-
-/**
-Revert an opaque or tagged type back to its original type by removing the readonly `[tag]`.
-
-Why is this necessary?
-
-1. Use an `Opaque` type as object keys
-2. Prevent TS4058 error: "Return type of exported function has or is using name X from external module Y but cannot be named"
-
-@example
-```
-import type {Opaque, UnwrapOpaque} from 'type-fest';
-
-type AccountType = Opaque<'SAVINGS' | 'CHECKING', 'AccountType'>;
-
-const moneyByAccountType: Record<UnwrapOpaque<AccountType>, number> = {
-	SAVINGS: 99,
-	CHECKING: 0.1
-};
-
-// Without UnwrapOpaque, the following expression would throw a type error.
-const money = moneyByAccountType.SAVINGS; // TS error: Property 'SAVINGS' does not exist
-
-// Attempting to pass an non-Opaque type to UnwrapOpaque will raise a type error.
-type WontWork = UnwrapOpaque<string>;
-
-// Using a Tagged type will work too.
-type WillWork = UnwrapOpaque<Tagged<number, 'AccountNumber'>>; // number
-```
-
-@category Type
-@deprecated Use {@link UnwrapTagged} instead
-*/
-export type UnwrapOpaque<OpaqueType extends TagContainer<unknown>> =
-	OpaqueType extends Tag<PropertyKey, any>
-		? RemoveAllTags<OpaqueType>
-		: OpaqueType extends Opaque<infer Type, OpaqueType[typeof tag]>
-			? Type
-			: OpaqueType;
-
 /**
 Attach a "tag" to an arbitrary type. This allows you to create distinct types, that aren't assignable to one another, for distinct concepts in your program that should not be interchangeable, even if their runtime values have the same type. (See examples.)
 

test-d/exact.ts

@@ -1,4 +1,4 @@
-import type {Exact, Opaque} from '../index';
+import type {Exact, Tagged} from '../index';
 
 { // Spec - string type
 	type Type = string;
@@ -356,7 +356,7 @@ import type {Exact, Opaque} from '../index';
 // Spec - special test case for Opaque types
 // @see https://github.com/sindresorhus/type-fest/issues/508
 {
-	type SpecialName = Opaque<string, 'special name'>;
+	type SpecialName = Tagged<string, 'special name'>;
 
 	type OnlyAcceptName = {
 		name: SpecialName;
@@ -375,7 +375,7 @@ import type {Exact, Opaque} from '../index';
 // @see https://github.com/sindresorhus/type-fest/issues/508
 {
 	// Test for number Opaque type
-	type SpecialName = Opaque<number, 'special name'>;
+	type SpecialName = Tagged<number, 'special name'>;
 
 	type OnlyAcceptName = {
 		name: SpecialName;
@@ -392,7 +392,7 @@ import type {Exact, Opaque} from '../index';
 
 // Spec - test the above for tagged types too.
 {
-	type TaggedNumber = Opaque<number, 'tag'>;
+	type TaggedNumber = Tagged<number, 'tag'>;
 
 	const function_ = <T extends Exact<{a: TaggedNumber}, T>>(arguments_: T) => arguments_;
 

test-d/readonly-deep.ts

@@ -1,5 +1,5 @@
 import {expectType, expectAssignable} from 'tsd';
-import type {Opaque, tag} from '../source/opaque';
+import type {Tagged, tag} from '../source/tagged';
 import type {ReadonlyDeep, ReadonlyObjectDeep} from '../source/readonly-deep';
 import type {JsonValue} from '../source/basic';
 
@@ -17,8 +17,8 @@ type NamespaceWithOverload = Overloaded & {
 	baz: boolean[];
 };
 
-type OpaqueObjectData = {a: number[]} | {b: string};
-type OpaqueObject = Opaque<OpaqueObjectData, {token: unknown}>;
+type TaggedObjectData = {a: number[]} | {b: string};
+type TaggedObject = Tagged<TaggedObjectData, 'token', unknown>;
 
 type ReadonlyJsonValue =
   | {readonly [k: string]: ReadonlyJsonValue}
@@ -62,7 +62,7 @@ const data = {
 	readonlyArray: ['foo'] as readonly string[],
 	readonlyTuple: ['foo'] as const,
 	json: [{x: true}] as JsonValue,
-	opaqueObj: {a: [3]} as OpaqueObject, // eslint-disable-line @typescript-eslint/consistent-type-assertions
+	opaqueObj: {a: [3]} as TaggedObject, // eslint-disable-line @typescript-eslint/consistent-type-assertions
 };
 
 const readonlyData: ReadonlyDeep<typeof data> = data;
@@ -99,7 +99,7 @@ expectType<Readonly<ReadonlySet<string>>>(readonlyData.readonlySet);
 expectType<readonly string[]>(readonlyData.readonlyArray);
 expectType<readonly ['foo']>(readonlyData.readonlyTuple);
 expectAssignable<ReadonlyJsonValue>(readonlyData.json);
-expectAssignable<Opaque<ReadonlyDeep<OpaqueObjectData>, ReadonlyDeep<OpaqueObject[typeof tag]>>>(readonlyData.opaqueObj);
+expectAssignable<ReadonlyDeep<TaggedObjectData> & ReadonlyDeep<{[tag]: TaggedObject[typeof tag]}>>(readonlyData.opaqueObj);
 
 expectType<((foo: number) => string) & ReadonlyObjectDeep<Namespace>>(readonlyData.namespace);
 expectType<string>(readonlyData.namespace(1));

test-d/opaque.ts renamed to test-d/tagged.ts

@@ -1,37 +1,34 @@
 import {expectAssignable, expectNotAssignable, expectNotType, expectType} from 'tsd';
-import type {Opaque, UnwrapOpaque, Tagged, GetTagMetadata, UnwrapTagged, InvariantOf,	SnakeCasedPropertiesDeep} from '../index';
+import type {Tagged, GetTagMetadata, UnwrapTagged, InvariantOf,	SnakeCasedPropertiesDeep} from '../index';
 
-type Value = Opaque<number, 'Value'>;
+type TaggedValue = Tagged<number, 'Value'>;
 
 // We make an explicit cast so we can test the value.
-const value: Value = 2 as Value;
+const value = 2 as TaggedValue;
 
 // The underlying type of the value is still a number.
 expectAssignable<number>(value);
 
-// You cannot modify an opaque value (and still get back an opaque value).
-expectNotAssignable<Value>(value + 2);
+// If you modify a tagged value, the result is not still tagged.
+expectNotAssignable<TaggedValue>(value + 2);
 
 // But you can modify one if you're just treating it as its underlying type.
 expectAssignable<number>(value + 2);
 
-type WithoutToken = Opaque<number>;
-expectAssignable<WithoutToken>(2 as WithoutToken);
-
-// Verify that the Opaque's token can be the parent type itself.
+// Verify that a tag's medatadata can be the parent type itself.
 type Person = {
-	id: Opaque<number, Person>;
+	id: Tagged<number, 'PersonId', Person>;
 	name: string;
 };
 const person = {
-	id: 42 as Opaque<number, Person>,
+	id: 42 as Tagged<number, 'PersonId', Person>,
 	name: 'Arthur',
 };
 expectType<Person>(person);
 
 // Failing test for https://github.com/sindresorhus/type-fest/issues/108
-// Use `Opaque` value as `Record` index type.
-type UUID = Opaque<string, 'UUID'>;
+// Use `Tagged` value as `Record` index type.
+type UUID = Tagged<string, 'UUID'>;
 type NormalizedDictionary<T> = Record<UUID, T>;
 type Foo = {bar: string};
 
@@ -45,41 +42,6 @@ const johnsId = '7dd4a16e-d5ee-454c-b1d0-71e23d9fa70b' as UUID;
 const userJohn = userEntities[johnsId];
 expectType<Foo>(userJohn);
 
-// Remove tag from opaque value.
-// Note: This will simply return number as type.
-type PlainValue = UnwrapOpaque<Value>;
-expectAssignable<PlainValue>(123);
-
-const plainValue: PlainValue = 123 as PlainValue;
-expectNotType<Value>(plainValue);
-
-// UnwrapOpque should work even when the token _happens_ to make the Opaque type
-// have the same underlying structure as a Tagged type.
-expectType<number>(4 as UnwrapOpaque<Opaque<number, {x: void}>>);
-
-// All the basic tests that apply to Opaque types should pass for Tagged types too.
-// See rationale for each test in the Opaque tests above.
-//
-// Tests around not providing a token, which Tagged requires, or using non-
-// `string | number | symbol` tags, which Tagged doesn't support, are excluded.
-type TaggedValue = Tagged<number, 'Value'>;
-type TaggedUUID = Tagged<string, 'UUID'>;
-
-const taggedValue: TaggedValue = 2 as TaggedValue;
-expectAssignable<number>(taggedValue);
-expectNotAssignable<TaggedValue>(value + 2);
-expectAssignable<number>(value + 2);
-
-const userEntities2: Record<TaggedUUID, Foo> = {
-	['7dd4a16e-d5ee-454c-b1d0-71e23d9fa70b' as UUID]: {bar: 'John'},
-	['6ce31270-31eb-4a72-a9bf-43192d4ab436' as UUID]: {bar: 'Doe'},
-};
-
-const johnsId2 = '7dd4a16e-d5ee-454c-b1d0-71e23d9fa70b' as TaggedUUID;
-
-const userJohn2 = userEntities2[johnsId2];
-expectType<Foo>(userJohn2);
-
 // Tagged types should support multiple tags,
 // by intersection or repeated application of Tagged.
 type AbsolutePath = Tagged<string, 'AbsolutePath'>;
@@ -97,27 +59,27 @@ expectAssignable<NormalizedPath>('' as NormalizedAbsolutePath);
 expectNotAssignable<SpecialCacheKey>('' as UrlString);
 expectAssignable<UrlString>('' as SpecialCacheKey);
 
-// A tag that is a union type should be treated as multiple tags.
-// This is the only practical-to-implement behavior, given how we're storing the tags.
-// However, it's also arguably the desirable behavior, and it's what the TS team planned to implement:
-// https://github.com/microsoft/TypeScript/pull/33290#issuecomment-529710519
-expectAssignable<Tagged<number, 'Y'>>(4 as Tagged<number, 'X' | 'Y'>);
-
-// UnwrapOpaque and UnwrapTagged both work on Tagged types.
-type PlainValueUnwrapOpaque = UnwrapOpaque<TaggedValue>;
-type PlainValueUnwrapTagged = UnwrapTagged<TaggedValue>;
-
-const unwrapped1 = 123 as PlainValueUnwrapOpaque;
-const unwrapped2 = 123 as PlainValueUnwrapTagged;
+// Remove tag from tagged value. UnwrapTagged should work on types with multiple tags.
+type PlainValue = UnwrapTagged<TaggedValue>;
+expectAssignable<PlainValue>(123);
 
+const unwrapped1 = 123 as UnwrapTagged<TaggedValue>;
+const unwrapped2 = '' as UnwrapTagged<NormalizedAbsolutePath>;
 expectType<number>(unwrapped1);
-expectType<number>(unwrapped2);
+expectType<string>(unwrapped2);
 
-// UnwrapTagged/UnwrapOpaque should work on types with multiple tags.
+const plainValue: PlainValue = 123 as PlainValue;
+expectNotType<TaggedValue>(plainValue);
+
+// UnwrapTagged should work on types with multiple tags.
 const unwrapped3 = '' as UnwrapTagged<NormalizedAbsolutePath>;
-const unwrapped4 = '' as UnwrapOpaque<NormalizedAbsolutePath>;
 expectType<string>(unwrapped3);
-expectType<string>(unwrapped4);
+
+// A tag that is a union type should be treated as multiple tags.
+// This is the only practical-to-implement behavior, given how we're storing the tags.
+// However, it's also arguably the desirable behavior, and it's what the TS team planned to implement:
+// https://github.com/microsoft/TypeScript/pull/33290#issuecomment-529710519
+expectAssignable<Tagged<number, 'Y'>>(4 as Tagged<number, 'X' | 'Y'>);
 
 // Tags have no metadata by default
 expectType<never>(undefined as unknown as GetTagMetadata<UrlString, 'URL'>);
@@ -143,6 +105,6 @@ expectAssignable<JsonOf<InvariantOf<number>>>(
 );
 
 // Test for issue https://github.com/sindresorhus/type-fest/issues/643
-type IdType = Opaque<number, 'test'>;
+type IdType = Tagged<number, 'test'>;
 type TestSnakeObject = SnakeCasedPropertiesDeep<{testId: IdType}>;
 expectType<TestSnakeObject>({test_id: 2 as IdType});