P,Q,R ::=0                                      //nil or stopped process
  | for ( ptrn1 <- x1; ... ; ptrnN <- xN ).P    //input guards
  | x!( Q )                                     //output
  | \*x\                                        //dereferenced or unquoted name
  | P|Q                                         //parallel composition
x,ptrn ::= @P                                   //name or quoted process 

new HelloWorld, stdout(`rho:io:stdout`) in {
    HelloWorld!("Hello, world!")|
    for (@text <- HelloWorld) {
        stdout!(text)
    }
}

//用for接收消息
new pizzaShop, stdout(`rho:io:stdout`) in {
    pizzaShop!("2 medium pies")|
    pizzaShop!("5 medium pies")|
    for (order <- pizzaShop) {
        stdout!("Order Received.")
    }
}

//用for持续接收消息
new pizzaShop, stdout(`rho:io:stdout`) in {
    for (order <= pizzaShop) {
        stdout!("Pizza Order Received")
    }|
    pizzaShop!("one hot chocolate")|
    pizzaShop!("two large latte's please")
}

//用contract持续接收消息
new coffeeShop, stdout(`rho:io:stdout`) in {
    contract coffeeShop(order) = {
        stdout!("Coffee Order Received")
    }|
    coffeeShop!("one hot chocolate")|
    coffeeShop!("two large cappuccinos please")
}

new a, stdout(`rho:io:stdout`) in {
    a!(1)|
    for (@b <- a) {
        for (@c <- @b) {
            stdout!([c, "index1"])
        }|
        stdout!([b,"index2"])
    }
}

for (p1Pushups <- player1; p2Pushups <- player2) {
    stdout!("The winner is...")
}

new aliceLaunch, bobLaunch, stdout(`rho:io:stdout`) in {
    for (x <- aliceLaunch) {
        for (y <- bobLaunch) {
            stdout!("Launching the rocket")
        }
    }|
    aliceLaunch!("launch")|
    bobLaunch!("launch")
}

new aliceLaunch, bobLaunch, stdout(`rho:io:stdout`) in {
    for (x <- aliceLaunch; y <- bobLaunch) {
        stdout!("Launching the rocket")
    }|
    aliceLaunch!("launch")|
    bobLaunch!("launch")
}

new p1, p2, stdout(`rho:io:stdout`) in {
    p1!("Send any message")|
    p2!("Hope I win")|
    for (m2 <- p2) {
        for (m1 <- p1) {
            stdout!("Player one wins!")
        }
    }|
    for (m1 <- p1) {
        for (m2 <- p2) {
            stdout!("Player two wins!")
        }
    }
}

new p1, p2, a, stdout(`rho:io:stdout`) in {
    p1!("Send any message")|
    p2!("Hope I win")|
    a!(1)|
    for (m2 <- p2; _ <-a) {
        for (m1 <- p1) {
            stdout!("Player one wins!")
        }
    }|
    for (m1 <- p1; _ <-a) {
        for (m2 <- p2) {
            stdout!("Player two wins!")
        }
    }
}

new philosopher1, philosopher2, north, south, knife, spoon in {
    north!(*knife)|
    south!(*spoon)|
    for (@knf <- north) {
        for (@spn <- south) {
            philosopher1!("Complete!")|
            north!(knf)|
            south!(spn)
        }
    }|
    for (@spn <- south) { 
        for (@knf <- north) {
            philosopher2!("Complete!")|
            north!(knf)|
            south!(spn)
        } 
    }
}

new philosopher1, philosopher2, north, south, knife, spoon in {
    north!(*knife)|
    south!(*spoon)|
    for (@knf <- north; @spn <- south) {
        philosopher1!("Complete!")|
        north!(knf)|
        south!(spn)
    }|
    for (@spn <- south; @knf <- north) {
        philosopher2!("Complete!")|
        north!(knf)|
        south!(spn)
    }
}

new a in {
    a!(1)|
    a!(2)|
    for(@x<-a){Nil}|
    if(P){Q}
    else{R}|
    contract a(b)={P}
}

new a, stdout (`rho:io:stdout`) in{
    a!(1)|
    a!(2)|
    a!(3)|
    a!(4)|
    a!(5)|
    for(@x<=a){
        stdout!(x)
    }
}

new a,b,stdout (`rho:io:stdout`) in{
    a!(1)|
    for(@x<-a){
        b!(x+1)|
        stdout!(x)
    }|
    for(@y<-b){
        stdout!(y)
    }
}

new alice, bob, stdout(`rho:io:stdout`) in {
    alice!("How to program: Change stuff and see what happens.")|
    for (message <- alice) {
        bob!(*message)
    }|
    for (message <- bob) {
        stdout!(*message)
    }
}

new a, b, stdout(`rho:io:stdout`) in {
    a!(*b)|
    b!(1)|
    for (@c <- a) {
        stdout!(c)
    }
}

//结果： Unforgeable(0x0ef84f0816679bafc4365da3e28d2ea9f674823f0dc7709dd3c74d2b8ac0a038)

for (@n <- m) {stdout!(n)}

contract example(@a, ack) = {
    stdout!(a)|
    ack!(Nil)
}

new get, initial, stdout(`rho:io:stdout`) in {
    initial!(0)|
    contract get(@"new", @arg, ack) = {
        for (@old <- initial) {   
            initial!(arg)|
            ack!(old)  
        }
    }|
    new ack in {
        get!("new", 1, *ack) |
        for (_ <- ack) {
            stdout!("The process had finished.")
        } 
    }   
}

