Combining two infinite algorithms to create a single infinite algortihm
Is this idea correct?

(I apologize for my initial, poorly thought-out response to this question, and thank the commentors for pointing out the flaws.)

Your solution will work if $g(\cdot)$ is differentiable around $f(x)$.

Since $G(y)$ converges to $g(y)$, for any constant $\epsilon_G&gt;0$ there exists some $N_G&gt;0$ such that for any $y$ and all $i&gt;N_G$, 
$$-\epsilon_G &lt; G_i(y)-g(y) &lt; \epsilon_G.$$

If $g(\cdot)$ is differentiable around $f(x)$, there exists constant $\epsilon_f&gt;0$ such that $g(y)$ slopes toward $g(f(x))$ for all $y \in \left(f(x)-\epsilon_f, f(x)+\delta_g\right)$. Because $F$ converges to $f(x)$, there exists some $N_F&gt;0$ such that for all $i&gt;N_F$,
$$-\epsilon_f&lt; F_i(x) - f(x) &lt; \epsilon_f.$$

Since $g(\cdot)$ slopes toward $f(x)$ in the neighborhood containing all $F_i(x)$ for $i&gt;N_F$, as $F(x)$ approaches $f(x)$, $g(F(x))$ approaches $g(f(x))$; i.e., $g(F_i(x))$ converges to $g(f(x))$. That is, for any $\epsilon_g&gt;0$, there exists some $N_g&gt;N_F$ such that for all $i&gt;N_g$,
$$-\epsilon_g &lt; g(F_i(x)) - g(f(x)) &lt; \epsilon_g.$$

Now let $y=F_i(x)$. For any $\epsilon&gt;0$, set $\epsilon_G = \epsilon_g = \frac{\epsilon}{2}$. Then for all $i&gt;N$ (where $N=\max(N_G, N_F, N_g)$),
$$-\epsilon = -(\epsilon_G+\epsilon_g) &lt; G_i(F_i(x))-g(F_i(x)) + g(F_i(x)) - g(f(x)) &lt; (\epsilon_G+\epsilon_g) = \epsilon,$$
or,
$$-\epsilon &lt; G_i(F_i(x)) - g(f(x))) &lt; \epsilon.$$
That is, $G_i(F_i(x))$ converges to $g(f(x))$.



Is there a better idea?

Probably. Your algorithm generates $O(i)$ numbers to create the $i$th output number. 

Consider if the algorithms were finite (i.e., you stopped at the $n$th output). Then, you would run $F$ to $F_n(x)$, then run $G$ using this as your input. This would only take generating $O(n)$ numbers. Your problem is not finite, though. 

However, you can choose some constant $c$ and only restart $G$ after every $c$ steps. That is, the $i$th output will be $G_i(F_{c\lfloor i/c\rfloor}(x))$. This will make the convergence less smooth, but it will help your running time; it will now only generate $O(i/c)$ (amortized) numbers to create the $i$th output number.