code: def result(self, timeout=None):
          
          it, exceptions, future_lists = [], [], []
          from concurrent.futures import Future, wait as wait_fut
  
          def update(fut, data, key):
              if isinstance(fut, Future):
                  it.append((fut, data, key))
              elif isinstance(fut, AsyncList) and fut not in future_lists:
                  future_lists.append(fut)
                  it.extend([(j, fut, i)
                             for i, j in enumerate(fut)
                             if isinstance(j, Future)][::-1])
  
          for s in self.sub_sol.values():
              for k, v in list(s.items()):
                  update(v, s, k)
  
              for d in s.workflow.nodes.values():
                  if 'results' in d:
                      update(d['results'], d, 'results')
  
              for d in s.workflow.edges.values():
                  if 'value' in d:
                      update(d['value'], d, 'value')
  
          wait_fut({v[0] for v in it}, timeout)
  
          for f, d, k in it:
              try:
                  d[k] = await_result(f, 0)
              except SkipNode as e:
                  exceptions.append((f, d, k, e.ex))
                  del d[k]
              except (Exception, ExecutorShutdown, DispatcherAbort) as ex:
                  exceptions.append((f, d, k, ex))
                  del d[k]
  
          if exceptions:
              raise exceptions[0][-1]
          return self
docs: Set all asynchronous results.
  
          :param timeout:
              The number of seconds to wait for the result if the futures aren't
              done. If None, then there is no limit on the wait time.
          :type timeout: float
  
          :return:
              Update Solution.
          :rtype: Solution