00:06 <FromGitter> <Blacksmoke16> https://crystal-lang.org/api/master/HTTP/Client.html#connect_timeout=(connect_timeout:Number)-instance-method

00:11 <ukd1> Blacksmoke16, no - i'm deliberatly holding it open; I need to know when the other end (client) disconnects from the server

00:15 <FromGitter> <Blacksmoke16> hm im not sure

01:19 <FromGitter> <asterite> named tuple has a limit to avoid that infinite recursion. There's no real limit I think for defining a named tuple with more than 300 elements, but I can't see a use case for that. Named tuple represent argument methods and should be used like that. And I can't imagine passing 300 arguments to a method. Plus Hash will work equally fine, or the performance will be probably be negligible

02:23 <FromGitter> <rmarronnier> Thanks @asterite for the detailed answer. ⏎ ⏎ > Named tuple represent argument methods and should be used like that ⏎ ⏎ Ok, this makes sense now. [https://gitter.im/crystal-lang/crystal?at=5d785a98d5c7bd57946f6d3b]

02:24 <companion_cube> asterite: why not have a recursion limit on the specializer instead?

02:24 <companion_cube> or syntactic criteria (ie uniform or ground specialization)

04:06 <companion_cube> did anyone consider enabling github sponsors for crystal

04:06 <companion_cube> ?

04:09 <FromGitter> <galvertez> anybody know if `@[AlwaysInline]` works if the method yields? it seems like something that would be ignored if a method yields but i'm not sure and i'm curious

04:09 <FromGitter> <galvertez> i don't figure there's any way to tell (easily)

07:57 <FromGitter> <Daniel-Worrall> You've been able to sponsor Crystal on Github since its release.

08:56 <FromGitter> <bew> @galvertez i think it should work too

10:17 <FromGitter> <asterite> galvertez a method that yields is always inlined, that annotation has no effect in that case

10:55 <FromGitter> <mavu> If I want (read: have to) do HTTPS with crystal, what should be my first choice?

10:56 <FromGitter> <mavu> Add a server in front of my software? (i.e. nginx handles ssl)

10:56 <FromGitter> <mavu> or do it in cryatal "natively"?

10:57 <FromGitter> <mavu> Or in other words: Is HTTPS in crystal nice, easy and secure enough, or is it something you use when you have no other options?

11:02 <FromGitter> <straight-shoota> Crystal's `HTTP::Server` can do HTTPS but, it's not a very sophisticated webserver overall. It's designed to provide a framework for building an application server. For production apps, I'd recommend to always put it behind a reverse proxy like nginx . It offer way more features and greatly improves the performance and safety of your HTTP application.

11:03 <FromGitter> <Daniel-Worrall> You

11:04 <FromGitter> <Daniel-Worrall> Best practice is to build it behind a reverse proxy like nginx and if you need the security from the app passing it to

11:05 <FromGitter> <Daniel-Worrall> (My thumb hates me)

11:06 <FromGitter> <Daniel-Worrall> And if you need the security from app to proxy you can use https on the app too as Johannes said

11:06 <FromGitter> <mavu> ok, thanks. ⏎ my webserver is just a tiny configuration UI tacked on a service, so thats why i'm undecided which way to go.

11:07 <FromGitter> <mavu> nginx is not a problem, but an additional package to install and configure. ⏎ on the other hand that would require no rebuilding/new release of hte main serrvice.

11:08 <FromGitter> <mavu> I think I'll toss a coin.

11:10 <FromGitter> <mavu> Hmm. could someone point me to an example of a HTTPS server in crystal? ⏎ the documentation only lists the TCPServer variant, and I'm not sure how I start a HTTPserver on a existing TCPServer?

11:15 <FromGitter> <Daniel-Worrall> pass the tls: true option

11:16 <FromGitter> <Daniel-Worrall> I know Kemal uses http server and it just has the certs passed in from launch args but idk about Stalin

11:16 <FromGitter> <Daniel-Worrall> Stdlib

11:17 <FromGitter> <mavu> Ahhh. found it, I was looking in the wrong place. thankd

11:33 <FromGitter> <bew> @asterite about inlining for methods that yields, I know the block is inlined in the method, but the method is always inlined too??

14:13 <companion_cube> Daniel-Worrall: hmm it only redirects to external sites, I was thinking of the new sponsorship within github

14:14 <FromGitter> <Daniel-Worrall> External sites are linked up with things and github sponsor handles providing the external links. /shrug

14:55 <FromGitter> <asterite> @bew I'm not sure I understand the question. If you have a method that does `a = 1; yield a; puts a + 2` and you call that passing the block, that entire code, including the block, is inlined in the parent method

14:55 <FromGitter> <asterite> that's why `5.times { ... }` is exactly equivalent to `i = 0; while i < 5; ...; i += 1; end`

14:58 <FromGitter> <asterite> I guess you asked whether `i = 0; i < 5; etc.` isn't inlined, but it is. The block can `return` so the entire method that yields must be inlined in the caller

15:03 <FromGitter> <Daniel-Worrall> Is there any way I can cast a custom class? ⏎ ⏎ ```class Foo(T) ⏎ @bar : T? ⏎ end ⏎ Foo(String).new.as(Foo(Int32))``` [https://gitter.im/crystal-lang/crystal?at=5d790cd4ae44a84124bd2d8c]

15:04 <FromGitter> <Daniel-Worrall> https://carc.in/#/r/7jlj

15:04 <FromGitter> <Blacksmoke16> whats the use case?

15:05 <FromGitter> <Daniel-Worrall> Casting an Event(AllTypes) to Event(Specific) or the other way around, so I can integrate with EDA to emit an "all events" signal

15:05 <FromGitter> <Daniel-Worrall> so AllTypes would be an alias union

15:05 <FromGitter> <Blacksmoke16> what if you include a module into each and listen on that module

15:06 <FromGitter> <Blacksmoke16> otherwise afaik no you cant since `Foo(Int32)` isnt the same thing as `Foo(String)`

15:06 <FromGitter> <Daniel-Worrall> Well

15:06 <FromGitter> <Daniel-Worrall> `Foo(String | Int32) to Foo(String)`

15:06 <FromGitter> <Daniel-Worrall> or backwards

15:06 <FromGitter> <Daniel-Worrall> is my use case

15:06 <FromGitter> <Blacksmoke16> still dont think you could

15:07 <FromGitter> <Daniel-Worrall> I don't think I *should* do including on each since then I'm registering on every specific class and removing it will be harder

15:07 <FromGitter> <Daniel-Worrall> or impossible

15:09 <FromGitter> <Blacksmoke16> im not sure i follow

15:09 <FromGitter> <Blacksmoke16> if the goal is to emit something that all "children" will react to that would be idea no?

15:09 <FromGitter> <Blacksmoke16> ideal

15:09 <FromGitter> <Blacksmoke16> while still being able to emit single class events

15:10 <FromGitter> <Daniel-Worrall> yes, but then there'd be the same proc for each, but with their own handler id

15:10 <FromGitter> <Daniel-Worrall> which I'd have to store since I'm trying to abstract it away for the user

15:14 <FromGitter> <Blacksmoke16> seems you cant subscribe to a parent type anyway

15:26 <FromGitter> <Daniel-Worrall> https://carc.in/#/r/7jm3

15:26 <FromGitter> <Daniel-Worrall> How bad of an idea is this

15:31 <FromGitter> <asterite> My guess is that you probably don't need Foo to be generic. `bar` should be the union of all types and that's it

15:39 <FromGitter> <Daniel-Worrall> Ah yeah, but I still need to put Foo(Klass)

15:39 <FromGitter> <Daniel-Worrall> otherwise, even if I specify it to use a union, it just falls back to a string

15:40 <FromGitter> <Daniel-Worrall> ty boios

15:55 <FromGitter> <Daniel-Worrall> ```p foo = nil ⏎ foo``` ⏎ ⏎ assignment inside a puts/p/pp breaks playground [https://gitter.im/crystal-lang/crystal?at=5d79190d3b1e5e5df1918fbd]

15:57 <FromGitter> <Daniel-Worrall> (https://files.gitter.im/crystal-lang/crystal/tUKO/image.png)

15:57 <FromGitter> <Daniel-Worrall> oops

15:57 <FromGitter> <Daniel-Worrall> think a dupe of https://github.com/crystal-lang/crystal/issues/7091

16:33 <FromGitter> <bew> @asterite i see thanks, missed the early return case 👌

17:23 <FromGitter> <bew> TIL https://carc.in/#/r/7jn9 this is cool

17:23 <FromGitter> <bew> you can declare a top level module from inside some other module

17:23 <FromGitter> <naqvis> how to `xor` value? for example in some languages you can do `^var` to retrieve the value. assuming `v = 5` output would be `-6`

17:25 <FromGitter> <Blacksmoke16> dont you need another value to do it with?

17:26 <FromGitter> <Blacksmoke16> i.e. `5 ^ 12`

17:27 <FromGitter> <naqvis> yeah in that case it works, but how to do `bitwise xor` of same value?

17:27 <FromGitter> <naqvis> or what it called `^x bitwise complement`

17:28 <FromGitter> <bew> ah `~v` iirc

17:28 <FromGitter> <naqvis> aah

17:28 <FromGitter> <Blacksmoke16> wow thats not documented at all

17:28 <FromGitter> <Blacksmoke16> https://crystal-lang.org/api/master/Int.html#~-instance-method

17:28 <FromGitter> <Blacksmoke16> lol

17:28 <FromGitter> <bew> it is https://crystal-lang.org/reference/syntax_and_semantics/operators.html#binary-operators

17:28 <FromGitter> <naqvis> thanks @bew

17:29 <FromGitter> <Blacksmoke16> not in the api docs tho

17:29 <FromGitter> <naqvis> yeah, couldn't find that as well

17:29 <FromGitter> <Blacksmoke16> would make a good doc PR 😉

17:30 <FromGitter> <naqvis> 😆

17:31 <FromGitter> <bew> indeed, no doc, funny it's implemented as `self ^ -1`

17:49 <FromGitter> <Blacksmoke16> heres a question for you @bew

17:51 <FromGitter> <Blacksmoke16> so im working on how to implementing exclusion strategies for the serializer

17:51 <FromGitter> <Blacksmoke16> by default the group/version strategies will be supported

17:52 <FromGitter> <Blacksmoke16> however im thinking how to best implement a way for people to add their own custom strategies

17:54 <FromGitter> <Blacksmoke16> option 1 - have some class like ⏎ ⏎ ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=5d7934b92f93ab5a1546be28]

17:54 <FromGitter> <Blacksmoke16> option 2 - just have people reopen the serialize method and then call `previous_def` ⏎ ⏎ ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=5d7934f2ae44a84124be5682]

17:55 <FromGitter> <Blacksmoke16> (it'll prob be a module in the end vs Object)

17:56 <FromGitter> <Blacksmoke16> i think i like option 2 more, since its easier as you have access to the actual obj being serialized, i.e. ivars/annotations etc

17:57 <FromGitter> <Blacksmoke16> plus can override it on a per obj basis as well

18:58 <FromGitter> <Blacksmoke16> is there a reason why the call doesnt have any location info? https://play.crystal-lang.org/#/r/7jnt \cc @asterite

22:09 <FromGitter> <watzon> `previous_def` is supposed to call the original method right? So if I extend a class and override one of the methods, calling `previous_def` within that method should call the original?

22:10 <FromGitter> <watzon> Maybe I'm misunderstanding what it's for

22:11 <FromGitter> <absolutejam_gitlab> yeah

22:12 <FromGitter> <watzon> Ahh right, it's for monkeypatching

22:12 <FromGitter> <watzon> not extending

22:12 <FromGitter> <absolutejam_gitlab> it's equivalent to `super` in other languages?

22:13 <FromGitter> <absolutejam_gitlab> I'd say it's fine for extending

22:13 <FromGitter> <watzon> https://github.com/crystal-lang/crystal/wiki/Metaprogramming-Help

22:13 <FromGitter> <watzon> It doesn't work for what I'm trying to do

22:14 <FromGitter> <watzon> https://carc.in/#/r/7jo6

22:14 <FromGitter> <watzon> What I need to do is call the method that I'm overloading, but on the other class

22:14 <FromGitter> <watzon> Ideally without creating an instance of the class I'm extending

22:15 <FromGitter> <watzon> I'd think super would work, but it doesn't either https://carc.in/#/r/7jo7

22:36 <FromGitter> <Blacksmoke16> @watzon its just `super`

22:36 <FromGitter> <Blacksmoke16> https://carc.in/#/r/7joa

22:37 <FromGitter> <watzon> Lol well there we go

22:37 <FromGitter> <watzon> Thanks

22:37 <FromGitter> <Blacksmoke16> np