Redux Study-- Source Code

if (
  process.env.NODE_ENV !== 'production' &&
  typeof isCrushed.name === 'string' &&
  isCrushed.name !== 'isCrushed'
) {
  warning(
    ...
  )
}

function dispatch(action: A) {
    if (!isPlainObject(action)) {
      throw new Error(
       ...
      )
    }

    if (typeof action.type === 'undefined') {
      throw new Error(
       ...
      )
    }

    if (isDispatching) {
      throw new Error('Reducers may not dispatch actions.')
    }
	
    try {
       // start running the reducer
      isDispatching = true
       // the new state comes from current reducer with current state and action
      currentState = currentReducer(currentState, action)
    } finally {
       //finish running the reducer
      isDispatching = false
    }
	/**
	* we get the new listeners here and exec them  
	* currentListeners =  nextListeners will ensure if listeners subscribe
    * unsubscribe during the exec, the change will happen in next dispatch 
	* 
	*/
    const listeners = (currentListeners = nextListeners)
    for (let i = 0; i < listeners.length; i++) {
      const listener = listeners[i]
      listener()
    }

    return action
  }

function subscribe(listener: () => void) {
    // listener should be a function
   if (typeof listener !== 'function') {
     throw new Error('Expected the listener to be a function.')
   }

   if (isDispatching) {
     throw new Error(
       ...
     )
   }
//ensure not repeatly unsubscribe
   let isSubscribed = true
/**
  * This makes a shallow copy of currentListeners so we can use
  * nextListeners as a temporary list while dispatching.
  *
  * This prevents any bugs around consumers calling
  * subscribe/unsubscribe in the middle of a dispatch.
  */
   ensureCanMutateNextListeners()
   // add linstener to nextListeners
   nextListeners.push(listener)
// unsubscribe as a return function 
   return function unsubscribe() {
     if (!isSubscribed) {
       return
     }

     if (isDispatching) {
       throw new Error(
        ...
       )
     }
  // mark as unsubscribe
     isSubscribed = false
     // again prevent buts when unsubscribe using a shallow copy
     ensureCanMutateNextListeners()
     // get index of the listener we want to unsubscribe
     const index = nextListeners.indexOf(listener)
     nextListeners.splice(index, 1)
     currentListeners = null
   }
 }

// how to make a shallow copy of current listeners
function ensureCanMutateNextListeners() {
    if (nextListeners === currentListeners) {
      nextListeners = currentListeners.slice()
    }
  }

function getState(): S {
    if (isDispatching) {
      throw new Error(
       ...
      )
    }

    return currentState as S
  }