new stdout(`rho:io:stdout`) in {
    for (a <- @{8+2}) {
        stdout!(*a)
    }|
    @{5+5}!("Hello")
}

Evaluating:
new x0 in {
  @{(5 + 5)}!("Hello") |
  for( @{x1} <- @{(8 + 2)} ) {
    x0!(x1)
  }
}
"Hello"

new pizzaShop, stdout(`rho:io:stdout`) in {
    contract pizzaShop(order) = {
        stdout!("Order Received.")
    }
}|
pizzaShop!("Extra bacon please")|
pizzaShop!("Hawaiian Pizza to go")

new a {P}
for(a<-b){P}
contract b(a)={P}

new pizzaShop, stdout(`rho:io:stdout`) in {
    contract pizzaShop(order) = {
        stdout!("Order Received.")
    }|
    pizzaShop!("Extra bacon please")|
    pizzaShop!("Hawaiian Pizza to go")
}

// 运行结果
// "Order Received."
// "Order Received."

new b in {Q|for (a <- b) {P}}
new b in {Q|contract b(a) = {P}}

new a,stdout(`rho:io:stdout`) in {
    a!(Nil)|
    a!(Nil)|
    for (x <- a) {P}|
    contract a(y) = {Q}
}

new a,stdout(`rho:io:stdout`) in{
    stdout!(*a)|
    new a in{
        stdout!(*a)
    }
}|
new a,stdout(`rho:io:stdout`) in{
    stdout!(*a)
}

// 运行结果
// Unforgeable(0x729d3a68aaf4b4b4985b168f95626d2842cc4e3a972e265bc2538fbf1c83db58)
// Unforgeable(0x46404982fa2da2ba74ac7b6816eca1af46a8ab5880bfdf73cacf4f794262a775)
// Unforgeable(0x5ab9526e8bcc709e85e914ba96ad09a7e90e92258b9ca087f4ca754eb0341df4)

new a,stdout(`rho:io:stdout`) in{
    stdout!(*a)|
    a!(100)|
    for(x<-a){
        stdout!(*x)
    }
}

// 运行结果
// Unforgeable(0x6f2df38e2d7fa3cc4f7f40cbede8834a069ac6d52a4b8f9825fd5ed5fa043ce6)
// 100

new a, b in {
    b!(*a)|
    for (x <- b) {
        x!(P)
    }|
    for (y <- a) {Q}
}

new a in {
    a!(P)|
    for (x <- a) {Q}
}

new alice, bob, stdout(`rho:io:stdout`) in {
    alice!(*bob)|
    bob!("Bob,You are the best. From Charlie")|
    stdout!(["un1 ", *bob])|
    for (bobCh <- alice) {
        for (@letter <- bobCh){
            stdout!(letter)
        }|
        stdout!(["un2",*bobCh])
    }
}

new alice, bob, stdout(`rho:io:stdout`) in {
    alice!(*bob)|
    stdout!(["un1",*bob])|
    for (@letter <- bob){
        stdout!(letter)
    }|
    for (bobCh <- alice) {
        bobCh!("Bob,You are the best. From Charlie")|
        stdout!(["un2",*bobCh])
    }
}

new oldHen, round, counter, stdout(`rho:io:stdout`) in {
    contract oldHen ( ack ) = {
        round!(1)|
        for (@round_ <= round) {
            counter!(1)|
            if (round_ < 4) {
                for (@counter_ <= counter){
                    if(counter_ < 4 ){
                        counter!( counter_ + 1 )|
                        stdout!(["counter",counter_ ])                    
                    }    
                    else {
                        round!( round_ + 1)|
                        stdout!(["round", round_ ])                
                    }
                }
            }
        }
    }|
    oldHen!(1)
}

new oldHen, round, stdout(`rho:io:stdout`) in {
    contract oldHen ( ack ) = {
        round!(1)|
        for (@round_ <= round) {
            if (round_ < 4) {
                new counter in{
                    counter!(1)|
                    for (@counter_ <= counter){
                        if(counter_ < 4 ){
                            counter!( counter_ + 1 )|
                            stdout!(["counter",counter_])                    
                        }    
                        else {
                            round!( round_ + 1)|
                            stdout!(["round", round_])                
                        }
                    }
                } 
            }
        }
    }|
    oldHen!(1)
}

// Separation of Powers
// line4、line5被触发时，method1 与 method2 会被分别传入unforgeable name
contract factory(method1, method2) = {
    contract method1(ack) = { ... }
    |
    contract method2(ack) = { ... }
}

// Control Panel
// 只有factory拥有unforgeable name
contract factory(cPanel) = {
    contract @[cPanel, "method1"](ack) = { ... }
    |
    contract @[cPanel, "method2"](ack) = { ... }
}

new currentCount, increase, reset, stdout(`rho:io:stdout`) in {

    currentCount!(0)|

    contract increase(ack) = {
        for (old <- currentCount) {
            currentCount!(*old + 1)|
            ack!(*old)
        }
    }|

    contract reset(ack) = {
        for (old <- currentCount) {
            currentCount!(0)|
            ack!(*old)
        }
    }|

    new ack in {
        increase!(*ack)|
        for (_ <- ack) {
            increase!(*ack)|
            for (_ <- ack) {
                increase!(*ack)|
                for (_ <- ack) {
                    increase!(*ack)|
                    for (_ <- ack; count <- currentCount) {
                        stdout!(*count)
                    }
                } 
            }
        }
    }
}

