08:47 <fifr> Hi everyone. I have questions: when "include"ing a generic module and the type parameter refers to some type that comes later in the current scope, it fails with an "undefined constant" error: https://carc.in/#/r/c8m2

08:48 <fifr> Is this expected/desired?

12:45 <jhass[m]> At least it's consistent with subclassing https://carc.in/#/r/c8nz

12:45 <jhass[m]> instance variables are evaluated only at a second pass I think

12:45 <jhass[m]> Not sure on the desirability part though

12:58 <fifr> jhass[m]: oh, yeah, and it's basically the same even with generics: https://carc.in/#/r/c8o3 so it's probably expected (I've just not been aware of)

12:58 <fifr> thx

18:37 <jeremyc> When I have a variable that can potentially be nil, how can I satisfy the compiler that it is not nil? i.e. if var_name ... File.open(var_name) fails on no overload match (Nil.class | String)

18:39 <FromGitter> <Blacksmoke16> ideally make it so that variable isnt nilable

18:39 <FromGitter> <Blacksmoke16> otherwise you can do like

18:39 <FromGitter> <Blacksmoke16> ```var_name.try do |name| ⏎ # name is not nilable here ⏎ end``` [https://gitter.im/crystal-lang/crystal?at=618d6377d3ae402e47a1abcd]

18:39 <FromGitter> <Blacksmoke16> or ⏎ ⏎ `````` [https://gitter.im/crystal-lang/crystal?at=618d637a3f09d857366974d0]

18:40 <FromGitter> <Blacksmoke16> ```if name = var_name ⏎ end ⏎ # or ⏎ if var_name ⏎ end``` [https://gitter.im/crystal-lang/crystal?at=618d63898c019f0d0b8c96f9]

18:40 <FromGitter> <Blacksmoke16> if you absolutely know it won't be nil, but the compiler can't prove that you can do `var_name.not_nil!`

18:41 <FromGitter> <Blacksmoke16> but usually the best option is ask if that var actually needs to be nilable

18:41 <jeremyc> It's a parameter that may be given on the command line, dealt with through OptionParser.

18:41 <jeremyc> I figured default of Nil was the right thing, if the option wasn't used. Maybe not so.

18:42 <FromGitter> <Blacksmoke16> fwiw you prob want `var_name = nil` not `var_name = Nil`

18:42 <FromGitter> <Blacksmoke16> the latter is assigning it a value of `Nil.class` not the value of `nil`

18:43 <FromGitter> <Blacksmoke16> but yea, if it's optional, using nil seems appropriate

20:50 <hightower2>

20:52 <hightower2> Hey give me an idea if you can... So I read some binary data from the wire and create an object from it. This part is easy because the data is always in the same order. But then this is followed by an optional list of binary infos, where each element consists of [type, len, data of type <type> and len <len>]... Reading this is also no problem, but I am kind of unclear on where to save this data in the main object...

20:52 <hightower2> I mean, because type is varying, so I can't just have a list or a hash

20:55 <FromGitter> <Blacksmoke16> use some base type possibly with a disriminator?

20:55 <FromGitter> <maxfierke> a custom struct type is probably a good place for this. `JSON::Any` might be useful inspiration (then you can treat it as a sort of a box of data and keep the secrets of how to interpret that data within that type)

21:00 <hightower2> hm indeed, struct could work

21:00 <hightower2> ok, thanks for ideas

21:01 <hightower2> as for base type... yeah, having a base class for all could help, although I'm not sure how far to the final solution that'd bring me.. I'll think about it.

22:28 <FromGitter> <jrei:matrix.org> You can put what's optional to a dedicated ivar

22:28 <FromGitter> <jrei:matrix.org> Then, have a case/when with the type and parse the following data accordingly for each case

22:30 <FromGitter> <jrei:matrix.org> That's the essentially the same as descriminator, as @Blacksmoke16 suggested

22:56 <jeremyc> Does the scry lsp server work? Seems a little dated, was trying to make it work with kakoune w/no luck.

22:57 <jeremyc> Dunno if the problem is with Kakoune or scry

23:13 <riza> I think crystaline is more up to date, but i don't think either are nearing completion yet

23:13 <riza> https://github.com/elbywan/crystalline