[uryga]

> But at the same time this seems to require colons after... what exactly?

not 100% sure but it kind of looks like copper's Whole Deal™ are "object-functions" (closures?) and you use colons to get an object function's return value. something like this

  adder = [a b]{ ret(this.a + this.b) }
  x = adder(3 5)
  print(x.a x.b x:) # 3 5 8

(i looked at the docs for like 10 minutes, could be wrong)

[nercht12]

You are correct. "object-function" is basically like in Javascript: It's an object (having members) and an executable body. The colons are a shorthand for function call. ie myfunc()

In Copper, variables only store functions. This separates routine from data so you never end up with null pointer errors like in languages that have Any Types or pointers. Functions can return data, so you end up having function calls everywhere. a=5 is basically a={ret(5)}

In your above example the correct first line would be: adder = [a b] { ret(+(a: b:)) }

Parameters to a function are those that are not assigned data, whereas members are: add = [Param, Member=10) { ret(+(Param: this.Member:)) }

Now you can probably see what's wrong with your third line.

[uryga]

yeah, i think i get it now. but if variables can only store functions, how would you write something like this in Copper?

  x = foo()
  bar(x.a, x.b)

[nercht12]

x = foo()

bar(x.a: x.b:)

Functions can return data. So say, a=5, then to get the value of 5 out, all you have to do is call the function a.

Edit: I'm assuming foo() here returns an object with members "a" and "b". An example of such a function-object would be:

foo = [] { ret( [a=5, b=10] ) }

[uryga]

right, but doesn't that contradict this:

> "in Copper, variables only store functions"

because here, `x` clearly stores an object... is this about the whole "object-function" thing where Copper doesn't really distinguish the two?

(btw i'm sure this is explained in the docs... but maybe this'll help folks like me who often just read the comments)

[nercht12]

Copper does not distinguish between function and object. An object-function has two parts: the member part and the executable body. In C++, it's analogous to:

class FunctionObject {

FunctionObject* members[];

void* operator() { /* executable body */ }

};