Page Comparison

new insertArbitrary(`rho:registry:insertArbitrary`) in { … }
new insertSigned_ed25519(`rho:registry:insertSigned:ed25519`) in { … }
new lookup(`rho:registry:lookup`) in { … }

// insertArbitrary
//     Insert an unforgable name
//     Two parameters: name, returnUri
new insertArbitrary(`rho:registry:insertArbitrary`), stdout(`rho:io:stdout`) in {
    new x, return in {
        // Insert the name into the registry
        // Wrap in bundle+ so only write is possible for those who lookup
        insertArbitrary!(bundle+{*x}, *return) |

        // Receive the URI generated by the registry
        for (xUri <- return) {
            // Something like: `rho:id:rtu77e1cj1ky7dpqyoc6o8rcdseseax35qi7w37hbf3astmrcupusi`
            stdout!(*xUri)
        }
    }
}

// insertSigned 
//     Insert an unforgable name a signed term using ed25519 signature 
//     Four parameters:  Two parameters: namepublic-key, term, signature, returnUri 
new insertArbitraryinsertSigned_ed25519(`rho:registry:insertArbitrary`insertSigned:ed25519`), stdout(`rho:io:stdout`) in {
    new x, return in {
        // Insert the name into the registry Secret key:
        // d039d5c634ad95d968fc18368d81b97aaecd32fc7cf6eec07a97c5ac9f9fcb5b11afb9a5fa2b3e194b701987b3531a93dbdf790dac26f8a2502cfa5d529f6b4d
        // Public key:
        // Wrap11afb9a5fa2b3e194b701987b3531a93dbdf790dac26f8a2502cfa5d529f6b4d
in bundle+ so only write is possible for those// whoThe lookupsignatures here are over the serialized representation of  insertArbitrary!(bundle+{*x}, *return) |the nonce, value tuple.
         // To Receiverecreate the URI generated by signatures, you can do something like the registryfollowing:
        for// (xUrival <-key return) {
  = Base16.decode("<secret key goes here>")
         // Somethingval like: `rho:id:rtu77e1cj1ky7dpqyoc6o8rcdseseax35qi7w37hbf3astmrcupusi`toSign: Par = ETuple(Seq(GInt(789), GString("entry")))
        // val sig = stdout!(*xUriEd25519.sign(toSign.toByteArray, key)
        }insertSigned_ed25519!(
        } }  // insertSigned "11afb9a5fa2b3e194b701987b3531a93dbdf790dac26f8a2502cfa5d529f6b4d".hexToBytes(),
 //     Insert a signed term using ed25519 signature 
//(789, "entry"),
     Four parameters: public-key, term, signature, returnUri  new insertSigned_ed25519(`rho:registry:insertSigned:ed25519`"20c3b7da06565933400cb61301ffa14df82ef09b046c8152e02e8047d6f69ee2c2a2e4114db7ceb01eb828dfc98c15e40a502f9d85c58ca03734cab549e85e0d".hexToBytes(),
stdout(`rho:io:stdout`) in {     new return in {  *return) |
     // Secret key:         // d039d5c634ad95d968fc18368d81b97aaecd32fc7cf6eec07a97c5ac9f9fcb5b11afb9a5fa2b3e194b701987b3531a93dbdf790dac26f8a2502cfa5d529f6b4d
        // Public key:
  Receive the URI generated by the registry
      // 11afb9a5fa2b3e194b701987b3531a93dbdf790dac26f8a2502cfa5d529f6b4d for (entryUri <- return) {
   // The signatures here are over the serialized representation of the nonce, value tuple. stdout!(*entryUri)
        }
  // To recreate}
the}
signatures,
you// canlookup
do// something like the following: Look up an entry in the registry 
// val key = Base16.decode("<secret key goes here>")
        // val toSign: Par = ETuple(Seq(GInt(789), GString("entry")))
   Two parameters: uri, return 
new lookup(`rho:registry:lookup`),
    insertArbitrary(`rho:registry:insertArbitrary`),
    stdout(`rho:io:stdout`) in {

    // val sig = Ed25519.sign(toSign.toByteArray, key)
  Part 1, Run this code once and then comment it out
    // /*
insertSigned_ed25519!(    new x, insertReturn in {
    "11afb9a5fa2b3e194b701987b3531a93dbdf790dac26f8a2502cfa5d529f6b4d".hexToBytes(),    // Insert x into the registry
   (789, "entry"),     insertArbitrary!(bundle+{*x}, *insertReturn) |

    "20c3b7da06565933400cb61301ffa14df82ef09b046c8152e02e8047d6f69ee2c2a2e4114db7ceb01eb828dfc98c15e40a502f9d85c58ca03734cab549e85e0d".hexToBytes(),     // Receive the URI returned from the registry
*return) |        for (xUri <- insertReturn)   {
            // Write Receiveout the URI generated by the registry
            for// (entryUri <- return) {
A) REMEMBER THIS VALUE, use it below
            stdout!(*entryUrixUri)
        } |

   } }  // lookup // Set up a receive Lookon upx
an entry in the registry  //  for (v <= Two parameters: uri, return 
new lookup(`rho:registry:lookup`),x) {
       insertArbitrary(`rho:registry:insertArbitrary`),     stdout(`rho:io:stdout`) in {!("Received from x") |
             // Part 1, Run this code once and then comment it out
    // /*
    new x, insertReturn in {
   stdout!(*v)
        }
    }

    // End of Part 1, after running once, comment out to here
    // Insert*/
x
into the registry  // Part 2, Uncomment this code once  insertArbitrary!(bundle+{*x}, *insertReturn) |
you've run Part 1 first
    /*    
// Receive the URI returnednew fromlookupReturn thein registry{
        // forLookup (xUrix <-using insertReturn)its {URI from location (A) above
        // Write out the URI generated by the registry
  lookup!(`The Value from A`, *lookupReturn) |

        // (A)x REMEMBERis THIS VALUEreturned, usecalling it belowxLookup here
        for (xFromRegistry  stdout!(*xUri)
        } |<- lookupReturn) {
            // Set up a receive Send on xthe name retrieved     from the forregistry (v <=which is really x)
{             stdoutxFromRegistry!("Received from x") |
            stdout!(*vHello, I'm sending on x which I got from the registry.")
        }
    }
     // End of Part 1, after running once, comment out to here
    // */

    // Part 2, Uncomment this code once you've run Part 1 first
    /*    
    new lookupReturn in {
        // Lookup x using its URI from location (A) above
        // lookup!(`The Value from A`, *lookupReturn) |

    End of Part 2
    */
}

new x in {
    // xERROR: islogical returned,OR callingis itused xLookupin herethe pattern of the receive
    for(@{Nil  for (xFromRegistry\/ Nil} <- lookupReturnx) {
            // Send on the name retrieved from the registry (which is really x)
            xFromRegistry!("Hello, I'm sending on x which I got from the registry.")
        }
    }
    // End of Part 2
    */
}
 Nil }
} 

new x in {
    // ERROR: logical NOT is used in the pattern of the receive
    for(@{~Nil} <- x) { Nil }
} 

new x in {
    // OK: logical AND is allowed in the receive
    for(@{Nil /\ Nil} <- x) { Nil }
}