docs: def get_space(self, current_result_list, current_query, param_space, runs,
                    result_parsing_function):
          """
          Convert a parameter space specification to a nested array structure
          representing the space. In other words, if the parameter space is::
  
              param_space = {
                  'a': [1, 2],
                  'b': [3, 4]
              }
  
          the function will return a structure like the following::
  
              [
                  [
                      {'a': 1, 'b': 3},
                      {'a': 1, 'b': 4}
                  ],
                  [
                      {'a': 2, 'b': 3},
                      {'a': 2, 'b': 4}
                  ]
              ]
  
          where the first dimension represents a, and the second dimension
          represents b. This nested-array structure can then be easily converted
          to a numpy array via np.array().
  
          Args:
              current_query (dict): the query to apply to the structure.
              param_space (dict): representation of the parameter space.
              result_parsing_function (function): user-defined function to call
                  on results, typically used to parse data and outputting
                  metrics.
              runs (int): the number of runs to query for each parameter
                  combination.
          """
          if result_parsing_function is None:
              result_parsing_function = CampaignManager.files_in_dictionary
              # Note that this function operates recursively.
  
          # Base case
          if not param_space:
              results = [r for r in current_result_list if
                         self.satisfies_query(r, current_query)]
              parsed = []
              for r in results[:runs]:
                  parsed.append(result_parsing_function(r))
  
              return parsed
  
          space = []
          [key, value] = list(param_space.items())[0]
          # Iterate over dictionary values
          for v in value:
              next_query = deepcopy(current_query)
              temp_query = deepcopy(current_query)
              # For each list, recur 'fixing' that dimension.
              next_query[key] = v
              next_param_space = deepcopy(param_space)
              del(next_param_space[key])
              temp_query[key] = v
              temp_result_list = [r for r in current_result_list if
                                  self.satisfies_query(r, temp_query)]
              space.append(self.get_space(temp_result_list, next_query,
                                          next_param_space, runs,
                                          result_parsing_function))
          return space