Sun Jul 19 23:05:29 EDT 2015

Very interesting problem

Questions to answer:

- composition: easy: pick the arrow functions.

- what is a primitive?

composing two machines:

More abstractly: where do all these types come from?

Essentially, the compositions builds a p.  That p:
- takes a collection of primitives
- spits out the composition

so p is really:

[prim] -> composite

I keep running into the problem that you really can't hide those state
types anywhere!

There is a cycle reasoning in my mind I don't see.

Actually.  The types are visible.  They are just very complex:

The "generator" looks something like:

(  (s1,a) -> (s1, b) ,
   (s2,a) -> (s2, b, c) ,
   ... )


(sx,(a,b,c)) -> (sx, (d, e f))


sx = (s1,(s1,(s2, .... )))

So what the generator does is to convert a known type: a list of the
primitives of the language, into a re-tupled type, parameterized by
the type parameters in the list of primitives.

This requires two steps:

- selection of primitives
- recording of combination of these (selection, composition)

This gets quite complex, and it seems that hiding the composition
isn't all that useful.

So no,
1) I don't see it clearly.
2) if it is what I think it is I don't see the point of the complexity.

Unless 'p' is constant, it is useless.