Merge pull request #7 from jeffreylanters/feature/async-await

Feature/async await

Author: jeffreylanters

README.md

@@ -51,18 +51,6 @@ openupm add nl.elraccoone.promises
 
 # Documentation
 
-## Syntax
-
-```cs
-new Promise ((resolve, reject) => { /* ... */ });
-new Promise<ResolveType> ((resolve, reject) => { /* ... */ });
-new Promise<ResolveType, RejectType> ((resolve, reject) => { /* ... */ });
-```
-
-A function that is passed with the arguments resolve and reject. The executor function is executed immediately by the Promise implementation, passing resolve and reject functions (the executor is called before the Promise constructor even returns the created object). The resolve and reject functions, when called, resolve or reject the promise, respectively. The executor normally initiates some asynchronous work, and then, once that completes, either calls the resolve function to resolve the promise or else rejects it if an error occurred. If an error is thrown in the executor function, the promise is rejected. The return value of the executor is ignored.
-
-## Description
-
 A Promise is a proxy for a value not necessarily known when the promise is created. It allows you to associate handlers with an asynchronous action's eventual success value or failure reason. This lets asynchronous methods return values like synchronous methods: instead of immediately returning the final value, the asynchronous method returns a promise to supply the value at some point in the future.
 
 A Promise is in one of these states:
@@ -73,6 +61,16 @@ A Promise is in one of these states:
 
 A pending promise can either be fulfilled with a value, or rejected with a reason (error). When either of these options happens, the associated handlers queued up by a promise's then method are called. (If the promise has already been fulfilled or rejected when a corresponding handler is attached, the handler will be called, so there is no race condition between an asynchronous operation completing and its handlers being attached.)
 
+## Syntax
+
+A function that is passed with the arguments resolve and reject. The executor function is executed immediately by the Promise implementation, passing resolve and reject functions (the executor is called before the Promise constructor even returns the created object). The resolve and reject functions, when called, resolve or reject the promise, respectively. The executor normally initiates some asynchronous work, and then, once that completes, either calls the resolve function to resolve the promise or else rejects it if an error occurred. If an error is thrown in the executor function, the promise is rejected. The return value of the executor is ignored.
+
+```cs
+new Promise ((resolve, reject) => { /* ... */ });
+new Promise<ResolveType> ((resolve, reject) => { /* ... */ });
+new Promise<ResolveType, RejectType> ((resolve, reject) => { /* ... */ });
+```
+
 ## Creating a Promise
 
 A Promise object is created using the new keyword and its constructor. This constructor takes as its argument a function, called the "executor function". This function should take two functions as parameters. The first of these functions (resolve) is called when the asynchronous task completes successfully and returns the results of the task as a value. The second (reject) is called when the task fails, and returns the reason for failure, which is typically an error object.
@@ -121,7 +119,7 @@ public void Start () {
 }
 ```
 
-### Using Async/Await method
+### Using Async/Await methods
 
 When chaining multiple promises after one another or when simply wanting to prevent a lot of nested callbacks, use the async await logic to keep things simple. There are two ways of doing so, the simplest way does not require any changes on the promise's creation side. A basic implementation could be as following.