type variables abridgment

Author: Péter Hauszknecht

src/store/middlewares/thunk.ts

@@ -1,26 +1,26 @@
 import { Middleware, GetState, Dispatch, Reducer, Store } from '../types';
 
-export interface ThunkMiddleware<State, ExtraArgument>
-  extends Middleware<State, Reducer<State>, Thunk<State, ExtraArgument>> {
-  (store: Store<State, Reducer<State> | Delegate<State, ExtraArgument>>): {
-    (next: Dispatch<Reducer<State>, State>): Dispatch<Delegate<State, ExtraArgument>>;
+export interface ThunkMiddleware<S, EA>
+  extends Middleware<S, Reducer<S>, Thunk<S, EA>> {
+  (store: Store<S, Reducer<S> | Delegate<S, EA>>): {
+    (next: Dispatch<Reducer<S>, S>): Dispatch<Delegate<S, EA>>;
   };
-  withExtraArgument: <EA>(extraArgument: EA) => ThunkMiddleware<State, EA>;
+  withExtraArgument: <EA>(extraArgument: EA) => ThunkMiddleware<S, EA>;
 }
 
-export interface Delegate<State, ExtraArgument, Return = any> {
-  (dispatch: ThunkDispatch<State, ExtraArgument>, getState: GetState<State>, extraArgument: ExtraArgument): Return;
+export interface Delegate<S, EA, RE = any> {
+  (dispatch: ThunkDispatch<S, EA>, getState: GetState<S>, extraArgument: EA): RE;
 }
 
-export interface Thunk<State, ExtraArgument, Return = any> {
-  (state: State): Delegate<State, ExtraArgument, Return>;
+export interface Thunk<S, EA, RE = any> {
+  (state: S): Delegate<S, EA, RE>;
 }
 
-export interface ThunkDispatch<State, ExtraArgument> extends Dispatch<Reducer<State>, State> {
-  <Return>(thunk: Thunk<State, ExtraArgument, Return>): Return;
+export interface ThunkDispatch<S, EA> extends Dispatch<Reducer<S>, S> {
+  <Return>(thunk: Thunk<S, EA, Return>): Return;
 }
 
-const thunkFactory = <State, ExtraArgument>(extraArgument?: ExtraArgument) => {
+const thunkFactory = <S, EA>(extraArgument?: EA) => {
   const thunk = (store => next => reducer => {
     if (typeof reducer !== 'function') throw new Error('Thunk requires reducers as functions');
     const state = store.getState();
@@ -30,7 +30,7 @@ const thunkFactory = <State, ExtraArgument>(extraArgument?: ExtraArgument) => {
       next(_ => result);
       return reducer;
     }
-  }) as ThunkMiddleware<State, ExtraArgument>;
+  }) as ThunkMiddleware<S, EA>;
   thunk.withExtraArgument = thunkFactory;
   return thunk;
 };

src/store/types.ts

@@ -1,13 +1,13 @@
-export interface GetState<State> {
-  (): State;
+export interface GetState<S> {
+  (): S;
 }
 
 export interface Reducer<State> {
   (state: State): State;
 }
 
-export interface Dispatch<Reducer, State = any> {
-  (reducer: Reducer): State;
+export interface Dispatch<R, S = any> {
+  (reducer: R): S;
 }
 
 export interface Listener {
@@ -18,15 +18,15 @@ export interface Unsubscribe {
   (): void;
 }
 
-export interface Middleware<State, R1, R2> {
-  (store: Store<State, R1>): {
-    (next: Dispatch<R1, State>): Dispatch<R2>;
+export interface Middleware<S, R1, R2> {
+  (store: Store<S, R1>): {
+    (next: Dispatch<R1, S>): Dispatch<R2>;
   };
 }
 
-export interface Store<State, R = Reducer<State>> {
-  getState: GetState<State>;
-  dispatch: Dispatch<R, State>;
+export interface Store<S, R = Reducer<S>> {
+  getState: GetState<S>;
+  dispatch: Dispatch<R, S>;
   subscribe(listener: Listener): Unsubscribe;
-  addMiddleware<R2>(...middlewares: Middleware<State, R, R2>[]): Store<State, R | R2>;
+  addMiddleware<R2>(...middlewares: Middleware<S, R, R2>[]): Store<S, R | R2>;
 }