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

def result(self, timeout=None):
        """
        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
        """
        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