Continuous control structures

Classical AI has a consistent problem with fragility and difficulty of learning, which I trace in large part to the use of discrete data spaces (in particular, boolean and small integer), which among other things prevent the application of hill-climbing algorithms. I'm interested in understanding how one programs using continuous data spaces and types.

Focus: Control structures
At the moment, I'm particularly interested in how one replaces conventional von Neuman control structures (if-then-else and while-do and such) with control structures more in the spirit of continuous domains -- energy minimization algorithms and such.

Straight if-then-else seems relatively straight-forward. For example, a mixing function controlled by a (0,1) parametrix mixing function can output a linear mix of two input data functions. Interation constructs seem less obvious.

I spent the evening rereading CommonLisp the Language 2nd Ed's section on Series. This provides in essence a classification of what interactive control structures are used for in practice. Three general categories are identified:

The first category includes such functions as the whole numbers in order, and all the elements of a list, tree, vector or similar aggregate datastructure in some (possibly somewhat arbitrary) order.

The second category includes functions which selectively drop or insert elements from series to produce new series, functions which merge multiple series to produce a single one, and functions which split a single series into multiple ones.

The third category includes functions which store a series in a list, vector, tree or other aggregate datastructure, and functions which compute some scalar summary or property of a series, such as max, min, sum, average or mean.

The Series appendix provides a set of functions in the above category which is claims satisfy >90% of all iteration needs, based on about 100,000 lines of programming experience by several people of the course of a year.

Whereas conventional Algolic von Neumann iteration constructs do not have immediately obvious continuous counterparts, I think that it is reasonably clear that all of the series functions have quite natural counterparts in the continuous domain:

I'm quite encouraged: From the control structure point of view, moving programming from the discrete to the continuous domain looks to be conceptually quite straightforward, at least on brief consideration.

Next problem: Recursion and parameters. :)