11:21 <FromGitter> <Dan-Do> I have a GC statistic like this ⏎ ⏎ ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=61a214b7b5ba9e5a11da6635]

11:21 <FromGitter> <Dan-Do> Is it high in the `@total_bytes`?

13:55 <SamantazFox> <paulocoghi> "Is LibreSSl ready for Quic?" <- no. None of the major SSL libraries have planned to support QUIC yet. that's why there is a plethora of forks like BoringSSL, quictls/openssl, and others, on which QUIC libraries rely.

13:57 <SamantazFox> Also, OpenSSL has plans for the future (understand, in a long time, they haven't finished the 3.0 migration yet) where they would implement a complete QUIC client, rather than just a crypto API for QUIC.

14:47 <postmodern> how would you define a class that accepts an optional generic type? would you pass in Nil or something?

15:13 <FromGitter> <Dan-Do> You can look at `Slice(T)`, we can use `Slice` (without T)

15:13 <FromGitter> <Blacksmoke16> you cant have an optional generic type, best bet would be to define the common logic in a module/parent class and have generic and non-generic implementation

15:17 <FromGitter> <christopherzimmerman> @Dan-Do you can only do that in cases where the generic type can be implied. It’s not optional.

15:18 <FromGitter> <Dan-Do> Yeah 👍

15:41 <postmodern> good to know!

15:41 <postmodern> so why does String lack `#swapcase`?

15:45 <postmodern> hmm also i wish the compiler was smart enough to handle block type invariants. compiler is complaining that i'm passing `Proc(String,String)` where `&block : Proc(String,String) | Proc(Nil,String) | Nil` is accepted

15:49 <postmodern> also find it odd that String#sub(string,&block) doesn't define the signature of &block

15:52 <yxhuvud> postmodern: You need to upcast in that case, `proc.as(Proc(String,String) | Proc(Nil,String) | Nil)` or something like that. But you may want to do something to size down that union type, as that trinary choice is not very nice.

15:54 <postmodern> yxhuvud, i'm trying to caputre the combined type signature of blocks passed to String#sub.

15:54 <postmodern> appears you can do "str".sub(pattern) { replace }

15:54 <postmodern> and "str".sub(pattern) { |match| match + replace }

16:00 <yxhuvud> passing a union type involving nil looks weird though, as I don't see how a method with &block can ever not get a block passed

16:01 <yxhuvud> the sub variants seems to be a jungle though, not going to dig deep into that now.

16:02 <postmodern> hmm `.as()` it isn't working `expected a function type, not (Proc(String) | Proc(String, String) | Nil)`

16:04 <postmodern> you are right about the `| Nil`, since i'm also using overloading for a method that accepts `(pattern : String, replace : String)` and `(pattern : String, &block : Proc(String,String) | Proc(String))`

16:05 <yxhuvud> any call without a block probably calls another of the 4711 different sub signatures

16:20 <postmodern> ah it seems i can't do `&@block : Proc(...)`

16:24 <postmodern> hmm no, that's not it

17:12 <FromGitter> <naqvis> just found an interesting finding that `Free Variables` take precedence over `No Annotation` ⏎ https://carc.in/#/r/ccoc

18:46 <postmodern> what does `Error: expected block type to be a function type, not (Proc(String) | Proc(String, String))` exactly mean? I am trying to & pass a literal ->(match) { ... } object to a method's &block

18:47 <postmodern> oh wait, do i have to define override methods for each type of &block ?

18:49 <postmodern> hmm compiler gets confused by block argument arity if i do that

18:51 <FromGitter> <Blacksmoke16> can you make a playground link?

19:21 <postmodern> will have to reduce my code down to a minimal example

20:03 <FromGitter> <naqvis> postmodern: you can’t type restrict block param with Proc union. You will have to define overload method

20:07 <postmodern> naqvis, i tried defining overrides, but then the compiler complained about block arity (giving 1, expected 0). do you have any advice for that?

20:13 <FromGitter> <naqvis> type restrict block param

20:14 <FromGitter> <naqvis> def test(&block : Proc1)

20:15 <FromGitter> <naqvis> def test(&block : Proc2)

20:16 <FromGitter> <naqvis> block without type restriction is treated as arity 0

22:38 <postmodern> i have things like (String -> String) for Proc1 and (-> String) for Proc2. Not sure if that's the proper syntax?

22:39 <FromGitter> <Blacksmoke16> the first yields and returns a string, the second doesnt yield anything but returns a string

22:40 <postmodern> i should write up that self-contained example for carcin