Add technical reference labels everywhere (#251)

The labels will allow us to cross-reference between parts of the
documentation more easily.

Author: jstasiak

docs/reference/asyncoption.rst

@@ -1,3 +1,5 @@
+.. _class-AsyncOption:
+
 AsyncOption
 ===========
 
@@ -36,6 +38,8 @@ Or you can use the :ref:`Option.toAsyncOption() <method-Option-toAsyncOption>` m
 
     const option3 = Some(1).toAsyncOption()
 
+.. _method-AsyncOption-andThen:
+
 ``andThen()``
 -------------
 
@@ -60,6 +64,8 @@ Example:
     await hasValue.andThen(async (value) => None).promise // None
     await noValue.andThen(async (value) => Some(value * 2)).promise // None
 
+.. _method-AsyncOption-map:
+
 ``map()``
 ---------
 
@@ -83,6 +89,8 @@ Example:
     await noValue.map(async (value) => value * 2).promise // None
 
 
+.. _method-AsyncOption-or:
+
 ``or()``
 --------
 
@@ -129,6 +137,8 @@ Example:
 
 
 
+.. _attribute-AsyncOption-promise:
+
 ``promise``
 -----------
 
@@ -142,6 +152,8 @@ You can await it to convert ``AsyncOption<T>`` to ``Option<T>``, but prefer
 awaiting ``AsyncOption`` directly (see: `then()`_). Only use this property
 if you need the underlying Promise for specific use cases.
 
+.. _method-AsyncOption-then:
+
 ``then()``
 ----------
 
@@ -165,6 +177,8 @@ Example:
     const asyncOption = new AsyncOption(Some(42))
     const option = await asyncOption // Returns Option<number>
 
+.. _method-AsyncOption-toResult:
+
 ``toResult()``
 --------------
 

docs/reference/asyncresult.rst

@@ -1,3 +1,5 @@
+.. _class-AsyncResult:
+
 AsyncResult
 ===========
 
@@ -37,6 +39,8 @@ Or you can use the :ref:`Result.toAsyncResult() <method-Result-toAsyncResult>` m
     const result3 = Ok(1).toAsyncResult()
 
 
+.. _method-AsyncResult-andThen:
+
 ``andThen()``
 -------------
 
@@ -61,6 +65,8 @@ Example:
     await badResult.andThen(async (value) => Ok(value * 2)).promise // Err('boo')
 
 
+.. _method-AsyncResult-map:
+
 ``map()``
 ---------
 
@@ -83,6 +89,8 @@ Example:
     await goodResult.map(async (value) => value * 2).promise // Ok(2)
     await badResult.andThen(async (value) => value * 2).promise // Err('boo')
 
+.. _method-AsyncResult-mapErr:
+
 ``mapErr()``
 ------------
 
@@ -104,6 +112,8 @@ Example:
     await badResult.mapErr(async (error) => `Error is ${error}`).promise // Err('Error is boo')
 
 
+.. _method-AsyncResult-or:
+
 ``or()``
 --------
 
@@ -153,6 +163,8 @@ Example:
     await goodResult.orElse(() => Ok(123)).promise // Ok(1)
 
 
+.. _attribute-AsyncResult-promise:
+
 ``promise``
 -----------
 
@@ -166,6 +178,8 @@ You can await it to convert ``AsyncResult<T, E>`` to ``Result<T, E>``, but prefe
 awaiting ``AsyncResult`` directly (see: `then()`_). Only use this property 
 if you need the underlying Promise for specific use cases.
 
+.. _method-AsyncResult-then:
+
 ``then()``
 ----------
 
@@ -190,6 +204,8 @@ Example:
     const result = await asyncResult // Returns Result<number, Error>
 
 
+.. _method-AsyncResult-toOption:
+
 ``toOption()``
 --------------
 

docs/reference/option.rst

@@ -1,3 +1,5 @@
+.. _class-Option:
+
 Option
 ======
 
@@ -20,6 +22,8 @@ Construction:
     const some = Some('some value')
     // None is a singleton, no construction necessary
 
+.. _method-Option-all:
+
 ``all()``
 ---------
 
@@ -45,6 +49,8 @@ Example:
     let optionsWithNone: Option<number>[] = [Some(1), None, Some(3)];
     Option.all(optionsWithNone); // None, type: Option<number[]>
 
+.. _method-Option-any:
+
 ``any()``
 ---------
 
@@ -69,6 +75,8 @@ Example:
     Option.any([None, None, Some(3)]); // Some(3), type: Option<number>
     Option.any([None, None, None]); // None, type: Option<never>
 
+.. _attribute-Some-EMPTY:
+
 ``Some.EMPTY``
 --------------
 
@@ -85,6 +93,8 @@ Example:
 
     const x: Option<void> = Some.EMPTY
 
+.. _method-Option-andThen:
+
 ``andThen()``
 -------------
 
@@ -95,11 +105,15 @@ Example:
 Calls ``mapper`` if the ``Option`` is ``Some``, otherwise returns ``None``.
 This function can be used for control flow based on ``Option`` values.
 
+.. _attribute-Some-value:
+
 ``value``
 ---------
 
 The value contained in ``Some``. Only present on ``Some`` objects.
 
+.. _method-Option-expect:
+
 ``expect()``
 ------------
 
@@ -116,6 +130,8 @@ there won't be an exception thrown on access.
 
 ``msg``: the message to throw if no ``Some`` value.
 
+.. _method-Option-isNone:
+
 ``isNone()``
 ------------
 
@@ -125,6 +141,8 @@ there won't be an exception thrown on access.
 
 ``true`` when the ``Option`` is ``None``.
 
+.. _method-Option-isSome:
+
 ``isSome()``
 ------------
 
@@ -134,6 +152,8 @@ there won't be an exception thrown on access.
 
 ``true`` when the ``Option`` is ``Some``.
 
+.. _method-Option-map:
+
 ``map()``
 ---------
 
@@ -146,6 +166,8 @@ leaving a ``None`` value untouched.
 
 This function can be used to compose the Options of two functions.
 
+.. _method-Option-mapOr:
+
 ``mapOr()``
 -----------
 
@@ -159,6 +181,8 @@ of ``Some``) or using the ``default_`` value (in case of ``None``).
 If ``default_`` is a result of a function call consider using `mapOrElse()`_ instead, it will
 only evaluate the function when needed.
 
