Q:

How to view updated state in another reducer?

I've 2 reducers A, B residing in packages A and B respectively. I've a store in package A which combines both reducers. 
Package A consumes package B. However, package B has a form which upon submission must update the components defined in package A. I've defined an action in package B and want reducer A to handle that action.  
I am able to get to the case statement for the action but the state in the reducer A doesn't reflect the global state. I thought once the store's state was updated all the reducers states' which make up the store would be updated but that doesn't seem to be the case. Reducer A is maintaining its own state which is a subset of the global store state. How do I make reducer A access the state updates brought by reducer B? 
One thought I had was to merge reducer B within A but that would make package B dependent on A. I haven't tried using redux-form since we've our own internal components for form elements. Any other thoughts/suggestions?   
Update : Adding some code, the action types are constants defined as strings. Upon submission of the form I want SUBMIT_COURSE_DATA action to be dispatched and have the state updated in reducer A. Store is essentially using combineReducers to combine the reducers A and B.
// Reducer B
const bReducer = (state = {
selectedCourse: {
     courseType: ""
 },  
}, action) => {
  const newState = Object.assign({}, state);
switch (action.type) {
    case COURSE_DATA_CHANGE:
          newState.selectedCourse.courseType = action.courseType;
  } 
};

export default bReducer;  

// Action B 
 export function handleCourseDataChange(courseType) {
 return {
    type: COURSE_DATA_CHANGE,
    courseType : courseType
 }
}

 export function submitCourseData() {
  return {
    type: SUBMIT_COURSE_DATA,
  }
}

 //Reducer A

    const formReducers = (state = {
    coursesContext: {
    data: [],
    actions: []
  },  
}, action) => {  
const newState = Object.assign({}, state);  
 case SUBMIT_COURSE_DATA:
      newState.coursesContext.data = [newState.coursesContext.data, Object.assign({},
        {"Course_Type": newState.selectedCourse.courseType})];
    return newState;

     // store.js
        import { reducers as modalManagerReducers } from 'modal';
import { createStore, combineReducers, applyMiddleware } from 'redux';
import reduceReducers  from 'reduce-reducers';
import createSagaMiddleware from 'redux-saga';
import { baseReducers } from '../../../packageB/src/components/AddCourseDialog';
import  courseFormReducers from './reducers';
import  formSubmissionReducer from './formReducer';
import { SUBMIT_COURSE_DATA } from '../../../packageB/src/components/actions';

const sagaMiddleware = createSagaMiddleware();

const courseReducer = Object.assign({}, { model: courseFormReducers });

const mainReducer = combineReducers(Object.assign({}, baseReducers, courseReducer, modalManagerReducers ));

const formSubmissionReducer = function(state,action) {
   switch (action.type)
   {
       case SUBMIT_COURSE_DATA:
           return formSubmissionReducer(state.selectedCourse);

       default:
           return state;
   }
};

const rootReducer = reduceReducers(mainReducer, formSubmissionReducer);

const store = createStore(
    rootReducer,
    compose(applyMiddleware(sagaMiddleware)),
);

export  {store, sagaMiddleware};

// formSubmissionReducer is same as reducer A. Just that now reducer A
   doesn't have a case for SUBMIT_COURSE_DATA anymore.

//AddCourseDialog 

// Form Submit handler
 handleSubmit(e) {
    e.preventDefault();
    this.props.dispatch(submitCourseData());
}

    // How to ensure that formSubmissionReducer in the store gets invoked here?
    const baseReducers = Object.assign({}, { baseReducer: courseBaseReducers });
export { baseReducers };

export default connect(mapStateToProps)(AddCourseDialog);

Updated to include the AddCourseDialog container which handles the on change and submit events by dispatching actions. 

A:

Per the Redux FAQ entry on sharing state between slice reducers:

Many users later want to try to share data between two reducers, but find that combineReducers does not allow them to do so. There are several approaches that can be used:

If a reducer needs to know data from another slice of state, the state tree shape may need to be reorganized so that a single reducer is handling more of the data.
You may need to write some custom functions for handling some of these actions. This may require replacing combineReducers with your own top-level reducer function. You can also use a utility such as reduce-reducers to run combineReducers to handle most actions, but also run a more specialized reducer for specific actions that cross state slices.
Async action creators such as redux-thunk have access to the entire state through getState(). An action creator can retrieve additional data from the state and put it in an action, so that each reducer has enough information to update its own state slice.

There's also many other third-party reducer utilities available, and some of those may be useful.  In particular, you might want to look at ryo33/combine-section-reducers, convoyinc/combined-reduction, and KodersLab/topologically-combine-reducers.
update
Per your question about why "r isn't a reducer", right now you have:
const courseReducer = Object.assign({}, { model: courseFormReducers });

const mainReducer = Object.assign({}, baseReducers, courseReducer,        
                                 modalManagerReducers );

That's not what you need.  You need to pass those slice reducers to combineReducers to form the initial "per-slice handling" reducer.  Then, if you do want to use reduceReducers, pass both of the "top-level state" reducers in.  Here's an example:
const combinedReducer = combineReducers({
    model : courseFormReducers,
    anotherSlice : anotherSliceReducer
});

const rootReducer = reduceReducers(combinedReducer, formSubmissionReducer);

const store = createStore(rootReducer);

