08:24 <benq> hi

10:22 <vaninwagen> benq ho

10:23 <benq> just a quick 10'000 feet question for a pony developer

10:24 <benq> do you know the chapel programming language and how you compare to ponylang?

10:59 <vaninwagen> me personally i only briefly heard about it.

11:03 <vaninwagen> what i can say for sure is that pony is not a parallel global address space language - at its core it has an actor system

11:04 <vaninwagen> and pony is not distributed yet like chapel

11:07 <vaninwagen> i heard sylvan talk about the problem of locality of actors in a distributed setup

11:07 <vaninwagen> but parallelism needs to be modelled explicitly using actors

16:18 <endformationage> jemc: I'm afraid your gist in response to my query regarding primitives in generics was the same link I posted. I'd be grateful to still have an example using traits as you suggested. I attempted but was unable to find a solution.

16:18 <endformationage> http://playground.ponylang.org/?gist=154f26896f12766b425fe51ca83e32d0

16:32 <jemc> ah, sorry!

16:32 <endformationage> no problem, just still really curious :P

16:33 <jemc> here you go: http://playground.ponylang.org/?gist=afcd3fe485741fc110252a9664a3ee91

16:33 <jemc> my apologies for not copying the new link, and for not reading the chat backlog from yesterday from after I left

16:35 <endformationage> Dang, I thought I tried something like this. I guess I was missing the constructor on the trait.

16:35 <endformationage> Thanks again jemc.

16:38 <jemc> no problem!

17:00 <endformationage> jemc: I have a general feeling as to why this doesn't work, but I cannot quite pinpoint it: http://playground.ponylang.org/?gist=605e779b79824bf576bdc08d14870d4e

17:01 <endformationage> And I realize it wouldn't really solve the over allocation issue you pointed out earlier, but here I'm just experimenting with generics.

17:02 <endformationage> ^ attempting to use Array[T].init(T(0), _count)

17:27 <jemc> I think you're hitting an issue here that I've noted in the past as a pain point for generics, where a type parameter constraint of `(A | B)`, where `A` and `B` are concrete types means that the possible type arguments are `A`, `B`, or `(A | B)` - it's the last one that's causing you trouble here because you don't actually want to allow that as a type argument

17:29 <jemc> the following would work, except for the fact that literal inference is not able to function without the type argument: http://playground.ponylang.org/?gist=8725c897a2ad9c8c52538d5b65f03fad

17:31 <jemc> using `T.min_value()` works, but it's not the same thing as `0` for either `F32` or `I32`

17:32 <endformationage> I see. Yeah I had an incling it had to do with concrete vs not..

17:33 <jemc> using `T.from[U32](0)` is a way to work around the literal inference issue, and the compiler should inline it to a constant, though it's not exactly intuitive: http://playground.ponylang.org/?gist=868578bc3e20983162e15dc30a2a93d3

17:34 <endformationage> Ah, interesting

17:34 <jemc> I'm pretty sure this situation (pain points due to lack of literal inference on a type parameterized number type) came up in a conversation before - SeanTAllen, do you remember this? I think you were involved

17:35 <endformationage> So using Real instead of the Union type pushes the type param to the concrete side of things?

17:35 <endformationage> a trait right?

17:36 <endformationage> I guess I meant to ask, Is a trait considered concrete?

17:36 <SeanTAllen> its not ringing any bells jemc but, i'm also really tired.

17:38 <jemc> I only mentioned concrete types above because I wanted to simplify the discussion to the three cases I mentioned: `A`, `B`, and `(A | B)`

17:39 <jemc> traits and interfaces are *not* concrete types, and I was trying to talk specifically about the case where `A` and `B` are concrete (not traits or interfaces)

17:40 <jemc> because if `A` or `B` were a trait or interface, there would be more than three possibilities for type arguments here, because you might have a third type `C` which is a subtype of `A` and/or `B`, which could be used as a type argument and muddy the waters of the discussion

17:41 <endformationage> Haha. I think I understand it now.

17:42 <jemc> in this case, you were calling a constructor on `T` (either `T.create(value: T)` or `T.from[B: (Number & Real[B] val)](value: B)`)

17:42 <jemc> what's most important is that `T` is something you can call that constructor on

17:44 <jemc> when your constraint is `(F32 | I32)`, and you passed a type argument of literally `(F32 | I32)`, then `T` is a type union, and you can't call a constructor on a type union

17:45 <endformationage> Asesome, I was just about to confirm: "which wasn't the case with the union type"

17:45 <jemc> using `Real[T]` as the constraint requires that the type argument is something on which you could call any of the constructors defined in the `Real` interface

17:46 <jemc> note that if you wanted to limit to only `F32` or `I32`, you can use `((F32 | I32) & Real[T])` as the constraint

17:46 <endformationage> Oh, neat.

17:47 <jemc> which is incidentally the same thingthat the `B` type argument to the `from` constructor is doing :)

17:47 <jemc> (`Number` is a type union, and it is intersected with the `Real` trait)

17:47 <endformationage> I did try messing around with Real, but it didn't occur to me to pass T along to _it's_ type param..

17:48 <endformationage> This helps alot, thank you.

17:49 <jemc> yeah, the circular type parameter like that is a common pattern in Pony, because we don't have a magic `Self` type by which a parameterized type definition could refer to itself