06:55 <Jenz> Moin o/

06:55 <Jenz> DIM = {100, 60}

06:56 <Jenz> Why do I get an error: "invalid constant value" for that?

06:59 <Jenz> Very weird

08:19 <FromGitter> <bew> Where/how do you use it?

10:30 <FromGitter> <apahl> Hi, I am working through "Programming Crystal" by Ivo Balbaert and Simon St. Laurent and I have a question about including modules vs. subclassing. Please keep in mind that I do not come from a Ruby background... ⏎ What is the advantage of implementing `Comparable` as a module in the stdlib and including it in a class where I want to use it vs. implementing it as a class and then subclassing it?

10:31 <FromGitter> <j8r> you're telling essentially composition vs inheritance?

10:33 <FromGitter> <apahl> Yes, probably. For the example of `Comparable` what is the advantage of implementing it via composition?

10:33 <FromGitter> <j8r> yes: you can include it to a struct, a class or another module

10:34 <FromGitter> <j8r> and, you can include multiple module. With inheritance, you can only inherit once and that's it

10:34 <FromGitter> <apahl> Ok, so it can be more versatilly applied that way?

10:34 <FromGitter> <apahl> Thanks for the explanation!

10:34 <FromGitter> <j8r> Yes, it's more flexible

10:37 <FromGitter> <j8r> behind this choice there is also a logic behind: it wouldn't make sense to have a `Comparable` class that can be used as-is. It's a set of methods that can be included ans used in other structs/classes

10:38 <FromGitter> <apahl> Ok, I understand. Thanks again for the explanation, that helped a lot.

10:42 <FromGitter> <j8r> you're welcome :)

11:10 <FromGitter> <codenoid> how do i json.parse with a structs ?

11:34 <FromGitter> <vladfaust> `Struct.from_json("{}")`

17:09 <FromGitter> <jwoertink> Anyone know of a good way to sort of "reset" an instance when you do this sort of pattern? ....

17:09 <FromGitter> <jwoertink> ```class Thing ⏎ INSTANCE = new ⏎ end``` [https://gitter.im/crystal-lang/crystal?at=5c8fd0dc2fb6800d803ee97a]

17:10 <FromGitter> <jwoertink> Mainly for running a spec where the first spec sets up some variables on the instance, then the second spec already knows of these variables

17:10 <FromGitter> <j8r> You want to change a constant?

17:11 <FromGitter> <j8r> you can use `class_property instance`

17:12 <FromGitter> <jwoertink> Yeah, sort of .... I just want to reset the values of `INSTANCE` between specs

17:12 <FromGitter> <jwoertink> but the pattern works fine in the code

17:12 <FromGitter> <j8r> you can instantiate a new class Thing for each

17:13 <FromGitter> <j8r> each spec should be independent of each other, they can be ran separately

17:15 <FromGitter> <jwoertink> I'm not sure I follow, but let me make a quick example

17:17 <FromGitter> <j8r> you should be able to run each `it "should be ... " do ... end` independently, with `crystal spec spec/myfile.cr:12`

17:18 <FromGitter> <jwoertink> https://play.crystal-lang.org/#/r/6ivm

17:21 <FromGitter> <j8r> don't use a constant if it's not really a constant

17:22 <FromGitter> <aemadrid> I’ve seen the singleton usecase a lot on Crystal that way though

17:23 <FromGitter> <j8r> @jwoertink https://play.crystal-lang.org/#/r/6ivt

17:23 <FromGitter> <jwoertink> https://github.com/kemalcr/kemal/blob/master/src/kemal/route_handler.cr#L7

17:23 <FromGitter> <j8r> yeah that's bad

17:24 <FromGitter> <jwoertink> ok, so let's say it has to be a constant because it's a part of a library that won't be changing that...

17:24 <FromGitter> <j8r> that's why @RX14 said https://github.com/kemalcr/kemal/pull/378#issuecomment-440825575

17:24 <FromGitter> <j8r> This is a global mutable state

17:25 <FromGitter> <aemadrid> you might want to make that class resettable - meaning you can say `Xyz::INSTANCE.reset(…)`

17:25 <FromGitter> <j8r> @jwoertink anyway https://play.crystal-lang.org/#/r/6ivv

17:25 <FromGitter> <jwoertink> that's what I was thinking of doing. I was curious of other's solutions

17:26 <FromGitter> <j8r> I'm afraid not :(

17:58 <FromGitter> <kinxer> @jwoertink Soon I'm going to refactor the code I have that uses a singleton, but to reset it in specs I reopen it in the spec_helper, kind of like so: https://play.crystal-lang.org/#/r/6iwa

18:00 <FromGitter> <jwoertink> Yeah, that makes sense. Thanks @kinxer

18:28 <FromGitter> <jwoertink> When using `Spec.before_each`, is there a way to scope it to just the describe block you're in?

18:29 <FromGitter> <vladfaust> Nope

18:29 <FromGitter> <jwoertink> fair enough. Thanks!

18:29 <FromGitter> <kinxer> I don't think so. I think you have to redefine it to an empty method at the end of the block.

18:29 <FromGitter> <vladfaust> It literally runs before each spec in you compiled specs

18:29 <FromGitter> <vladfaust> However, if you split the specs...

18:29 <FromGitter> <vladfaust> And run each in separate call...

18:30 <FromGitter> <kinxer> That's a sad state of affairs.

18:30 <FromGitter> <vladfaust> Absolutely

18:30 <FromGitter> <jwoertink> Yeah. I put it in one file that I wanted it to run, then ran `crystal spec/` and expected it to only work on that file I added it in

18:33 <FromGitter> <kinxer> Speaking of things that (probably) don't exist, is there a way to use macros in comments?

18:34 <FromGitter> <jwoertink> Yeah, you can just do `{% %}` in a comment

18:36 <FromGitter> <kinxer> Oh, cool.

18:37 <FromGitter> <jwoertink> https://github.com/crystal-lang/crystal/blob/60760a5460aa13a1f80c5a1a7410782dc4076b77/src/http/client.cr#L348

18:37 <FromGitter> <jwoertink> there's an example of where it's being done

18:37 <FromGitter> <jwoertink> well, already being in a macro for, but I'm pretty sure that works

20:34 <FromGitter> <Blacksmoke16> ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=5c9000d78126720abc04abfe]

