add document.

Author: bromne

README.md

@@ -12,7 +12,14 @@ Optional (like Java) implementation in TypeScript
 `Optional<T>` is a type which *may* or *may not* contain a *payload* of type `T`.
 It provides a common interface regardless of whether an instance is *present* or is *empty*. 
 
-This module is inspired by [Optional class in Java 8+](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html).
+This module is inspired by [Optional class in Java 8+](https://docs.oracle.com/javase/10/docs/api/java/util/Optional.html).
+
+ The following methods are currently not supported:
+ 
+ - `equals`
+ - `toString`
+ - `hashCode`
+ - `stream`
 
 ### Install
 

lib/index.ts

@@ -1,5 +1,20 @@
 import { Option, Cases } from "./types";
 
+/**
+ * `Optional` (like Java) implementation in TypeScript.
+ * 
+ * `Optional<T>` is a type which *may* or *may not* contain a *payload* of type `T`.
+ * It provides a common interface regardless of whether an instance is *present* or is *empty*. 
+ *
+ * This module is inspired by [Optional class in Java 8+](https://docs.oracle.com/javase/10/docs/api/java/util/Optional.html).
+ * 
+ * The following methods are currently not supported:
+ * 
+ * - `equals`
+ * - `toString`
+ * - `hashCode`
+ * - `stream`
+ */
 export default abstract class Optional<T> {
     /**
      * Returns `true` if this is present, otherwise `false`.
@@ -95,12 +110,30 @@ export default abstract class Optional<T> {
      */
     abstract orElseThrow<U>(errorSupplier: () => U): T;
 
+    /**
+     * Converts this to an `Option`.
+     */
     abstract toOption(): Option<T>;
 
+    /**
+     * If a payload is present, returns the payload,
+     * otherwise returns `null`.
+     */
     abstract orNull(): T | null;
 
+    /**
+     * If a payload is present, returns the payload,
+     * otherwise returns `undefined`.
+     */
     abstract orUndefined(): T | undefined;
 
+    /**
+     * Returns an appropriate result by emulating pattern matching with the given `cases`.
+     * If a payload is present, returns the result of `present` case,
+     * otherwise returns the result of `empty` case.
+     * 
+     * @param cases cases for this `Optional`
+     */
     abstract matches<U>(cases: Cases<T, U>): U;
 
     /**
@@ -147,6 +180,12 @@ export default abstract class Optional<T> {
         return new EmptyOptional();
     }
 
+    /**
+     * Retrieve the given `option` as an Optional.
+     * 
+     * @param option an `Option` object to retrieve
+     * @throws {TypeError} when the given `option` does not have a valid `kind` attribute.
+     */
     static from<T>(option: Option<T>): Optional<T> {
         switch (option.kind) {
             case "present": return Optional.of(option.value);

lib/types.ts

@@ -1,8 +1,23 @@
+/**
+ * An interface that represents respective cases of pattern matching of `Optional`.
+ */
 export interface Cases<T, U> {
-    present: (value: T) => U
-    empty: () => U
+    /**
+     * A mapper that maps a payload for case of an `Optional` is present.
+     */
+    present: (value: T) => U;
+
+    /**
+     * A supplier that provides a value for case  of  an `Optional` is empty.
+     */
+    empty: () => U;
 }
 
+/**
+ * An alias of algebraic, prototype-free JavaScript object which represents `Optional`.
+ * Objects of this type are provided by `Optional.toOption`
+ * and they can be retrieved as `Optional` by `Optional.from`.
+ */
 export type Option<T> = Present<T> | Empty<T>
 
 export interface Present<T> {