Skip to content

Commit

Permalink
cleanup: remove Opaque and UnwrapOpaque
Browse files Browse the repository at this point in the history
  • Loading branch information
@ethanresnick
ethanresnick committed Mar 2, 2024
1 parent 5011e4a commit dbbf3f9
Show file tree
Hide file tree
Showing 9 changed files with 48 additions and 201 deletions.
2 changes: 1 addition & 1 deletion index.d.ts
View file
Expand Up @@ -31,7 +31,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/opaque';
export type {InvariantOf} from './source/invariant-of';
export type {SetOptional} from './source/set-optional';
export type {SetReadonly} from './source/set-readonly';
Expand Down
6 changes: 2 additions & 4 deletions readme.md
View file
Expand Up @@ -134,10 +134,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) if needed.
- [`UnwrapTagged`](source/opaque.d.ts) - Get the untagged portion of a tagged type created with `Tagged`.
- [`Opaque`](source/opaque.d.ts) - Create a [tagged type](https://medium.com/@KevinBGreene/surviving-the-typescript-ecosystem-branding-and-type-tagging-6cf6e516523d). This implementation only supports a single tag.
- [`UnwrapOpaque`](source/opaque.d.ts) - Get the untagged portion of a tagged type created with `Opaque` or `Tagged`.
- [`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) if needed. This replaces the former `Opaque` type.
- [`UnwrapTagged`](source/opaque.d.ts) - Get the untagged portion of a tagged type created with `Tagged`. This replaces the former `UnwrapOpaque` type.
- [`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.
Expand Down
2 changes: 1 addition & 1 deletion source/exact.d.ts
View file
@@ -1,5 +1,5 @@
import type {ArrayElement, ObjectValue} from './internal';
import type {Opaque, TagContainer} from './opaque';
import type {TagContainer} from './opaque';
import type {IsEqual} from './is-equal';
import type {KeysOfUnion} from './keys-of-union';

Expand Down
2 changes: 0 additions & 2 deletions source/invariant-of.d.ts
View file
@@ -1,5 +1,3 @@
import type {Opaque} from './opaque';

declare const invariantBrand: unique symbol;

/**
Expand Down
111 changes: 0 additions & 111 deletions source/opaque.d.ts
View file
Expand Up @@ -6,117 +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
*/
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
*/
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.)
Expand Down
14 changes: 7 additions & 7 deletions test-d/exact.ts
View file
@@ -1,5 +1,5 @@
import {expectError} from 'tsd';
import type {Exact, Opaque} from '../index';
import type {Exact, Tagged} from '../index';

{ // Spec - string type
type Type = string;
Expand Down Expand Up @@ -354,10 +354,10 @@ import type {Exact, Opaque} from '../index';
}
}

// Spec - special test case for Opaque types
// Spec - special test case for Tagged 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;
Expand All @@ -372,11 +372,11 @@ import type {Exact, Opaque} from '../index';
});
}

// Spec - special test case for Opaque type
// Spec - special test case for Tagged type
// @see https://github.com/sindresorhus/type-fest/issues/508
{
// Test for number Opaque type
type SpecialName = Opaque<number, 'special name'>;
// Test for number Tagged type
type SpecialName = Tagged<number, 'special name'>;

type OnlyAcceptName = {
name: SpecialName;
Expand All @@ -393,7 +393,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 fn = <T extends Exact<{a: TaggedNumber}, T>>(arguments_: T) => arguments_;

Expand Down
92 changes: 27 additions & 65 deletions test-d/opaque.ts
View file
@@ -1,37 +1,34 @@
import {expectAssignable, expectError, 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};

Expand All @@ -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'>;
Expand All @@ -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'>);
Expand All @@ -142,6 +104,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});
10 changes: 5 additions & 5 deletions test-d/readonly-deep.ts
View file
@@ -1,5 +1,5 @@
import {expectType, expectError, expectAssignable} from 'tsd';
import type {Opaque, tag} from '../source/opaque';
import type {Tagged, tag} from '../source/opaque';
import type {ReadonlyDeep, ReadonlyObjectDeep} from '../source/readonly-deep';
import type {JsonValue} from '../source/basic';

Expand All @@ -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}
Expand Down Expand Up @@ -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;
Expand Down Expand Up @@ -98,7 +98,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));
Expand Down

0 comments on commit dbbf3f9

Please sign in to comment.