new counterFactory, stdout(`rho:io:stdout`) in {

    contract counterFactory(increase, reset) = {
        new currentCount in {
            currentCount!(0)|

            contract increase(ack) = {
                for (old <- currentCount) {
                    currentCount!(*old + 1)|
                    ack!(*old)|
                    stdout!(*old)
                }
            }|

            contract reset(ack) = {
                for(old <- currentCount){
                currentCount!(0)|
                ack!(*old)
                }
            }
        }
    }|

    new ack, AliceIncrease, AliceReset in {
        counterFactory!(*AliceIncrease,*AliceReset)|
        AliceIncrease!(*ack)|
        // AliceIncrease!(*ack)|
        // AliceIncrease!(*ack)|
        AliceIncrease!(*ack)
    }|

    new ack, BobIncrease, BobReset in {
        counterFactory!(*BobIncrease,*BobReset)|
        BobIncrease!(*ack)|
        // BobIncrease!(*ack)|
        // BobIncrease!(*ack)|
        BobIncrease!(*ack)
    }
}

new factory in {

    contract factory(method1, method2) = {
        contract method1(ack) = {
            Nil
        }|
        contract method2(ack) = {
            Nil
        }
    }|

    new a, b in {
        factory!(*a, *b)|
        a!(1)|
        b!("Hello")
    }
}

new factory in {
    contract factory(x, y) = {
        new method1, method2 in {
            x!(*method1)|
            y!(*method2)|
            contract method1(ack) = {
            Nil
            }|
            contract method2(ack) = {
            Nil
            }
        }        
    }|
    new a, b in {
        factory!(*a, *b)|
        for (ack1 <- a) {
            ack1!(1)
        }|
        for (ack2 <- b) {
            ack2!("Hello")
        }
    }
}

new stationFactory, stdout(`rho:io:stdout`) in {
    contract stationFactory(initialMessage, getInfo, setInfo) = {
        new currentMessage in {
            currentMessage!(*initialMessage)|
            contract setInfo(newMessage) = {
                for (msg <- currentMessage) {
                    currentMessage!(*newMessage)
                }
            }|
            contract getInfo(return) = {
                for (msg <- currentMessage) {
                    return!(*msg)|
                    currentMessage!(*msg)
                }
            }
        }
    }|
    new airportInfo, set in {
        stationFactory!("Weather is nice", *airportInfo, *set)|
        set!("Strong crosswinds, be advised")|
        airportInfo!(*stdout)
    }   
}

new openAccount, stdout(`rho:io:stdout`) in {
    // This contract registers a new account and creates its methods.
    contract openAccount(initialDeposit, deposit, withdraw, check) = {
        new balanceCh in {
            balanceCh!(*initialDeposit)|
            // Deposit Contract
            contract deposit(amount, ack1) = {
                for (old <- balanceCh) {
                    balanceCh!(*old + *amount)|
                    ack1!(Nil)
                }
            }|
            // Withdraw Contract
            contract withdraw(amount, ack2) = {
                for (old <- balanceCh) {
                    balanceCh!(*old - *amount)|
                    ack2!(Nil)
                }
            }|
            // Check contract
            contract check(ack3) = {
                for (balance <- balanceCh) {
                    ack3!(*balance)
                }
            }
        }
    }|
    // Customer Sarah creates an uses an account
    new sarahDeposit, sarahWithdraw, sarahCheck, sarahack in {
        openAccount!(10, *sarahDeposit, *sarahWithdraw, *sarahCheck)|
        sarahWithdraw!(3, *sarahack)|
        for (_ <- sarahack) {
            sarahCheck!(*stdout)
        }
    }
}

 stephanie!(*sarahDeposit)

new pizzaShop, stdout(`rho:io:stdout`) in {
    contract pizzaShop(order, ack) = {
        ack!("Order Received.")
    }|
    new alice in {
        pizzaShop!("One medium veggie pizza", *alice)|
        for (@info<-alice) {
            stdout!(info)
        }
    }
}

new chan, ack, stdoutAck(`rho:io:stdoutAck`) in {
    chan!(0)|
    for (_ <- ack) {
        chan!(1)
    }|
    for (@num <= chan) {
        stdoutAck!(num, *ack)
    }
}

new rocketFactory, stdout(`rho:io:stdout`) in {

    contract rocketFactory(aliceLaunch, bobLaunch, ackCh) = {
        new aliceReadyCh, bobReadyCh in {

            contract aliceLaunch(ackAlice) = {
                aliceReadyCh!(true)|
                new aliceAbort in {
                    contract aliceAbort(_) = {
                        for (_ <- aliceReadyCh) {
                                stdout!("Abort")
                        }
                    }|
                    ackAlice!(*aliceAbort)
                }
            }|

            contract bobLaunch(ackBob) = {
                bobReadyCh!(true)|
                new bobAbort in {
                    contract bobAbort(_) = {
                        for (_ <- bobReadyCh) {
                            stdout!("Abort")
                        }
                    }|
                    ackBob!(*bobAbort)
                }
            }|

            for (a <- aliceReadyCh; b <- bobReadyCh) {
                stdout!("Launch!")|
                ackCh!("Launch!")    
            }
        }
    }|
    // 发射
    new aliceLaunch, bobLaunch, ackCh, ackAlice, ackBob in {
        rocketFactory!(*aliceLaunch, *bobLaunch, *ackCh)|
        aliceLaunch!(*ackAlice)|
        bobLaunch!(*ackBob)
    }|
    // Alice取消发射
    new aliceLaunch, bobLaunch, ackCh, ackAlice, ackBob in {
        rocketFactory!(*aliceLaunch, *bobLaunch, *ackCh)|
        aliceLaunch!(*ackAlice)|
        for (x <- ackAlice) {
            x!(Nil)
        }
    }
}

