Merge pull request #15 from abraham/switch

Use a switch for type narrowing

Author: abraham

src/index.test.ts

@@ -1,4 +1,13 @@
-import { Failure, fold, Initialized, Pending, Success } from './index';
+import { Failure, fold, Initialized, Kinds, Pending, Success } from './index';
+
+test('Kinds', () => {
+  expect(Kinds).toEqual({
+    'Failure': 'Failure',
+    'Initialized': 'Initialized',
+    'Pending': 'Pending',
+    'Success': 'Success'
+  });
+});
 
 test('Initialized', () => {
   expect(new Initialized()).toBeInstanceOf(Initialized);

src/index.ts

@@ -1,29 +1,36 @@
 export type RemoteData<E, D> = Initialized | Pending | Failure<E> | Success<D>;
 
+export enum Kinds {
+  Initialized = 'Initialized',
+  Pending = 'Pending',
+  Failure = 'Failure',
+  Success = 'Success',
+}
+
 export class Initialized {
-  private kind = 'Initialized';
+  public kind: typeof Kinds.Initialized = Kinds.Initialized;
 }
 
 export class Pending {
-  private kind = 'Pending';
+  public kind: typeof Kinds.Pending = Kinds.Pending;
 }
 
-export class Success<D> {
-  private kind = 'Success';
+export class Failure<E> {
+  public kind: typeof Kinds.Failure = Kinds.Failure;
 
-  constructor(public data: D) {
-    if (data === null || data === undefined) {
-      fail('Parameter "data" is required');
+  constructor(public error: E) {
+    if (error === null || error === undefined) {
+      fail('Parameter "error" is required');
     }
   }
 }
 
-export class Failure<E> {
-  private kind = 'Failure';
+export class Success<D> {
+  public kind: typeof Kinds.Success = Kinds.Success;
 
-  constructor(public error: E) {
-    if (error === null || error === undefined) {
-      fail('Parameter "error" is required');
+  constructor(public data: D) {
+    if (data === null || data === undefined) {
+      fail('Parameter "data" is required');
     }
   }
 }
@@ -35,16 +42,17 @@ export function fold<T, E, D>(
   success: (data: D) => T,
 ): (state: RemoteData<E, D>) => T {
   return (state: RemoteData<E, D>) => {
-    if (state instanceof Initialized) {
-      return initialized();
-    } else if (state instanceof Pending) {
-      return pending();
-    } else if (state instanceof Success) {
-      return success(state.data);
-    } else if (state instanceof Failure) {
-      return failure(state.error);
-    } else {
-      return fail('Unknown RemoteData type used');
+    switch (state.kind) {
+      case Kinds.Initialized:
+        return initialized();
+      case Kinds.Pending:
+        return pending();
+      case Kinds.Failure:
+        return failure(state.error);
+      case Kinds.Success:
+        return success(state.data);
+      default:
+        return fail('Unknown RemoteData type used');
     }
   }
 }