add aliases for capitalized methods

README.md

@@ -1,17 +1,21 @@
 # Grip
 
+
+[A take on Go Style Error Handling In JavaScript](https://dev.to/nesterow/a-take-on-go-style-error-handling-in-javascript-577)
+
 Simplified result/error handling for JavaScript.
 Grip always returns a consistent call result ready to be handled.
 It makes the control flow similar to that of Golang, but doesn't force you to make additional null checks or create transitional variables to hold error results.
 
+
 Instead of returning a nullish error, Grip always returns a consistent status object:
 
 ```javascript
 const [value, status] = grip(callable)
-if (status.Of(MySpecificError)) {
+if (status.of(MySpecificError)) {
   // handle specific error
 }
-if (status.Fail()) {
+if (status.fail()) {
   // handle any error
 }
 ```
@@ -20,10 +24,10 @@ The call result is better than tuple:
 
 ```javascript
 const result = grip(callable)
-if (result.Fail()) {
+if (result.fail()) {
   // handle any error
 }
-if (result.Of(MySpecificError)) {
+if (result.of(MySpecificError)) {
   // handle specific error
 }
 

dist/grip.js

@@ -18,12 +18,21 @@ class Err extends Error {
   Ok() {
     return false;
   }
+  ok() {
+    return this.Ok();
+  }
   Fail() {
     return true;
   }
+  fail() {
+    return this.Fail();
+  }
   Of(cls) {
     return this.cause instanceof cls || this instanceof cls;
   }
+  of(cls) {
+    return this.Of(cls);
+  }
   static fromCatch(error) {
     const e = new Err(typeof error === "string" ? error : error.message);
     e.cause = error;
@@ -36,12 +45,21 @@ class Ok {
   Ok() {
     return true;
   }
+  ok() {
+    return this.Ok();
+  }
   Fail() {
     return false;
   }
+  fail() {
+    return this.Fail();
+  }
   Of(cls) {
     return this instanceof cls;
   }
+  of(cls) {
+    return this.Of(cls);
+  }
   toString() {
     return "Ok";
   }
@@ -64,12 +82,21 @@ class Result extends Array {
   Ok() {
     return this[1].Ok();
   }
+  ok() {
+    return this.Ok();
+  }
   Fail() {
     return this[1].Fail();
   }
+  fail() {
+    return this.Fail();
+  }
   Of(cls) {
     return this[1].Of(cls);
   }
+  of(cls) {
+    return this.Of(cls);
+  }
   Iter() {
     const value = this.value;
     const that = this;
@@ -92,6 +119,9 @@ class Result extends Array {
       }
     };
   }
+  iter() {
+    return this.Iter();
+  }
 }
 var promise = (result) => {
   return result.then((res) => new Result(res, new Ok)).catch((err) => new Result(null, Err.fromCatch(err)));

grip.test.ts

@@ -49,7 +49,7 @@ test("fetch err", async () => {
   const [result, status] = await grip(fetch("https://localhost:30012"));
   expect(status.Ok()).toBe(false);
   expect(result === null).toBe(true);
-  expect(status.Of(Error)).toBe(true);
+  expect(status.of(Error)).toBe(true);
 });
 
 test("fetch json", async () => {

grip.ts

@@ -2,20 +2,38 @@ interface Status {
   message?: string;
   cause?: any;
   Ok(): boolean;
+  /* alias Ok */
+  ok(): boolean;
   Fail(): boolean;
+  /* alias Fail */
+  fail(): boolean;
   Of(cls: any): boolean;
+  /* alias Of */
+  of(cls: any): boolean;
 }
 
 export class Err extends Error {
   Ok() {
     return false;
   }
+  /* alias Ok */
+  ok() {
+    return this.Ok();
+  }
   Fail() {
     return true;
   }
+  /* alias Fail */
+  fail() {
+    return this.Fail();
+  }
   Of(cls: any) {
     return this.cause instanceof cls || this instanceof cls;
   }
+  /* alias Of */
+  of(cls: any) {
+    return this.Of(cls);
+  }
   static fromCatch(error: any) {
     const e = new Err(typeof error === "string" ? error : error.message);
     e.cause = error;
@@ -28,12 +46,24 @@ export class Ok {
   Ok() {
     return true;
   }
+  /* alias Ok */
+  ok() {
+    return this.Ok();
+  }
   Fail() {
     return false;
   }
+  /* alias Fail */
+  fail() {
+    return this.Fail();
+  }
   Of(cls: any) {
     return this instanceof cls;
   }
+  /* alias Of */
+  of(cls: any) {
+    return this.Of(cls);
+  }
   toString() {
     return "Ok";
   }
@@ -66,12 +96,24 @@ class Result<T> extends Array<T | Status> implements IResult<T> {
   Ok() {
     return (this[1] as Status).Ok();
   }
+  /* alias Ok */
+  ok() {
+    return this.Ok();
+  }
   Fail() {
     return (this[1] as Status).Fail();
   }
+  /* alias Fail */
+  fail() {
+    return this.Fail();
+  }
   Of(cls: any) {
     return (this[1] as Status).Of(cls);
   }
+  /* alias Of */
+  of(cls: any) {
+    return this.Of(cls);
+  }
   Iter() {
     const value = this.value;
     const that = this;
@@ -100,6 +142,10 @@ class Result<T> extends Array<T | Status> implements IResult<T> {
       },
     };
   }
+  /* alias Iter */
+  iter() {
+    return this.Iter();
+  }
 }
 
 type Unwrap<T> =