00:42 <FromGitter> <Dan-Do> @SamantazFox do you see slowness in stdlib json?

00:42 <FromGitter> <Dan-Do> In Kostya's json benchmark, it's 10 times slower then simdjson

00:47 <SamantazFox> Dan-Do: yes, from time to time

00:47 <SamantazFox> it sometimes uses a lot of CPU and/or RAM

00:48 <SamantazFox> but that improved greatly since we improved the code and make preliminary checks before digging too far into the hierarchy

00:51 <FromGitter> <Dan-Do> 👍

14:31 <FromGitter> <naqvis> doesn't *variadic* means *zero* or more params?

14:32 <FromGitter> <naqvis> https://carc.in/#/r/cbyy

14:32 <FromGitter> <naqvis> am i missing something?

14:58 <SamantazFox> naqvis: you're missing a default value for your function arguments, so you can't pass 0 args.

14:59 <SamantazFox> Oh, and splat parameters can't have default values

14:59 <SamantazFox> So you're forced to pass at least one arg

14:59 <SamantazFox> https://carc.in/#/r/cbzd

15:00 <FromGitter> <naqvis> yeah, and that was my question on how to understand variadic params

15:00 <FromGitter> <naqvis> per defintion that means zero or more

15:08 <SamantazFox> https://crystal-lang.org/reference/syntax_and_semantics/default_values_named_arguments_splats_tuples_and_overloading.html#components-of-a-method-call

15:09 <SamantazFox> it's splat parameters, it's a little bit different from variadic parameters

15:10 <FromGitter> <naqvis> Splat is variadic argument in Crystal.

15:11 <FromGitter> <naqvis> https://crystal-lang.org/reference/syntax_and_semantics/macros/index.html#variadic-arguments-and-splatting

15:12 <SamantazFox> This is in macros, this is a bit different

15:13 <SamantazFox> I've made an issue about that: the macro language, while being very close to the rest of the crystal code, has small differences.

15:18 <SamantazFox> https://carc.in/#/r/cc04

15:18 <SamantazFox> here is for instance a macro with a splat parameter, and you'll see that it accepts 0+ arguments

15:19 <SamantazFox> Here's is the issue: https://github.com/crystal-lang/crystal/issues/11143

15:20 <SamantazFox> s/Here's is/Here is/

15:21 <FromGitter> <naqvis> variadic params are turned to `TupleLiteral` in macro land and that's same as for non-macro world.

15:22 <FromGitter> <naqvis> this seems to be bug to me

16:39 <FromGitter> <asterite> why?

16:43 <FromGitter> <asterite> Strange, I thought this was documented. When a splat has a type restriction, it only matches one or more args. The reason is that if you have multiple overloads with different types, for example `foo(*x : Int32)` and `foo(*x : String)`, which one is chosen if you call it without args? The answer is: none! You have to define a separate overload `foo` without args. No ambiguity! But if there's no type

16:43 <FromGitter> ... restriction, the problem doesn't exist, so it matches zero args. Given that macros don't have type restrictions, splat match zero args.

16:59 <FromGitter> <naqvis> thanks for the clarification Ary. But this restriction means that one can't have `Proc` defined for variadic params

16:59 <FromGitter> <naqvis> as `Proc` requires type definitions to be defined

17:12 <SamantazFox> <asterite> "Strange, I thought this was documented." <- I'm going to be honnest: many, many edge cases and other complex part of the Crystal language are not documented at all.

17:12 <SamantazFox> Like, sometimes, I have to go in the stdlib code to understand how some specifics work

17:13 <FromGitter> <Blacksmoke16> it would be helpful if people create issues or ideally PRs when they run into this stuff

17:13 <FromGitter> <Blacksmoke16> either on the book repo or crystal itself if its an API thing

17:15 <SamantazFox> I do!

17:15 <SamantazFox> https://github.com/crystal-lang/crystal-book/issues/542

17:15 <FromGitter> <Blacksmoke16> ❤️

17:24 <SamantazFox> reminds me that I forgot to open an issue for something

19:54 <riza> puts [1,1,1].reduce(&.+) => 1

19:54 <riza> I expected 3...but I don't know why that didn't work

19:54 <riza> puts [1,1,1].reduce { |acc, i| acc + i } => 3

19:56 <straight-shoota> `&.+` has no arguments, so it references the unary operator

19:56 <straight-shoota> it's essentially `[1, 1, 1].reduce { |acc, i| +i }`

19:57 <riza> oh yes, right. the "positive" sign strikes again

19:59 <riza> ruby has that figured out somehow

20:00 <straight-shoota> Ruby has no overloading so there's only one + method

20:01 <riza> I don't follow what you mean, how is overloading at play here?

20:01 <straight-shoota> wait

20:03 <straight-shoota> Short block syntax in Ruby are just symbols which are turned into a proc and call a method of their own name, forwarding all block parameters.

20:03 <straight-shoota> In Crystal it's a separate syntax feature and you write the call explicitly with full controll over it

20:03 <riza> there we go, that's what I was assuming

20:40 <FromGitter> <Blacksmoke16> fwiw in this case you can just use `#sum`

21:05 <riza> well... why didn't you say that 45min ago! hah

21:13 <FromGitter> <jrei:matrix.org> Not fun otherwise :)

21:30 <riza> does the crystal implementation of Time provide for a notion of time which isn't fixed to a day? or is the practice to simply ignore the date-part of a Time if all that's needed is the hours/minutes/esconds

21:31 <FromGitter> <Blacksmoke16> Time::Span maybe?

21:32 <FromGitter> <oprypin:matrix.org> nah that's not it. ⏎ i think there isn't such a thing in crystal

21:32 <FromGitter> <Blacksmoke16> It's more so for duration yea

21:32 <FromGitter> <oprypin:matrix.org> i've actually never run into such a thing anywhere, so i was surprised that Python has it

22:26 <SamantazFox> Time::Span seems the more appropriate to simply store hours/minutes/seconds

22:26 <SamantazFox> And if required, can easily be applied to a Time object.

22:43 <FromGitter> <Blacksmoke16> yea it stores a duration of time

22:44 <FromGitter> <Blacksmoke16> what's your use case for only needing the time and not the date?