new MakeRevokableForwarder in {
    contract MakeRevokableForwarder(target, ret) = {
        new port, kill, forwardFlag in {
            ret!(*port, *kill)|
            forwardFlag!(true)|
            contract port(msg) = {
                for (@status <- forwardFlag) {
                    forwardFlag!(status)|
                    match status { true => target!(*msg) }
                }
            }|
            for (_ <- kill; _ <- forwardFlag) {
                forwardFlag!(false)
            }
        }
    }|
    new target, ret in {
        MakeRevokableForwarder!(*target,*ret)|
        for (port, kill<- ret) {
            port!(111)
        // |kill!(000)
        }
    }
}

new MakeCoatCheck in {
    contract MakeCoatCheck(ret) = {
        new port, table in {
            ret!(*port)|
            for (@"new", @arg, ack <= port) {  // 传出通道的使用：port的Unforgeable Name被传出到了ret，#28中又把它取出，之后向cc发送Process即触发相应的合约（#5/11/17）
                new ticket in {   // 定义一个ticket，代表存衣凭证。它的Unforgeable Name被传出到ack中
                    ack!(*ticket)|
                    @{*ticket | *table}!(arg)
                }
            }|
            for (@"get", @arg, ack <= port) {   // 查看功能。@"get"用于匹配，@arg代表凭证，ack是返回通道
                for (@value <- @{arg | *table}) {
                    @{arg | *table}!(value)|
                    ack!(value)
                }
            }|
            for (@"set", @arg1, @arg2, ack <= port) {   // 更换存衣功能。@"set"用于匹配，arg1代表凭证，arg2代表新的衣服，ack是返回通道
                for (_ <- @{arg1 | *table}) {
                    @{arg1 | *table}!(arg2)|
                    ack!(true)
                }
            }
        }
    }|
    // Usage
    new ret, get, set in {
        MakeCoatCheck!(*ret)|  // 传入通道的使用：ret的Unforgeable Name被传入#2，两个ret等价
        for (cc <- ret) {
            // Creates new cell with initial value 0
            cc!("new", 0, *ret)|
            for (ticket <- ret) {
                contract get(return) = { 
                    cc!("get", *ticket, *return) 
                }|
                contract set(@value, return) = { 
                    cc!("set", *ticket, value, *return) 
                }|        
                get!(*ret)|
                for (@r <- ret) {
                    //r is equal to 0
                    set!(1, *ret)|
                    for (_ <- ret) {
                        get!(*ret)|
                        for (@r <- ret) {
                            //r is equal to 1
                            Nil
                        }
                    }
                }
            }
        }
    }
}

new string, stdout(`rho:io:stdout`) in{
    contract string (@word) = {
        stdout!("Hello" ++ word)
    }|
    string!("World")
}

new tCh, stdout (`rho:io:stdout`) in {
    tCh!!((3, 4, 5))|
    for (@t <- tCh){
        stdout!(["Test nth. Expected: 5. Got ", t.nth(2)])
    }|
    for(@t <-  tCh){
        stdout!(["toByteArray test.Got：",t.toByteArray()])
  }
}

new a,stdout (`rho:io:stdout`) in{
    contract a (x,y,z) ={
        stdout!("HelloWorld")
    }|
    a!(1,2,3)|
    a!(1)
}

new alice, bob, key1, key2, stdout(`rho:io:stdout`) in {

    alice!(*key1)|
    bob!(*key2)|

    contract @(*key1, *key2)(_) = {
        stdout!("Congratulations, Alice and Bob, you've cooperated.")
    }|
    for(@a<-alice;@b<-bob){
        @(a,b)!(1)
    }
}

Tuple ! ((1,2,Nil,"Hi"))|for(@t<-Tuple){P}

new lCh, stdout(`rho:io:stdout`) in {

    lCh!!([3, 4, 5])|

    for (@l <- lCh){
        stdout!({l.nth(2)})
    }|
    for (@l <- lCh){
        stdout!(["Test slice. Expected: [4, 5]. Got: ", l.slice(1, 3)])
    }|

    for (@l <- lCh){
        stdout!({l.length()})
    }
}

List ! ([1,2,Nil,"Hi"])|for(@l<-List){P}

new sCh, stdout(`rho:io:stdout`) in {
    sCh!!(Set(3, 4, 5))|
    // 在Set里面加一个process
    for (@s <- sCh){
        stdout!(["Test add. Expected Set(3, 4, 5, 6), Got: ", s.add(6)])
    }|
    // 删除Set里面的一个process
    for (@s <- sCh){
        stdout!(["Test delete. Expected: Set(3, 4). Got: ", s.delete(5)])
    }|
    for (@s <- sCh){
        stdout!(["Test contains. Expected: true. Got:", s.contains(5)])|
        stdout!(["Test contains. Expected: false. Got: ", s.contains(6)])
    }|
    for (@s <- sCh){
        stdout!(["Test union. Expected: Set(1, 2, 3, 4, 5). Got: ", s.union(Set(1, 2))])
    }|
    for (@s <- sCh){
        stdout!(["Test diff. Expected: Set(5) Got: ", s.diff(Set(3, 4))])
    }|
    for (@s <- sCh){
        stdout!(["Test toByteArray. Got: ", s.toByteArray()])
    }      
}

