General mechanism for synchronous access

[michaelfig]

This makes unwrap(foo) useful when foo is not a Promise at all.

[michaelfig]

@katelynsills the code I'm thinking of is:

function sync(value) {
  if (!value || !value.then) {
   // Not a Thenable.  So, we can access it synchronously.
   return value;
  }
  // Try unwrapping the promise.
  return HandledPromise.unwrap(value);
}

function foo(resultP) {
  const result = sync(resultP);
  // result should be defined if resultP can be obtained synchronously
}

[katelynsills]

I like this a lot. I'm wondering about the sync name though, it sounds like synchronizing rather getting a local object potentially from a promise synchronously. I'm not sure it's much better, but what about getLocal or something like that?

[michaelfig]

Yes, getLocal sounds reasonable. The test doesn't have to be very elaborate because we assume you're only dealing with objects that are already local, or have been passed to you through a secure comms system from another vat.

[katelynsills]

Ok, sounds good to me!

[erights]

Are we talking about two operations rather than one, or are we just talking about the name of the one operation? I think I'm missing some context.

I think we only need one operation, that should always return a non-promise non-thenable immediately.

[katelynsills]

I think @michaelfig is saying that E.unwrap() needs to remain as is, but I can make my own helper function getLocal. Is that right?

[erights]

@michaelfig does E.unwrap() throwing on non-promises serve any purpose?

[michaelfig]

@erights No particular purpose. Shall we change E.unwrap() as described above?

[erights]

Yes, thanks!