docs(eslint-plugin): Expand docs for array-type (typescript-eslint#634)

bradzacher · web-flow · commit 44b099df8a5f · 2019-06-28T08:37:18.000-07:00
I noticed the docs were pretty sparse. Simple, but not hugely helpful.
I just expanded them with examples
diff --git a/packages/eslint-plugin/docs/rules/array-type.md b/packages/eslint-plugin/docs/rules/array-type.md
@@ -1,33 +1,83 @@
 # Requires using either `T[]` or `Array<T>` for arrays (array-type)
 
-```ts
-class Foo<T = Array<Array<Bar>>> extends Bar<T, Array<T>>
-  implements Baz<Array<T>> {
-  private s: Array<T>;
-
-  constructor(p: Array<T>) {
-    return new Array();
-  }
-}
-```
+Using the same style for array definitions across your codebase makes it easier for your developers to read and understand the types.
 
 ## Rule Details
 
-This rule aims to standardise usage of array.
+This rule aims to standardise usage of array types within your codebase.
 
 ## Options
 
-Default config:
+This rule accepts one option - a single string
+
+- `"array"` enforces use of `T[]` for all types `T`.
+- `"generic"` enforces use of `Array<T>` for all types `T`.
+- `"array-simple"` enforces use of `T[]` if `T` is a simple type.
+
+Without providing an option, by default the rule will enforce `"array"`.
+
+### `"array"`
+
+Always use `T[]` or `readonly T[]` for all array types.
+
+Incorrect code for `"array"`:
+
+```ts
+const x: Array<string> = ["a", "b"];
+const y: ReadonlyArray<string> = ["a", "b"];
+```
 
-```JSON
-{
-    "array-type": ["error", "array"]
-}
+Correct code for `"array"`:
+
+```ts
+const x: string[] = ["a", "b"];
+const y: readonly string[] = ["a", "b"];
 ```
 
-- `array` enforces use of `T[]` for all types `T`.
-- `generic` enforces use of `Array<T>` for all types `T`.
-- `array-simple` enforces use of `T[]` if `T` is a simple type.
+### `"generic"`
+
+Always use `Array<T>` or `ReadonlyArray<T>` for all array types.
+
+Incorrect code for `"generic"`:
+
+```ts
+const x: string[] = ["a", "b"];
+const y: readonly string[] = ["a", "b"];
+```
+
+Correct code for `"generic"`:
+
+```ts
+const x: Array<string> = ["a", "b"];
+const y: ReadonlyArray<string> = ["a", "b"];
+```
+
+### `"array-simple"`
+
+Use `T[]` or `readonly T[]` for simple types (i.e. types which are just primitive names or type references).
+Use `Array<T>` or `ReadonlyArray<T>` for all other types (union types, intersection types, object types, function types, etc).
+
+Incorrect code for `"array-simple"`:
+
+```ts
+const a: (string | number)[] = ["a", "b"];
+const b: ({ prop: string })[] = [{ prop: "a" }];
+const c: (() => void)[] = [() => {}];
+const d: Array<MyType> = ["a", "b"];
+const e: Array<string> = ["a", "b"];
+const f: ReadonlyArray<string> = ["a", "b"];
+```
+
+Correct code for `"array-simple"`:
+
+```ts
+const a: Array<string | number> = ["a", "b"];
+const b: Array<{ prop: string }> = [{ prop: "a" }];
+const c: Array<() => void> = [() => {}];
+const d: MyType[] = ["a", "b"];
+const e: string[] = ["a", "b"];
+const f: readonly string[] = ["a", "b"];
+```
 
 ## Related to
 
