03:55 <AwesomeBrony> Hello

17:58 <btab> Heya - could someone take a quick look at https://gist.github.com/btab/1d814e886e9216c26cf0be485c1a0f5d and let me know what I'm missing? I don't understand how to address the compile errors.

19:16 <theodus> Hey btab, I'm getting the same errors. This seems to be a bug in the compiler because it is saying that "ref is not a subtype of #read" even though it is.

19:17 <theodus> The same goes for val.

19:18 <btab> Oh good - I'm not going crazy :-)

19:19 <btab> I'm happy to raise an issue but could use some help checking this won't be a dupe of an existing one - not quite sure what to look for.

19:25 <theodus> I think this is another example of the issues with subtype checking shown in issues 1193, 1328, and 1393. I'm not positive if it's the same issue though it seems to be related.

20:21 <btab> OK I think I have another one. Can someone take a look at this: https://gist.github.com/btab/a9c63828cbc3858f7a350faa8c02c974 ?

20:21 <btab> I may just have misunderstand how the various refcap defaults are meant to act in these cases - but it's not doing what I expect.

20:43 <doublec> btab: that's odd - it seems to be treating the default rcap for a class as iso

20:43 <doublec> btab: but it should be ref

20:45 <doublec> btab: if you give Foo a constructor it works

20:45 <doublec> maybe the default constructor for a class is "new iso create"

20:47 <doublec> btab: if that's the case you cn just declare the type: let f1: Foo = Foo

20:47 <doublec> btab: or consume it: useFoo(consume f1)

20:55 <btab> Yeah - there are a few ways to overcome it (I'm favoring the approach shown in 'f2' - declare the type explicitly). So if you're right about the default constructor type, that means that supplying the type explicitly on the LHS of the let expression isn't just saying 'give me a Foo' but actually saying 'give me a Foo ref' (and so coercing the iso to a ref).

20:55 <btab> Easy to work around - but again not what I was expecting :-)

21:00 <doublec> btab: yes, the default cap for a class is 'ref', so "let x: Foo" is "let x: Foo ref". And automatic recovery is converting the iso to a ref in that case.

21:06 <btab> Oh because classes can have constructors with different refcaps to their own. So let x = Foo reads 'declare x and make it the type of Foo.create()' per the sugaring for constructors. Whereas let x:Foo = Foo reads 'declare x and make it the type of class Foo - and then do your best to make the RHS match this'.

21:06 <btab> Is that right?

21:07 <btab> So I guess the only thing I need a better understanding of is why the default constructor returns an iso when an explicit constructor has a default refcap of ref. Any thoughts on that?

21:08 <doublec> btab: yes

21:08 <doublec> btab: Although "let x = Foo" is more "declare x and infer the type from the right hand side, and the RHS is a constructor so use the rcap of that"

21:08 <btab> Ah sorry - yeah that's what I meant.

21:09 <doublec> btab: I don't know what the default constructor is an iso - one of the language devs might be able to comment further on that

21:09 <doublec> d/what/why/

21:09 <doublec> s/d/s/

21:09 <doublec> Bad keyboard day :)