(G)
|dfps|
    halt: halt ==
  <B
  , tuple-type(map(
dfp.(df-program-statetype(dfp)?);dfps))
  , tuple(||dfps||;i.inl df-program-state(dfps[i]) )
  , let n := ||dfps|| in
    let nxt 

     tuple(n;i.let T,S,init,nxt = dfps[i]
               in 
a,x.case x of inl(z) => nxt z a | inr(z) => <x, {}>  )
    in 
s,a.
        if halt s
        then <inr 
 , {}>
        else let ps 

              ap2-tuple(n;nxt;a;s)
             in <inl evalall(map-tuple(n;
p.(fst(p));ps)) 
             , evalall(G map-tuple(n;
p.(snd(p));ps))
             >
        fi >
Definitions occuring in Statement : 
df-program-state: df-program-state(dfp), 
df-program-statetype: df-program-statetype(dfp), 
select: l[i], 
map: map(f;as), 
length: ||as||, 
ifthenelse: if b then t else f fi , 
it:
, 
spreadn: spread4, 
pi1: fst(t), 
pi2: snd(t), 
unit: Unit, 
apply: f a, 
lambda:
x.A[x], 
pair: <a, b>, 
decide: case b of inl(x) => s[x] | inr(y) => t[y], 
inr: inr x , 
inl: inl x , 
union: left + right, 
empty-bag: {}, 
map-tuple: map-tuple(len;f;t), 
ap2-tuple: ap2-tuple(len;f;x;t), 
tuple: tuple(n;i.F[i]), 
tuple-type: tuple-type(L), 
evalall: evalall(t), 
callbyvalueall: callbyvalueall, 
callbyvalue: callbyvalue
Definitions : 
tuple-type: tuple-type(L), 
map: map(f;as), 
union: left + right, 
df-program-statetype: df-program-statetype(dfp), 
unit: Unit, 
df-program-state: df-program-state(dfp), 
callbyvalue: callbyvalue, 
length: ||as||, 
tuple: tuple(n;i.F[i]), 
spreadn: spread4, 
select: l[i], 
decide: case b of inl(x) => s[x] | inr(y) => t[y], 
ifthenelse: if b then t else f fi , 
inr: inr x , 
it:
, 
empty-bag: {}, 
callbyvalueall: callbyvalueall, 
pair: <a, b>, 
inl: inl x , 
pi1: fst(t), 
evalall: evalall(t), 
apply: f a, 
map-tuple: map-tuple(len;f;t), 
lambda:
x.A[x], 
pi2: snd(t)
FDL editor aliases : 
parallel-df-prog
(G)
|dfps|
        halt:  halt  ==
    <B
    ,  tuple-type(map(\mlambda{}dfp.(df-program-statetype(dfp)?);dfps))
    ,  tuple(||dfps||;i.inl  df-program-state(dfps[i])  )
    ,  let  n  :=  ||dfps||  in
        let  nxt  \mleftarrow{}{}
          tuple(n;i.let  T,S,init,nxt  =  dfps[i]
                              in  \mlambda{}a,x.case  x  of  inl(z)  =>  nxt  z  a  |  inr(z)  =>  <x,  \{\}>    )
        in  \mlambda{}s,a.
                if  halt  s
                then  <inr  \mcdot{}  ,  \{\}>
                else  let  ps  \mleftarrow{}{}
                            ap2-tuple(n;nxt;a;s)
                          in  <inl  evalall(map-tuple(n;\mlambda{}p.(fst(p));ps))  ,  evalall(G  map-tuple(n;\mlambda{}p.(snd(p));ps))>
                fi  >
Date html generated:
2011_08_16-AM-09_36_58
Last ObjectModification:
2011_06_07-PM-12_15_05
Home
Index