def dict_stack2(dict_list, key_suffix=None, default=None):
    """
    Stacks vals from a list of dicts into a dict of lists. Inserts Nones in
    place of empty items to preserve order.

    Args:
        dict_list (list): list of dicts
        key_suffix (str): (default = None)

    Returns:
        dict: stacked_dict

    Example:
        >>> # ENABLE_DOCTEST
        >>> # Usual case: multiple dicts as input
        >>> from utool.util_dict import *  # NOQA
        >>> import utool as ut
        >>> dict1_ = {'a': 1, 'b': 2}
        >>> dict2_ = {'a': 2, 'b': 3, 'c': 4}
        >>> dict_list = [dict1_, dict2_]
        >>> dict_stacked = dict_stack2(dict_list)
        >>> result = ut.repr2(dict_stacked)
        >>> print(result)
        {'a': [1, 2], 'b': [2, 3], 'c': [None, 4]}

    Example1:
        >>> # ENABLE_DOCTEST
        >>> # Corner case: one dict as input
        >>> from utool.util_dict import *  # NOQA
        >>> import utool as ut
        >>> dict1_ = {'a': 1, 'b': 2}
        >>> dict_list = [dict1_]
        >>> dict_stacked = dict_stack2(dict_list)
        >>> result = ut.repr2(dict_stacked)
        >>> print(result)
        {'a': [1], 'b': [2]}

    Example2:
        >>> # ENABLE_DOCTEST
        >>> # Corner case: zero dicts as input
        >>> from utool.util_dict import *  # NOQA
        >>> import utool as ut
        >>> dict_list = []
        >>> dict_stacked = dict_stack2(dict_list)
        >>> result = ut.repr2(dict_stacked)
        >>> print(result)
        {}

    Example3:
        >>> # ENABLE_DOCTEST
        >>> # Corner case: empty dicts as input
        >>> from utool.util_dict import *  # NOQA
        >>> import utool as ut
        >>> dict_list = [{}]
        >>> dict_stacked = dict_stack2(dict_list)
        >>> result = ut.repr2(dict_stacked)
        >>> print(result)
        {}

    Example4:
        >>> # ENABLE_DOCTEST
        >>> # Corner case: one dict is empty
        >>> from utool.util_dict import *  # NOQA
        >>> import utool as ut
        >>> dict1_ = {'a': [1, 2], 'b': [2, 3]}
        >>> dict2_ = {}
        >>> dict_list = [dict1_, dict2_]
        >>> dict_stacked = dict_stack2(dict_list)
        >>> result = ut.repr2(dict_stacked)
        >>> print(result)
        {'a': [[1, 2], None], 'b': [[2, 3], None]}

    Example5:
        >>> # ENABLE_DOCTEST
        >>> # Corner case: disjoint dicts
        >>> from utool.util_dict import *  # NOQA
        >>> import utool as ut
        >>> dict1_ = {'a': [1, 2], 'b': [2, 3]}
        >>> dict2_ = {'c': 4}
        >>> dict_list = [dict1_, dict2_]
        >>> dict_stacked = dict_stack2(dict_list)
        >>> result = ut.repr2(dict_stacked)
        >>> print(result)
        {'a': [[1, 2], None], 'b': [[2, 3], None], 'c': [None, 4]}

    Example6:
        >>> # ENABLE_DOCTEST
        >>> # Corner case: 3 dicts
        >>> from utool.util_dict import *  # NOQA
        >>> import utool as ut
        >>> dict_list = [{'a': 1}, {'b': 1}, {'c': 1}, {'b': 2}]
        >>> default = None
        >>> dict_stacked = dict_stack2(dict_list, default=default)
        >>> result = ut.repr2(dict_stacked)
        >>> print(result)
        {'a': [1, None, None, None], 'b': [None, 1, None, 2], 'c': [None, None, 1, None]}
    """
    if len(dict_list) > 0:
        dict_list_ = [map_dict_vals(lambda x: [x], kw) for kw in dict_list]
        # Reduce does not handle default quite correctly
        default1 = []
        default2 = [default]
        accum_ = dict_list_[0]
        for dict_ in dict_list_[1:]:
            default1.append(default)
            accum_ = dict_union_combine(accum_, dict_, default=default1,
                                        default2=default2)
        stacked_dict = accum_
        # stacked_dict = reduce(partial(dict_union_combine, default=[default]), dict_list_)
    else:
        stacked_dict = {}
    # Augment keys if requested
    if key_suffix is not None:
        stacked_dict = map_dict_keys(lambda x: x + key_suffix, stacked_dict)
    return stacked_dict