14:01 <EEVV> hey what is a subcap error?

14:15 <EEVV> what is a subcap

14:41 <vaninwagen> I think it is analogous to a subtype: a sub capability

14:42 <vaninwagen> Something that a capability can be replaced with (i might not be 100% correct on this typesystem stuff)

14:42 <vaninwagen> If you give more context i could provide some more help EEVV

14:44 <EEVV> vaninwagen, I took a bit of a break from pony-lang, I was working on a project... I am changing the project a bit and I guess I messed up somewhere: I have a variable in my TCPConnectionNotify actor which stores a glorified array `ProtoBuffer`, most of the functions I do on the array are `fun ref`, but I tried setting the variable's type to `ProtoBuffer ref` with no luck

14:45 <EEVV> it says that my variable is `box` but I set it to `ref`... maybe the problem is deeper than this? I do not understand reference capabilities that well

14:46 <EEVV> I guess I mostly used the reference capabilities it wanted

14:49 <EEVV> ok, I think I had to change a function to `fun ref` but I am still confused.... Is `fun ref` a function that will change the local variables?

14:52 <EEVV> I guess I'm just stupid lol

14:56 <EEVV> also is it possible to copy a `ref` type to `val` without doing it manually?

15:08 <vaninwagen> You are definitely not stupid

15:08 <vaninwagen> After all you are here

15:08 <vaninwagen> a fun ref is a function that can mutate fields on the receiver, yes

15:09 <vaninwagen> If you have a simple fun (without the ref) then this is fun box

15:10 <EEVV> vaninwagen, ok is it possible to copy `ref` to make a `val`?

15:11 <EEVV> without doing it by hand?

15:11 <EEVV> last time I think someone said there is an issue with it, but maybe it is possible now?

15:13 <EEVV> I am also confused on `recover` and `consume`

15:13 <EEVV> they seem to be opposites of each other, but why does `recover` take a block of statements?

15:19 <EEVV> maybe i am asking too much

15:20 <EEVV> cheat sheet says recover is to lift a capability and consume is getting rid of alias

15:22 <EEVV> ok I'll just ask last question and I will try to figure out other problems on my own. When should I create actors? Right now I am just doing as STD tells me to (TCPConnectionNotify is actor, etc..)

15:22 <EEVV> before you answer consider that I haven't used threading much elsewhere

15:48 <vaninwagen> fun box means, you only see the receiver (mostly known as this) as read-only, so you cannot modify any fields

15:49 <vaninwagen> EEVV: copying ref to val would be unsafe

15:49 <EEVV> vaninwagen, I mean in the same actor

15:50 <vaninwagen> Because a val is sendable, you can send it to another actor, while ref is not sendable, but doesnt restrict how many references you have locally

15:50 <vaninwagen> EEVV still not possible, because the compiler doesnt know too well

15:50 <EEVV> what I mean by copy is create an array that just has the same elements, I think deep copy is the word

15:50 <vaninwagen> This is definitely possible

15:50 <EEVV> Array[U8 val] ref ->> Array[U8 val] val

15:51 <vaninwagen> Sorry, i misunderstood you apparantly

15:51 <EEVV> I did it by using an Array[U8 val] iso, filled it with copies from the `Array[U8 val] ref` then consumed it to `val`

15:51 <EEVV> maybe there is a better way?

15:52 <EEVV> (consume a iso^ to be specific)

15:53 <vaninwagen> You can try: https://stdlib.ponylang.io/builtin-Array/#copy_from91optional-b-a-real91b93-val-u8-val93

15:54 <vaninwagen> consume and recover are too different imho to be duals

15:54 <vaninwagen> consume gives up the reference passed to it and marks it as unusable, and it returns the consumed reference

15:55 <EEVV> vaninwagen, why can I not consume a ref^ to get val?

15:55 <vaninwagen> This is not hoe consume works

15:55 <vaninwagen> You would need recover for this

15:55 <EEVV> why not?

15:56 <EEVV> yes I used recover but I do not understand why

15:56 <vaninwagen> If you give up your ref reference using consume there could still be more refs around

15:56 <vaninwagen> So it is still unsafe

15:57 <vaninwagen> recover works in the following way:

15:57 <vaninwagen> It lets you convert between capabilities, if the conversion is still safe

15:58 <vaninwagen> The way from ref to val is safe, if we know there are no more references to the ref around

15:58 <EEVV> but I thought ref^ has no aliases?

15:58 <EEVV> are aliases not the same thing as references?

15:58 <vaninwagen> They are

15:58 <EEVV> so doesn't the `^` in ref^ say that it will not have extra aliases?

15:59 <EEVV> or I guess no aliases at all

15:59 <vaninwagen> In general this is how i thought about it too

15:59 <vaninwagen> But to be mord exact it is a unassigned reference floating around without a variable pointing to it

15:59 <vaninwagen> Kinda

16:00 <vaninwagen> So it doesnt say, there are NO OTHER references to the object it points to

16:00 <vaninwagen> Only in combination with iso

16:00 <vaninwagen> So, an iso^ is really without additional references

16:00 <EEVV> what about trn^?

17:46 <vaninwagen> A trn is only write unique

17:47 <vaninwagen> There could be other read-only references (e.g box) to the same object