Transferring in/out a structure of isolated objects

[MaryamZi]

Description:
Please consider the following example.

isolated class Foo {
   private int i = 1;

   function get() returns int {
      lock {
         return self.i;
      }
   }

   function increment() {
      lock {
         self.i += 1;
      }
   }
}

isolated class Bar {
   private Foo[] arr = [];

   function getArr() returns Foo[] {
      // Want to return an array that contains the same members as `self.arr` here.
   }
}

I don't think it is currently possible to do what's required in getArr.

Both the following are invalid.

Case I

   function getArr() returns Foo[] {
      lock {
         return self.arr; // ERROR: invalid attempt to transfer out, not an isolated expression.
      }
   }

Case II

   function getArr() returns Foo[] {
      Foo[] copy = [];
      lock {
         foreach Foo foo in self.arr {
            copy.push(foo); // ERROR: invalid attempt to transfer in `copy`
         }
      }
      return copy;
   }

In Case I, clone or cloneReadOnly cannot be used either, since Foo is not a subtype of value:Cloneable.

There were some scenarios where the standard library had a similar requirement too, but they were generally able to use read-only classes. But in cases where only a field would change previously they now have to create a new object since the original value cannot be updated.

[MaryamZi]

Also wondering if spread fields/expressions can help to a certain extent.

Using a spread field in a mapping constructor as an example (since we don't have list spread yet), if the following is allowed, I guess we can use this in the mapping case?

isolated class Bar {
   private map<Foo> m = {};

   function getMap() returns map<Foo> {
      lock {
         return {...self.m};
      }
   }
}

The implementation does not seem to allow this at the moment though.

[jclark]

Relates to #52.

[MaryamZi]

There's also a related scenario when the structure has a combination of isolated objects and values that belong to value:Cloneable.

I guess we can still use the spread operator if the values that belong to value:Cloneable are subtypes of readonly.

type Config record {|
   int[] & readonly a;
   IsolatedClass b;
|};

But this would not be possible if the types of the rest of the fields are not subtypes of readonly.

type Config record {|
   int[] a;
   IsolatedClass b;
   map<boolean> c;
|};

isolated class Foo {
   private Config c;

   isolated function init(Config con) {
      self.c = con; // ERROR: RHS is not an isolated expression and cannot use `clone`/`cloneReadOnly`.
                    // `self.c = {...con};` can't be used because `a` and `c` are mutable.
   }
}

Although we can get this to work by separating out the isolated objects and the values that belong to value:Cloneable and only using clone/cloneReadOnly with the latter, I don't think it will scale with nested records that have isolated objects as field types.

isolated class Foo {
   private Config c;

   isolated function init(Config con) {
      var {b, ...rest} = con;
      self.c = {b, ...rest.clone()};
   }
}

Could be related to #784

[jclark]

Please make #855 (comment) a separate issue.

[jclark]

Can we make a query expression work?

from var f in self.array select f

[MaryamZi]

Please make #855 (comment) a separate issue.

Created #856

Can we make a query expression work?

from var f in self.array select f

The implementation seems to have inadvertently allowed this already for transferring out. If the iterable value used in the from-clause is not an invalid transfer in and f is an isolated expression, the query expression currently seems to be considered an isolated expression.

[MaryamZi]

This is allowed at the moment when we transfer out (to an array using member access) one isolated object at a time.

isolated class Bar {
    private Foo[] arr = [];

    function getArr() returns Foo[] {
        Foo[] copy = [];
        lock {
            foreach [int, Foo] [index, foo] in self.arr.enumerate() {
                copy[index] = foo; // transfer out
            }
        }
        return copy;
    }
}

isolated class Foo {
    private int i = 1;

    function get() returns int {
        lock {
            return self.i;
        }
    }

    function increment() {
        lock {
            self.i += 1;
        }
    }
}