+.. _method-Option-mapOrElse:
+
 ``mapOrElse()``
 ---------------
 
@@ -169,6 +193,8 @@ only evaluate the function when needed.
 Maps an ``Option<T>`` to ``Option<U>`` by either converting ``T`` to ``U`` using ``mapper`` (in case
 of ``Some``) or producing a default value using the ``default_`` function (in case of ``None``).
 
+.. _method-Option-or:
+
 ``or()``
 --------
 
@@ -188,6 +214,8 @@ Example:
     Some(1).or(Some(2)) // => Some(1)
     None.or(Some(2)) // => Some(2)
 
+.. _method-Option-orElse:
+
 ``orElse()``
 ------------
 
@@ -207,6 +235,8 @@ Example:
     Some(1).orElse(() => Some(2)) // => Some(1)
     None.orElse(() => Some(2)) // => Some(2)
 
+.. _type-OptionSomeType:
+
 ``OptionSomeType``
 ------------------
 
@@ -223,6 +253,8 @@ Example:
     type Input = Option<string>
     type Output = OptionSomeType<Input> // string
 
+.. _type-OptionSomeTypes:
+
 ``OptionSomeTypes``
 -------------------
 
@@ -254,6 +286,8 @@ Creates an `AsyncOption` based on this `Option`.
 Useful when you need to compose results with asynchronous code.
 
 
+.. _method-Option-toResult:
+
 ``toResult()``
 --------------
 
@@ -263,6 +297,8 @@ Useful when you need to compose results with asynchronous code.
 
 Maps an ``Option<T>`` to a ``Result<T, E>``.
 
+.. _method-Option-unwrap:
+
 ``unwrap()``
 ------------
 
@@ -281,6 +317,8 @@ there won't be an exception thrown on access.
 
 Throws if the value is ``None``.
 
+.. _method-Option-unwrapOr:
+
 ``unwrapOr()``
 --------------
 
@@ -290,6 +328,8 @@ Throws if the value is ``None``.
 
 Returns the contained ``Some`` value or a provided default.
 
+.. _method-Option-unwrapOrElse:
+
 ``unwrapOrElse()``
 ------------------
 
@@ -311,6 +351,8 @@ Example:
 
     None.unwrapOrElse(() => 'UGH') // => 'UGH'
 
+.. _method-Option-Iterable:
+
 Iterable
 --------