01:25 <FunkyBob> morning, all

01:27 <FunkyBob> just verifying as I get started with pony.... I'd use a primitive for declaring consts, yes?

01:35 <doublec> FunkyBob: yep

01:35 <doublec> FunkyBob: primitives can't have fields so you'd use functions returning the value

01:36 <doublec> FunkyBob: see regex/regex.pony for an example

01:37 <FunkyBob> thanks

01:37 <FunkyBob> and all methods anf fields on an instance are implicitly in its scope?

01:37 <FunkyBob> there's no self or this?

01:40 <doublec> FunkyBob: On a primitive?

01:42 <FunkyBob> hmm.. point

01:42 <doublec> FunkyBob: there's a 'this' in classes and actors

01:42 <FunkyBob> it's a form of singleton, yes?

01:42 <FunkyBob> ok

01:43 <doublec> FunkyBob: primitives have one too but there singleton like you say

01:43 <doublec> s/there/they're/

01:45 <FunkyBob> just getting buried in the amount of boilerplate I'm queueing up to generate :)

01:46 <doublec> heh, are you wrapping a C library?

01:46 <FunkyBob> no

01:46 <FunkyBob> friend of mine wrote a Python VM in JS... so I'm retorting by writing one in Pony :P

01:46 <doublec> nice

01:48 <FunkyBob> ah... just saw in docs:

01:48 <FunkyBob> primitive Red fun apply(): U32 => 0xFF0000FF

01:49 <FunkyBob> sad I can't just do primitive Thing => value

01:50 <FunkyBob> can I do apply() => U8: 'a' ?

01:56 <doublec> FunkyBob: yes, but it's: apply(): U8 => 'a'

01:56 <FunkyBob> oops, thanks :)

01:58 <FunkyBob> so, I have a type that is a | of 29 primitives... yay...

01:59 <doublec> Sounds like a lexer or ast of some sort :)

02:00 <FunkyBob> indeed

02:00 <FunkyBob> this is for the de-marshal code to read the bycode

02:02 <FunkyBob> ~ is bitwise inversion?

02:06 <doublec> I don't know sorry

02:09 <FunkyBob> in a match block... want two cases to work the same... can I do "| (A | B) =>" ?

02:12 <doublec> FunkyBob: yes

14:02 <Perelandric> Very basic generics question. My understanding is if you have `class Foo[T]`, and make `Foo[Bar]`, then `T` becomes `Bar`.

14:02 <Perelandric> So if my generic class has `fun foo(t: T) => t.test()`, and `Bar` has a `.test()` method, why doesn't it compile?

14:03 <Perelandric> My basic understanding must be flawed.

14:03 <Perelandric> https://gist.github.com/Perelandric/0a2ffd8daebb32d3503630dc90a92b4f

14:04 <Perelandric> Does it actually *require* traits or interfaces to be able to call methods?

14:21 <SeanTAllen> you have to constrain T to be of a type that conforms to the interface you need, which means you need to name the interface and constrain T to that

14:23 <SeanTAllen> see the gist Perelandric, i put what you need in the comments

14:31 <Perelandric> SeanTAllen: Thanks. I understand that it can be done with constraints. I guess I just thought that it could be done without...

14:32 <Perelandric> ...and that the compiler when generating the specific code would catch stuff that wouldn't match the type.

14:32 <Perelandric> But that answers my question.

14:34 <SeanTAllen> It needs to be able to work for any T

14:34 <SeanTAllen> Any T that you define as being valid

14:36 <Perelandric> So the generic types are fully analysed before they're ever expanded...

14:37 <Perelandric> ... instead being analysed after the expansion in the case of unconstrained types.

14:41 <SeanTAllen> I've read that a few times and i'm having a hard time parsing it

14:42 <SeanTAllen> I'm not sure what "expanded" means but I think you are thinking of generics like type checked macros, which they aren't.

14:43 <SeanTAllen> what you say when you have class Foo[T] is that T is of type Any

14:43 <SeanTAllen> which means that you can only use like you would an Any

14:43 <SeanTAllen> the Any is implicit in that definition you wrote, any type can work here

14:44 <Perelandric> SeanTAllen: Thank you. That greatly sheds light on the flaw in my understanding.

15:20 <mcguire> Perelandric, AIUI, A C++ template would do what you expect: you plug a type Bar into foo(t:T), the compiler expands the template like a macro, and *then* the compiler typechecks the resulting code.

15:21 <mcguire> Pony, Java, Rust, etc., do it the opposite way: they typecheck the generic class or whatever, then separately check the uses of the class. To get the class to compile, you have to specify the requirements on T: the trait (or whatever) needed to supply the test() method.

15:31 <Perelandric> mcguire: Thank you, that does explain my flawed mental model very well.

15:31 <Perelandric> I'm ultimately trying to figure out why I can't get a specific generic implementation to work.

15:33 <Perelandric> It is boiling down to the definition of rcaps in a specific spot...

15:33 <Perelandric> and so I'm starting over and making sure I'm understanding things from the ground up.

15:33 <Perelandric> Sean's and your comments are very helpful to that end.