Fri Aug 26 10:10:50 CEST 2011
Next: make abstract interpretation work.
Given a SigOp, we need to observe:
- initial state
- representation of recurrence relation
So, for each domain there should be an unfold or eval function.
TODO: print int
data Expr = I String
| Add Expr Expr
instance Show Expr where
show (I v) = v
show (Add a b) = concat ["(",show a," + ",show b,")"]
instance Num Expr where
(+) = Add
(*) = undefined
abs = undefined
signum = undefined
fromInteger = I . show
*Main> cg (I "in") int
"(((in + 0),(in + 0)),0)"
*Main> cg (I "in") (int . int)
"(((((in + 0) + 0),(in + 0)),((in + 0) + 0)),(0,0))"
*Main> cg (I "in") (int . int . int)
"((((((in + 0) + 0) + 0),(((in + 0) + 0),(in + 0))),(((in + 0) + 0) + 0)),(0,(0,0)))"
This is almost correct, except that I don't have a way to name: this
isn't the generic update equation, this is an expression for the first
output from the initial state, "parameterized" over the input.
I.e. (cg int) works for:
cg (SigOp u s0) = show (u (s0, I "i"), s0)
but not for
cg (SigOp u s0) = show (u ("s", I "i"), s0)
We need some kind of test function that goes between the initial state
and what is actually fed into the function, or how that function is
unrolled or otherwise transformed for that matter..
This comes back to placing the unroll function in a type class.
Hmm.. Using some horrible hack I can do this:
cg (SigOp u s0) = show (u (sigOpInit s0, I "i"), s0)
instance SigOpInit Expr where
sigOpInit s = I "s"
-- Stream unfolding.
class Show s => (SigOpInit s) where
sigOpInit :: s -> s
sigOpInit x = x
-- Distribute over pairs, lists and void
instance (SigOpInit a, SigOpInit b) => SigOpInit(a,b) where
sigOpInit (a,b) = (sigOpInit a, sigOpInit b)
instance SigOpInit a => SigOpInit [a]
sigOpInit = map sigOpInit
instance SigOpInit ()
*Main> cg int
"(((i + s),(i + s)),0)"
Trouble with that of course is uniqueness, i.e. variable name
*Main> cg $ int . int
"(((((i + s) + s),(i + s)),((i + s) + s)),(0,0))"
Not simple.. Where to put all that functionality?
Start again. What's the main problem? The following seem not
1. Bundling initial state with processors.
2. Getting a representation of an opened-up function.
Instead of using some foefelare, is it possible to build that
intensional representation together with everything else? The trouble
seems to be that at some point the content of tuples needs to be
Yes. s needs to support some kind of labeling function that needs to
be threaded at composition time.