Replacing the Body of an Object Function

Suppose you have an object “a” that you have already instantiated members in.

a.b = 10

Now suppose you need to make the return of “a” equal to 9 so that:

print(a:)

… prints “9”. If you were to assign 9 to “a” directly, you would be giving “a” an entirely new object-function, thereby losing the member “b”. Fortunately, there is a way around the problem. Copper has a built-in function called “share_body” that allows two object-functions to share the same execution body. For example:

c = 9
share_body(c a)

… would allow “a” to have the body of “c”. If “c” gets destroyed from going out of scope, then “a” keeps the body. However, creating a new variable just to make a function body is unnecessary. If we create an ownerless object-function to share its body with “a”, then “a” will become the owner of the body.

share_body({9} a)

The ownerless object-function {9} is instantiated within the function-call parentheses of share_body where it dies but its body lives on. And there you have it, no copies required, no loss of object members.

Multidimensional List Solution

In a previous article, I wrote about how it was difficult to produce a 2D list in Copper due to the ownership dilemma. The solution at the time was to write a singly-linked list in Copper. It turns out, there is a better approach, one that will also allow us to create any multi-dimensional list.

Multidimensional List Access Problem

Suppose you wanted to create a 2-dimensional list. This can be easily done with the list constructor. ex:

mylist = list(list(9))

Now suppose we wanted to access the item in the second dimension of the list. Lists are special in that they are objects that contain other objects without themselves containing variables. To access an item in the list, we use the item_at() system function. This returns an object. Performing it once will return the child list. From there, we can call item_at() in succession to access the item of interest:

myitem = item_at(item_at(mylist: 0) 0)

Easy object member access for C++

Under the hood, Copper is a rather complicated system. It has to be that way in order to ensure Copper is safe (no null pointer errors) within Copper code. However, on the C++ side, this makes it tricky to just access the members and data of a FunctionObject, the most important of all Copper objects. Now there’s an easy way.