05:20 <doug_> i have an Array[U8] but I cant get the U8 values in a for loop.. keep getting "cannot infer type of for loop iterator"

06:25 <doublec> doug_: can you pastebin some code?

06:25 <doublec> doug_: of the loop body

06:54 <doug_> i finally figured it out.. it was iso issue.. still noob with capabilites

18:36 <dougmacdoug> is there any reason tuple would not be faster than array? i am just assuming there is no special sauce under the hood that would make arrays more performant than tuples in small sizes like a linear math lib

20:21 <SeanTAllen> you'd have to test but i'm not aware of a reason it wouldn't be

20:24 <dougmacdoug> well, i am trying to decide if i should do linear math in arrays or tuples.. i would prefer tuples for many reasons, the only issue is that a lot of math operations might generate a bunch of tuples.. would those be stack objects or heap..

20:37 <SeanTAllen> stack

20:48 <dougmacdoug> cool.. now I just need to figure out who to attach functions to type alias ;p .. maybe i should have started there..

20:48 <SeanTAllen> what do you mean by attach functions to a type alias?

20:49 <dougmacdoug> well, it was a joke, because I just found out i cant do that.. so like type Vec2 is (F32, F32)

20:49 <SeanTAllen> that works

20:49 <SeanTAllen> you can define a type alias for a tyuple

20:49 <dougmacdoug> i cant have a fun scale(s : F32) : Vec2 => (_1*s, _2*s)

20:50 <SeanTAllen> what is it that you want that to do?

20:51 <dougmacdoug> trying to make as lightweight as possible vec2, vec3 types which I can instantiate like (x,y)

20:51 <SeanTAllen> so what do you imagine (_1*s, _2*s) is doing?

20:52 <SeanTAllen> if i call scale(F32(1.0))

20:52 <SeanTAllen> what is the return tuple supposed to be?

20:52 <SeanTAllen> (F32(1.0), F32(1.0)) ?

20:52 <dougmacdoug> if I have v: Vec2 = (1,1) ... then v.scale(2) should return new tuple (2,2)

20:54 <dougmacdoug> seems I will need to use a class with single tuple member variable..

20:55 <SeanTAllen> something like this?

20:55 <SeanTAllen> https://www.irccloud.com/pastebin/aDg30QsB/

20:55 <SeanTAllen> i'm not sure i follow exactly, sorry if that isn't what you want

20:56 <dougmacdoug> primitive Foo

20:56 <dougmacdoug> fun scale(v : Vec2, s: F32): Vec2 => (v._1* s, v.1 *s)

20:57 <dougmacdoug> which is fine but verbose, it would be better if instead of Foo.scale(v, 2) I could call v.scale(2)

20:57 <SeanTAllen> the primitive there is acting as a module

20:58 <SeanTAllen> to call v, you would need a class and that is more expensive, but v. is on a specific object

20:58 <dougmacdoug> right..

20:59 <SeanTAllen> and then you have class and its on the heap, which you are trying to avoid so primitive would be how you need to do it

21:00 <dougmacdoug> I guess I could make a primitive namespace and just put all my fun in there .. i'm still trying to wire my brain into pony mode

21:03 <SeanTAllen> primitives do act as a module.

21:04 <SeanTAllen> i do that quite often, take all my nice functional bits and group them into modules using primitives that are easy to test. then pass in my objects as needed.

21:54 <dougmacdoug> i assume the restrictions on type alias and primitive prevent them from overriding infix operators..

22:18 <SeanTAllen> you need a class if you want to get sugar for add, sub etc so yes