Sets! (Set(1,2,Nil,"Hi"))|for(@s<-Sets){P}

new mCh, print(`rho:io:stdout`) in {
    mCh!!({"a": 3, "b": 4, "c": 5})|
    // .union 用来将两个map联合起来
    for (@m <- mCh){
        print!(["Test union. Expected: {a: 3, b: 4, c: 5, d: 6}. Got: ", m.union({"d": 6})])
    }|
    // .diff用来调出map中除了.diff()里面的东西。
    for (@m <- mCh){
        print!(["Test diff. Expected: {b: 4, c: 5}. Got: ", m.diff({"a": 3})])
    }|
    for (@m <- mCh){
        print!(["Test toByteArray. Got: ", m.toByteArray()])
    }|
    for (@m <- mCh){
        print!(["Test delete. Expected: {a: 3, b: 4}. Got: ", m.delete("c")])
    }|
    for (@m <- mCh){
        print!(["Test contains. Expected: true. Got: ", m.contains("c")])|
        print!(["Test contains. Expected: false. Got: ", m.contains("d")])
    }|
    for (@m <- mCh){
        print!(["Test get. Expected: 4. Got: ", m.get("b")])
    }|
    for (@m <- mCh){ 
        //getOrElse的第二个参数是Default Value
        print!(["getOrElseSuccessful. Expected: 4. Got: ", m.getOrElse("b", "?")])|
        print!(["getOrElseFailed. Expected: ?. Got: ", m.getOrElse("d", "?")])
    }|
    for (@m <- mCh){
        print!(["Test set. Expected {a: 3, b: 2, c: 5}. Got: ", m.set("b", 2)])
    }|
    for (@m <- mCh){
        print!(["Test keys. Expected Set(a, b, c)). Got: ", m.keys()])
    }|
    for (@m <- mCh){
        print!(["Test size. Expected 3. Got: ", m.size()])
  }
}

Map ! ({"a":1,"b":2})|for(@m<-Map){P}

new stdout(`rho:io:stdout`),sCh,lCh, mCh in {
    stdout!(["String","a".toByteArray()])|
    stdout!(["Int",16.toByteArray()])|
    stdout!(["list",["abc", 100].toByteArray()])|
    stdout!(["Set",Set("Hello",1).toByteArray()])|
    stdout!(["Map",{"b":99,"bb":999,}.toByteArray()])
}

//运行结果：
//["Int", 2a021020]
//["list", 2a13a201100a072a051a036162630a052a0310c801]
//["Map", 2a24ba01210a0e0a052a031a016212052a0310c6010a0f0a062a041a02626212052a0310ce0f]
//["Set", 2a14b201110a042a0210020a092a071a0548656c6c6f]
//["String", 2a031a0161]

new stdout(`rho:io:stdout`), hashValueCh in {
    @"keccak256Hash"!("1111F8dwxuPdE95j4XVqusbo2dDvkiwgi7JCodF7UQXVFDoWGTrA9".toByteArray(), *hashValueCh)|
    for(@hashValue<-hashValueCh){
    	stdout!(hashValue)
    }
}
// 运行结果：7b892e7366cd0f57e846bba7d1f70d6a62acff466e57834b9f70bc08182834e4

new stdout(`rho:io:stdout`), hashValueCh in {
    @"sha256Hash"!("1111F8dwxuPdE95j4XVqusbo2dDvkiwgi7JCodF7UQXVFDoWGTrA9".toByteArray(), *hashValueCh)|
    for(@hashValue<-hashValueCh){
    	stdout!(hashValue)
    }
}
// 运行结果：ae3d1d0f4cb47251155e707270aa4958dde64278e2cc353937f222fd7345fb80

new stdout(`rho:io:stdout`), hashValueCh in {
    @"sha256Hash"!("1111F8dwxuPdE95j4XVqusbo2dDvkiwgi7JCodF7UQXVFDoWGTrA9".toByteArray(), *hashValueCh)|
    for(@hashValue<-hashValueCh){
    	stdout!(hashValue)
    }
}
// 运行结果：2f7a32d03369be70d0d1b8f5f42cbb3e241c037fd5b147a9e6f65bca37660ace

for (@x <- <channel>) {
    match x{
        pattern1 =>{P}
        pattern2 =>{Q}
    }
}

match P{
  X =>{...}
  _ =>{...}
}

new patternMatcher, stdout(`rho:io:stdout`) in {
    for (x <= patternMatcher) {
        match *x {
            Nil     => stdout!("Got the stopped process")
            "hello" => stdout!("Got the string hello")
            [x, y]  => stdout!("Got a two-element list")
            Int     => stdout!("Got an integer")
            _       => stdout!("Got something else")
        }
    }|
    patternMatcher!({for(@0 <- @0){0}})|
    patternMatcher!({@"world"!("hello")})|
    patternMatcher!({Nil|"hello"})|
    patternMatcher!({0|"hello"})|
    patternMatcher!(Nil)
}

