Merge pull request #4

Improve documentation and typings

Author: AIRTucha

README.md

@@ -62,11 +62,12 @@ Implementation of PromiseLike.then() for proper functioning of await
 
 **return** *PromiseLike* object which inclose new value
 
-    Monad<T>.prototype.then<TResult1 = T, TResult2 = never>(
-        onfulfilled?: ( ( value: T ) => TResult1 | PromiseLike<TResult1> ) | undefined | null,
-        onrejected?: ( ( reason: any ) => TResult2 | PromiseLike<TResult2> ) | undefined | null
-    ): PromiseLike<TResult1 | TResult2>
-
+```typescript
+Monad<T>.prototype.then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ( ( value: T ) => TResult1 | PromiseLike<TResult1> ) | undefined | null,
+    onrejected?: ( ( reason: any ) => TResult2 | PromiseLike<TResult2> ) | undefined | null
+): PromiseLike<TResult1 | TResult2>
+```
 It is internally utilized by *bind()*.
 
 #### Monad.prototype.get()
@@ -75,63 +76,174 @@ Returns the value inclosed inside container.
 
 Signature for *Maybe* is:
 
-    Maybe<T>.prototype.get(): T | undefined
+```typescript
+Maybe<T>.prototype.get(): T | undefined
+```
 
 Signature for *Result* is:
 
-    Result<T, E>.prototype.get(): T | E
+```typescript
+Result<T, E>.prototype.get(): T | E
+```
 
 #### Monad.prototype.getOrElse()
 
 Returns the inclosed primary value or the one provided as an argument.
 
 Signature for *Maybe* is:
 
-    Maybe<T>.prototype.getOrElse( value: T): T 
+```typescript
+Maybe<T>.prototype.getOrElse( value: T): T 
+```
 
 Signature for *Result* is:
 
-    Result<T, E>.prototype.getOrElse( value: T): T  
-
-### Maybe<T>
+```typescript
+Result<T, E>.prototype.getOrElse( value: T): T  
+```
 
-Maybe<T> itself represents a union type of Just<T> and None<T>.
+### Maybe
 
-#### Maybe<T>(value: T | undefined | null) => Maybe<T>
+*Maybe<T>* itself represents a union type of Just<T> and None<T>.
 
 It is also a *smart factory* which turns Nullable object to *Just<T>* or *None<T>* accordingly.
 
-#### Just<T>
+```typescript
+Maybe<T>(value: T | undefined | null) => Maybe<T>
+```
 
-Represents a value of specified type.
+#### Just
 
-#### Just<T>(value: T) => Maybe<T> 
+Represents a value of specified type. It can be created via a factory which wraps the value with *Just<T>*
 
-Wraps a value with *Just<T>*
+```typescript
+Just<T>(value: T) => Maybe<T> 
+```
 
-#### None<T>
+#### None
 
-Represents a absents of a value with specified type.
+Represents an absents of a value with specified type. It can be created via a factory with specified type.
 
-#### None<T>() => Maybe<T> 
+```typescript
+None<T>() => Maybe<T> 
+```
 
-Creates None of specified type.
+#### isJust
 
-#### isJust<T>(obj: any): obj is Just<T>
+It exists as a stand alone function which checks wether object of any type is *Just*
 
-Checks wether object of any type is *Just*
+```typescript
+isJust<T>(obj: any): obj is Just<T>
+```
+
+Moreover *Maybe* has a method dedicated to the same goal.
+
+```typescript
+Maybe<T>.prototype.isJust(): obj is Just<T>
+```
+
+#### isNone
+
+It exists as a stand alone function which checks wether object of any type is *None*
+
+```typescript
+isNone<T>(obj: any): obj is None<T>
+```
 
-#### isNone<T>(obj: any): obj is Just<T>
+Moreover *Maybe* has a method dedicated to the same goal.
 
-Checks wether object of any type is *None*
+```typescript
+Maybe<T>.prototype.isNone(): obj is Just<T>
+```
 
+### Result
 
+*Result<T, E>* itself represents a union type of Success<T, E> and Failure<T, E>.
 
+It is also a *smart factory* which calls provided function and stores its output as *Success<T, E>* or *Failure<T, E>* accordingly.
 
+```typescript
+Maybe<T, E extends Throwable>(action: () => T | Result<T, E>) => Result<T, E>
+```
 
+#### Success
+
+Represents a value of specified type. It can be created via a factory which wraps the value with *Success<T, E>*
+
+```typescript
+Success<T, E extends Throwable>(value: T) => Result<T, E>
+```
 
+#### Failure
+
+Represents an error which explains an absents of a value. It can be created via a factory with specified type.
+
+```typescript
+Failure<T, E extends Throwable>(error: E) => Result<T, E>
+```
+
+#### isSuccess
+
+It exists as a stand alone function which checks wether object of any type is *Success*
+
+```typescript
+isSuccess<T>(obj: any): obj is Success<T>
+```
+
+Moreover *Result* has a method dedicated to the same goal.
+
+```typescript
+Result<T, E>.prototype.isSuccess(): obj is Success<T, E>
+```
+
+#### isFailure
+
+It exists as a stand alone function which checks wether object of any type is *Failure*
+
+```typescript
+isFailure<T, E>(obj: any): obj is Failure<T, E>
+```
+
+Moreover *Result* has a method dedicated to the same goal.
+
+```typescript
+Result<T, E>.prototype.isFailure(): obj is Failure<T>
+```
 
 ## Contribution guidelines
 
+The project is based on *npm* eco-system. Therefore development process is organized via *npm* scripts.
+
+For installation of dependencies run
+
+    npm install
+
+Build application once
+
+    npm run build
+
+Build application and watch for changes of files
+
+    npm run build:w
+
+Run tslint one time for CI
+
+    npm run lint
+
+Unit tests in a watching mode are performed by 
+
+    npm run test
+    
+A single run of test suit
+
+    npm run test:once
+
+A single run of test suit with test coverage report
+
+    npm run cover
+
+A single run of test suit with test coverage report
 
+    npm run test:ci
 
+Everybody is welcome to contribute and submit pull requests. Please communicate your ideas and suggestions via *issues*.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "amonad",
-  "version": "0.2.1",
+  "version": "0.2.3", 
   "description": "Experimental implementation of Maybe and Result monads compatible with await.",
   "main": "./dist/index.js",
   "scripts": {