Repository: TypeScript
Issue: Feature Request: `Documented` Utility Type
Labels: Suggestion,Awaiting More Feedback

## Search Terms

Docs, documentation, re-key, utility, type, extract, literal, update, tsdoc, comment, source, text

## Suggestion

I'd love to see documentation as a first-class citizen of the type system. My suggestion is a new utility type `Documented`, which allows users to document and unwrap documentation at the type-level.

The type could look as follows: `Documented<V, D extends string> = V`.

This:

```ts
type X = {
  a: Documented<string, "Some documentation for `a`">;
};
```

... would be equivalent to this:

```ts
type X = {
  /**
   * Some documentation for `a`
   */
  a: string;
};
```

While it would be preferable for consistency to specify the documentation attached to the key (as this is how mapped types transfer documentation), index signature and other contextual restrictions apply. Aka., this is no good:

```ts
type X = {
  [Documented<"a", "Some documentation for `a`">]: string;
}
```

Additionally, accessing the symbol of the literal of a specific key can be arduous (`Extract<keyof ..., ...`>). Whereas accessing the symbol of the field is simple (`X["a"]`).

> ALSO: apologies if I'm butchering the terminology.

## Use Cases

This utility type would enable users to extract documentation as string literal types, which they could then further manipulate and use elsewhere. They could build up higher-order generic types to assist with and type-check the documentation process.

## Examples

```ts
type X = {
  /**
   * Some documentation for `a`
   */
  a: string;
};

type XaDocs = X["a"] extends Documented<any, infer D> ? D : undefined;
declare const xaDocs: XaDocs; // "Some documentation for `a`"

// update (prefix) the string literal type of the documentation
type XaDocsUpdated = XaDocs extends string ? `USE WITH CAUTION: ${XaDocs}` : undefined;

// utilize the `Documented` utility to attach the new documentation
type XUpdated1 = {
  a: Documented<string, XaDocsUpdated>;
};

// perhaps within a mapped type
type XUpdated2 = {
  [K in keyof X]: K extends "a" ? Documented<X[K], XaDocsUpdated> : X[K];
};
```

In either of the cases above, `a` will be documented as "USE WITH CAUTION: Some documentation for `a`".

The real power of this utility is not in direct usage as demoed above, but rather in higher-order utilities. For instance, you could imagine a utility library that lets users specify flags that correspond to expected documentation.

```ts
import {EnsureDocumentationExists} from "some-doc-utility-lib";
import {HasDescriptionAndExampleDocs, HasDescriptionDocs} from "./my-own-potentially-poorly-documented-types";

export type A = EnsureDocumentationExists<HasDescriptionAndExampleDocs, {description: true; example: true}>;
export type B = EnsureDocumentationExists<HasDescriptionDocs, {description: true; example: true}>; // type-error
export type C = EnsureDocumentationExists<HasDescriptionDocs, {description: true}>;
```

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).