new patternMatcher, stdout(`rho:io:stdout`) in {
    for (x <= patternMatcher) {
        match *x {
            Nil               => stdout!("Got the stopped process")
            {_!(_)}           => stdout!("Got a send")
            {for(@0 <- _){_}} => stdout!("Got a receive on @0")
            _                 => stdout!("Got something else")
        }
    }|
    patternMatcher!({for(@0 <- @0){0}}) |
    patternMatcher!({@"world"!("hello")}) |
    patternMatcher!({0|"hello"}) |
    patternMatcher!(Nil)
}

new chan, stdout(`rho:io:stdout`) in {
    chan!(1,2,3) |
    for (@x, @y, @z <= chan) {
        stdout!(["three", x, y, z])
    } |

    chan!(7,8) |
    chan!([9, 10], 11) |
    for (@a, @b <= chan) {
        stdout!(["two", a, b])
    } |

    chan!((4,5,6)) |
    chan!(12 | 13) |
    for (@a <= chan) {
        stdout!(["one", a])
    } 
}

for (name pattern <- channel) { process }

new chan,stdout(`rho:io:stdout`)in{
    for (_ <- chan) {stdout!("Hello")}|
    chan!(1|2)|

    for (x <- chan) {stdout!("World")}|
    chan!(1|2|3)|

    for (@{y|x} <- chan) {stdout!("Hi")}|
    chan!(333)|

    for (@{y|_} <- chan) {stdout!("Hi～")}|
    chan!(22|44|66)|

    for (@x,@y <- chan) { stdout!(x)}|
    chan!(5,10)|

    for (@x,_ <- chan) { stdout!(x)}|
    chan!(5,10)|

    for (@{x!(Q)} <- @"chan") { stdout!(Q)}|
    @"chan"!({@"a"!(999)})|

    for (@{for (@P <- z) { R }} <- @"chan"){stdout!(R)}|
    @"chan"!(for (x <- @"a") {666})

}

new chan,stdout(`rho:io:stdout`)in{

    for (@{y|Nil} <- chan) {stdout!(y)}|
    chan!(Nil|333)|

    for (@{for (@5 <- x) {Nil}} <- chan) { stdout!("Hi")}|
    chan!(for (@5 <- chan) {Nil})|

    for(@{x!("Hello")} <- chan){ stdout!("World")}|
    chan!({@"a"!("Hello")})

}

new chan,stdout(`rho:io:stdout`) in{

    contract @(*chan,"method1")(@ack)={stdout!(["method1",ack])}|
    @(*chan,"method1")!(1)|

    contract @[*chan,"method2"](@ack)={stdout!(["method2",ack])}|
    @[*chan,"method2"]!(2)|

    contract chan(@"method3",@ack)={stdout!(["method3",ack])}|
    chan!("method3",3)|

    contract @(*chan,"method4")(@"method4",@ack)={stdout!(["method4",ack])}|
    @(*chan,"method4")!("method4",4)

}

contract channel pattern (name pattern) ={ Process }

new log(`rho:io:stdout`), missile in {
    
    contract @(*missile, "launch")(_) = {
        log!("launching...")
    }|

    contract @(*missile, "inspect")(_) = {
        log!("inspecting...")
    }|

    contract @"getInspectionChannel"(return) = {
        return!((*missile, "inspect"))
    }
    
}
//请补充调用合约，分别实现launch功能，和inspect功能
//|{...}

new log(`rho:io:stdout`), missile in {
    contract @(*missile, "launch")(_) = {
        log!("launching...")
    }|

    contract @(*missile, "inspect")(_) = {
        log!("inspecting...")
    }|

    contract @"getInspectionChannel"(return) = {
        return!((*missile, "inspect"))
    }
}
|
new ack in {
    @"getInspectionChannel"!(*ack)|
    for(@(missile, "inspect") <- ack){
        @(missile, "launch")!(Nil)
    }
}

new getInspectionChannel, log(`rho:io:stdout`), missile in {

  contract @(*missile, "launch")(_) = {
    log!("launching...")
  }
  |
  contract @(*missile, "inspect")(_) = {
    log!("inspecting...")
  }
  |
  contract getInspectionChannel(return) = {
    return!(bundle+{(*missile, "inspect")})
  }
}

new stdout(`rho:io:stdout`) in {
    for (@balance <= @"signTest") {
        if (balance > 0) {
            stdout!("Account in good standing.")
        } 
        else {
            stdout!("Account overdrawn.")
        }
    }
}
|
@"signTest"!(5)

if (cond) {P}
else {Q}

match cond {
  true => P
  false => Q
}

match x {
  cond => P
  _ => Q
}

new agech,stdout(`rho:io:stdout`) in{
    agech!(10)|
    agech!(18)|
    agech!(20)|
    for(@age<=agech){
        match {age>=18} {
            true =>{stdout!("permission")}
            _    =>{stdout!("rejection")}
        }
    }
}

new log(`rho:io:stdout`), binderChecker in {
    contract binderChecker(@data, return) = {
        match data {
            "nombre" \/ "name" => return!("name-like")
            _ => return!("not name-like")
        }
    }|
    binderChecker!("name", *log)|
    binderChecker!("nombre", *log)
}

new StudentGradeLevel, stdout(`rho:io:stdout`) in {
    for(@{{@"grade"!(x)}/\{@y!(10)}} <- StudentGradeLevel){stdout!("a")}|
    StudentGradeLevel!(@"grade"!(10))
}

