Don't do double checks about lisp-interpreter HOT 5 CLOSED

For example, (cond (zero? x) 5 (cond (zero? x) 1 2)) should be reduced to (cond (zero? x) 5 2).

from lisp-interpreter.

This should speed up the prelude implementation of mult a bit, for example.

from lisp-interpreter.

This should probably be done as two separate passes: 1 that detects duplicate function calls in expressions and wraps them in a closure and 1 that detects very simple patterns like cond $x (...) (... (cond $x ...) ...) and cond $x (... (cond $x ...) ...) (...).

The basic idea behind the first pass is that we only compute things once when we need them multiple times. For example, it should replace (add (add1 x) (add1 x)) by ((lambda y (add y y)) (add1 x)). We should be careful to do this at the right level to avoid unnecessary work. See the snippet below:

(cond z (mult 5 3) (add (add1 x) (add1 x)))

the lambda should replace the second branch of the condition and not the top level expression, since (add1 x) isn't used in the first branch. I believe the rule should be that the lambda replaces the expression closest to the root of which at least two descendents use the same expression. The order in which we do this operation doesn't matter too much (?) - think (add (add1 (add1 x)) (add1 (add1 x))). Extracting (add1 x) first and then (add1 y) later isn't as elegant and slightly less efficient, but the total work done should be similar.

from lisp-interpreter.

The rule on the extraction above isn't correct. Counter-example:

(add (cond x (add1 z) 1) (cond y (add1 z) 2))

Here, (add1 z) should not be extracted by the rule described above since it's not guaranteed to be used in both 'descendents' of add. The rule should state that it is always guaranteed to be used in at least two descendents, which is a lot more complicated to verify unfortunately...

from lisp-interpreter.

This has kind of been addressed in #51.

from lisp-interpreter.