20:35 <FromGitter> <Blacksmoke16> never realized how big the perf diff is between them for `["one", "two", "three"].includes? "three"`

20:40 <FromGitter> <kinxer> Oh, wow.

20:42 <FromGitter> <Blacksmoke16> ```count = 3 ⏎ ⏎ pp StaticArray(Int32, count).new(42)``` [https://gitter.im/crystal-lang/crystal?at=5c9002bdf3dbbd230c7a1fe4]

20:42 <FromGitter> <Blacksmoke16> there goes my idea :P

20:43 <FromGitter> <Blacksmoke16> makes me think that routers would benefit from StaticArray assuming they know number of routes at compile time

20:49 <FromGitter> <straight-shoota> @Blacksmoke16 The costly part is allocating an array on the heap. That's typically a one-time cost for a router.

20:49 <FromGitter> <Blacksmoke16> i.e. once all routes are registered?

20:50 <FromGitter> <straight-shoota> Your benchmark should only compare the call to `#includes?` not instantiating the collection

20:50 <FromGitter> <Blacksmoke16> sec

20:50 <FromGitter> <straight-shoota> yes

20:52 <FromGitter> <Blacksmoke16> ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=5c9004f18aa66959b630ef92]

20:52 <FromGitter> <Blacksmoke16> darn

20:52 <FromGitter> <Blacksmoke16> good call

21:04 <FromGitter> <kinxer> Where would I find the code for the `crystal docs` command?

21:05 <FromGitter> <r00ster91> It's in the compiler: https://github.com/crystal-lang/crystal/tree/master/src/compiler/crystal/tools/doc.

21:09 <FromGitter> <kinxer> Thank you.

21:10 <FromGitter> <r00ster91> you're welcome. good luck if you want to implement something

21:15 <FromGitter> <Blacksmoke16> one thing i noticed that was missing is default values on Ivars

21:15 <FromGitter> <Blacksmoke16> when used w/o initialize

21:23 <FromGitter> <Blacksmoke16> would have to be a new section on the docs id imagine

21:24 <FromGitter> <Blacksmoke16> skipping private and non `getter/property` ones

22:48 <FromGitter> <j8r> That's strange that the `Set` perf is as bad

22:48 <FromGitter> <j8r> What's your code?

22:49 <FromGitter> <j8r> Or maybe that's the `Set#includes?` that isn't optimized

22:53 <FromGitter> <j8r> It performs a `Hash#has_key?`

22:55 <FromGitter> <Blacksmoke16> i dont have it on this computer but was like

22:56 <FromGitter> <Blacksmoke16> ```SET = Set{"one", "two", "three"} ⏎ ⏎ benchmark.ips do |b| ⏎ SET.includes? "three" ⏎ end``` [https://gitter.im/crystal-lang/crystal?at=5c90221352c7a91455b8bfc5]

22:56 <FromGitter> <Blacksmoke16> something like that

22:57 <FromGitter> <j8r> I wonder if the list is longer...

23:14 <FromGitter> <Blacksmoke16> :shrug:

23:14 <FromGitter> <Blacksmoke16> prob would have some impact id imagine

23:25 <FromGitter> <dscottboggs_gitlab> Is `crystal tool expand` broken?

23:28 <FromGitter> <dscottboggs_gitlab> no, I think my macro is broken...

23:29 <FromGitter> <dscottboggs_gitlab> does `{% debug %}` work on like `macro(args)...end` type macros or just literals?

23:32 <FromGitter> <dscottboggs_gitlab> ok I think I get it now... `{% debug %}` only works when you put it *after* what you want output