for (name pattern <- channel) { Process }

new print(`rho:io:stdout`), register in {

    for (@{{@"name"!(_) | _} /\ {@"age"!(_) | _}} <= register){
        print!("Both name and age were in the data")
    }|
    register!(@"name"!(Nil))|
    register!(@"age"!(Nil))|
    register!(@"name"!(Nil) | @"age"!(Nil))|
    register!(@"name"!(Nil) | @"age"!(Nil) | @"height"!(175))
    
}

new StudentGradeLevel, x, stdout(`rho:io:stdout`) in{
    contract StudentGradeLevel (@{{@"grade"!(x)}/\{@y!(10)}}) ={stdout!("a")}|
    StudentGradeLevel!(@"grade"!(10))
}

contract channel  (name pattern) ={ Process }

new ack, stdout(`rho:io:stdout`) in {
    for (@Int <-ack){
        stdout!(Int)
    }|
    ack!(1)
}
//结果为Nil

new ack, stdout(`rho:io:stdout`) in {
    for (@{x /\ Int} <- ack) {
        stdout!(x)
    }|
    ack!(1)
}
//结果是1

new chan, uriChan,insertArbitrary(`rho:registry:insertArbitrary`),stdout(`rho:io:stdout`) in{
    insertArbitrary!(bundle+{*chan}, *uriChan)|
    for(@{Uri}<-uriChan){
            stdout!("success")
    }  
}

new chan,stdout(`rho:io:stdout`) in{
    chan!(`rho:id:x93d1g1oaj83pn3rgntehae7b3cnxzpktwojrijbg9uk7z8b3hkbw5`)|
    for(@{Uri}<-chan){
        stdout!("success")
    }
}

new chan, pm, stdout(`rho:io:stdout`) in{
    chan!(123)|
    for(@chan_<-chan){
        pm!(chan_.toByteArray())|
        for(@{ByteArray}<-pm){
            stdout!("success")
        }
    }  
}

new age, stdout(`rho:io:stdout`) in {
    for(@{x+5}<- age ){ 
        stdout!(x)
    }|
    age!({10+5})
} 

new age, stdout(`rho:io:stdout`) in {
    for(@{x>5}<- age ){ 
        stdout!(x)
    }|
    age!({10>5})
} 

new age, stdout(`rho:io:stdout`) in {
    for(@x<- age ){ 
        match x{
            x>5 => stdout!("123")
        }
    }|
    age!(10)
} 

new age, stdout(`rho:io:stdout`) in {
    for (@x <- age) { 
        match x/\10 {
            true => stdout!(x)
        }
    }|
    age!(10)
}

new helloNameAge, getOlder, stdout(`rho:io:stdout`) in {
    contract helloNameAge(@{@"name"!(name) | @"age"!(age) | _}) = {
        stdout!(["Hello, ", name, " aged ", age])
    } |
    contract getOlder(@{rest /\ {@"name"!(_) | _} | @"age"!(age) }, ret) = {
        ret!(@"age"!(age + 1) | rest)
    } |
    getOlder!(@"name"!("Joe") | @"age"!(39), *helloNameAge)
}

new people, stdout(`rho:io:stdout`) in {
    people!(@"name"!("Joe") | @"age"!(20) | @"eyes"!("blue") | @"seq"!(0)) |
    people!(@"name"!("Julie") | @"age"!(30) | @"eyes"!("brown") | @"seq"!(0)) |
    people!(@"name"!("Jane") | @"age"!(40) | @"eyes"!("green") | @"seq"!(0)) |
    people!(@"name"!("Jack") | @"age"!(50) | @"eyes"!("grey") | @"seq"!(0))|
    for (@{@"seq"!(0) | {row /\ {@"name"!(name) | @"age"!(age) | _}}} <= people) {
        if (age > 35) {
            stdout!([name, age])
        }|
        people!(row | @"seq"!(1))
    }
}

new myIncrease, stdout(`rho:io:stdout`) in { 
    new current in {
        current!(0)|
        contract myIncrease(ack) = {
            for (@old <- current) {
                current!(old + 1)|
                ack!(old)
            }
        }
    }|
    new ack in {
        myIncrease!(*ack)|
        contract ack(@a) = {
            if (a <= 5) {
                myIncrease!(*ack)|
                stdout!(a)
            }
        } 
    }
}

new sum, add, stdout(`rho:io:stdout`) in {
    contract sum(@arr, ret) = {
        match arr {
            [h, ...t] => {
                new ack in {
                    sum!(t, *ack)|
                    for (@arg <- ack) {
                        add!(h, arg, *ret)
                    }    
                }
            }            
            _ => ret!(0)
        } 
    }|
    contract add(@a, @arg, ret) = {
        ret!(a + arg)
    }|
    sum!([4,5,6], *stdout) 
}

new alice, stdout(`rho:io:stdout`) in {
    new aliceFanMail in {
        alice!!(bundle+ {*aliceFanMail})|
        for (mail <= aliceFanMail) {
            stdout!("Alice received a fanmail")
        }
    }|
    for (aliceFanMail <- alice) {
        aliceFanMail!("Dear Alice, you're #TheBest")
    }|
    for (aliceFanMail <- alice) {
        for (@stolenMail <= aliceFanMail) {
            stdout!(["Eve stole a message: ", stolenMail])
        }
    }
}

