Examples

A function to register a resource remotely:

serializable function registerAt (
   dest : location,
   t : serializable type,
   res : at dest resource t,
   value : t
) {
   if (dest == localhost) {
      spawn register res = value;
   } else {
      spawn at route dest registerAt (dest, t, res, value);
   }
}

An rpc function to remotely call a function and get the result:

serializable function rpc (
   dest : location,
   param : serializable type,
   result : serializable type,
   fun : at dest resource function (p : param) : result,
   arg : param
) : result {
   let origin : here = localhost;
   new r : at origin resource result;
   serializable function f () {
      if (dest == localhost) {
         registerAt (origin, result, r, fun (arg););
      } else {
         spawn at route dest f ();
      }
   }
   f ();
   return access r;
}

A traceroute function (assuming a type constructor for lists):

serializable function traceroute (
   dest : location
) : list location {
   let origin : here = localhost;
   new result : at origin resource list location;
   serializable function tr (route : list location) {
      if (dest == localhost) {
         registerAt (origin, list location, result, route);
      } else {
          spawn at route dest tr (localhost :: route);
      }
   }
   tr ([origin]);
   return access result;
}

A router which turns a remote function resource into a local function resource:

function router (
   dest : location,
   t : serializable type,
   port : at dest resource function (packet : t)
) : resource function (packet : t) {
   serializable function cell (in : resource function (packet : t)) {
      let next : neighbour = route dest;
      if (dest == next) {
         let out : at next resource function (packet : t) = port;
      } else {
         new out : at next resource function (packet : t);
         spawn at next cell (out);
      }
      register in (packet : t) {
         spawn at next access out (packet);
      }
   }
   new result : resource function (packet : t);
   spawn cell (result);
   return result;
}