(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