new gameCh, stdout(`rho:io:stdout`) in {
    new throw in {
        gameCh!!(bundle- {*throw})|
        throw!(4) |
        throw!(2) |
        throw!(6)
        }|
    for (throw <- gameCh) {
        for (points <= throw) {
            stdout!(["Bill caught it. Points: ", *points])
        }
    }|
    for (throw <- gameCh) {
        throw!(100)
    }
}

new gameCh, ack, stdout(`rho:io:stdout`) in {
    new ret in {
        contract gameCh(return) = {
            return!(bundle- {*ret})
        } |
        new throw in {
            throw!(1)|
            contract throw(@num) = {
                if (num <= 10){
                    throw!(num + 1)|
                    ret!(num) 
                }
            }
        }
    }|
    new initial in {
        new return in {
            gameCh!(*return)|
            initial!(0)|
            for (@throw <- return) {
                for (@points <= @throw; @ini <= initial) {
                    initial!(points + ini)|
                    stdout!(["P1 get the ball, the sum number is ", points + ini])          
                }           
            }
        } |
        new return in {
            gameCh!(*return)|
            initial!(0)|
            for (@throw <- return) {
                for (@points <= @throw; @ini <= initial) {
                    initial!(points + ini)|
                    stdout!(["P2 get the ball, the sum number is ", points + ini])          
                }           
            }
        } |
        new return in {
            gameCh!(*return)|
            initial!(0)|
            for (@throw <- return) {
                for (@points <= @throw; @ini <= initial) {
                    initial!(points + ini)|
                    stdout!(["P3 get the ball, the sum number is ", points + ini])      
                }           
            }
        } 
    }
}

new stdout(`rho:io:stdout`), stderr(`rho:io:stderr`) in{
    stdout!("Hello")|
    stderr!("World")
}

new ackout, ackerr,stdout(`rho:io:stdout`),stderr(`rho:io:stderr`), 
    stdoutAck(`rho:io:stdoutAck`), stderrAck(`rho:io:stderrAck`) in {
    stdoutAck!("hello", *ackout) |
    for (@ackout_ <- ackout) {
        stdout!([ackout_, "received"])
    }|

    stderrAck!("world", *ackerr) |
    for (@ackerr_ <- ackerr) {
        stderr!([ackerr_, "received"])
    }
}

new timestamp(`rho:block:timestamp`), stdout(`rho:io:stdout`), tCh in {
  timestamp!(*tCh) |
  for(@t <- tCh) {
    match t {
      Nil => { stdout!("no block time; no blocks yet? Not connected to Casper network?") }
      _ => { stdout!({"block time": t}) }
    }
  }
}

new alice, uriCh, stdout(`rho:io:stdout`), insertArbitrary(`rho:registry:insertArbitrary`) in {
    insertArbitrary!(*alice, *uriCh)|
    //insertArbitrary!(bundle+{*alice}, *uriCh)|
    //insertArbitrary!(bundle-{*alice}, *uriCh)|
    for(uri<-uriCh){
        stdout!(["alice",*uri])}
}
//运行结果：["alice", `rho:id:ohgpocjy48frt5cxtoqr8npp1zzy4odm3px67q9tw81ygc3ujm4kd1`]

new ack, lookup(`rho:registry:lookup`) in {
  lookup!(`rho:id:c8auch5r99u8ffcd3emzhoa9m99x7umrbf43y1jwc85faw8za9ajs9`, *ack)|
  for(uriUnforgeableName <- ack){
    uriUnforgeableName!(Nil)
  }
}

new ack, lookup(`rho:registry:lookup`), stdout(`rho:io:stdout`) in {
  lookup!(`rho:id:c8auch5r99u8ffcd3emzhoa9m99x7umrbf43y1jwc85faw8za9ajs9`, *ack)|
  for(uriUnforgeableName <- ack){
    for(@process<-uriUnforgeableName){
        stdout!(process)
    }
  }
}

new getDeployData(`rho:deploy:params`), ch, stdout(`rho:io:stdout`) in {
    getDeployData!(*ch)|
    for (_, _, @userId, _ <- ch) {
        stdout!(userId)
    }
}
//运行结果：048fb9524f276744aab7c765f2aa0b6e1fefdcaff0729b076459434c7f2fd9aa904b73cc711733780e5445c5748e013fdc99d97398ba14a9fa0dda85d3fb9690c9

new RevAddress(`rho:rev:address`),revAddressValid,stdout(`rho:io:stdout`) in {
    RevAddress!("validate", "1111F8dwxuPdE95j4XVqusbo2dDvkiwgi7JCodF7UQXVFDoWGTrA9", *revAddressValid)|
    for (@value <- revAddressValid) {
        stdout!({"validate result":value})
    }
}
//运行结果：{"validate result" : Nil}

new RevAddress(`rho:rev:address`),revAddrCh,stdout(`rho:io:stdout`) in {
    RevAddress!("fromPublicKey",
       "0401d0fd5accd56de6d69c1bd4f56d8460485b19908c789085bb3515eac432f7dabc86ea4d43a166a2c49a4eb5882b4e72b01dad32e493fbe5cfe2150779235758"
        .hexToBytes(), *revAddrCh) |
    for (@revAddress <- revAddrCh) {
        stdout!({"revAddress":revAddress})
    }
}
//运行结果：{"revAddress" : "1111F8dwxuPdE95j4XVqusbo2dDvkiwgi7JCodF7UQXVFDoWGTrA9"}