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
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.
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.