04:12 <FromGitter> <paulcsmith> Does anyone know how to create a Proc/block that doesn't return? This works but is quite verbose: https://play.crystal-lang.org/#/r/6ft6

04:12 <FromGitter> <paulcsmith> Is there a way to either change the type signature or some way to create a proc that returns void that doesn't require so much verbosity. I was hoping I could change the type to `-> Nil` or `-> _` but that doesn't seem to work

06:21 <FromGitter> <HarrisonB> What's the reason that proc instantiation creates closure,s but method definitions do not? E.g. https://play.crystal-lang.org/#/r/6fu0 fails to compile, but https://play.crystal-lang.org/#/r/6ftz succeeds. I read the closure section in the guide but i'm not seeing an explanation

08:30 <FromGitter> <bew> @paulcsmith indeed it's not easy or not nice.. Could still do this though https://play.crystal-lang.org/#/r/6fuu

08:33 <FromGitter> <bew> @HarrisonB I don't remember it being explained, I guess you could see it as procs can be created on the fly, with values from around your context, they can also be captured for a block (the method get a proc that closures variables around its call)

08:33 <FromGitter> <bew> Methods are more static, can't be created on the fly

10:16 <FromGitter> <straight-shoota> @HarrisonB A method can never create a closure because it's scope is not statically connected to the surrounding scope. Your example *could* however work with global variables and it would essentially be the same as a closure (but technically different). Yet, in Crystal we decided not to have global variables to reduce complexity and possibly surprising side effects. So `foo` is just a local variable in

10:16 <FromGitter> ... the top level scope. It's accessible from within a block because it's declared in the same scope, but not from method scope.

12:53 <FromGitter> <Sija> @paulcsmith see https://github.com/crystal-lang/crystal/issues/7306#issuecomment-453828089

13:53 <jokke> there's also each.with_index :)

13:55 <FromGitter> <paulcsmith> @bew very clever! Thanks for sharing!

13:56 <FromGitter> <bew> You're welcome :) But I agree it would be nice to be able to put `->` as a restriction, and be able to pass `->{ p "foo" }` without type errors

13:58 <FromGitter> <paulcsmith> Yeah it’s kind of confusing because a type restriction of Nil on a regular method is basically Void. So even if you return an Int it’ll work. But if you put return type of Nil on a prod you have to actually return Nil which is unexpected

13:59 <FromGitter> <paulcsmith> I’ll probably create an issue because being able to restrict return type to Nil or Void and work like regular methods would be more intuitive and make it easier to use procs . As they are now it’s cumbersome so I avoid using them which is too bad. It’s a super nice feature

14:00 <FromGitter> <bew> Oh that's right, forgot about that behavior for normal methods, yeah totally agree with you!

15:23 <FromGitter> <HarrisonB> Thanks @bew & @straight-shoota !

18:07 <sagax> hi all!

18:08 <sagax> we have some `awesome-crystal` with list modules, plugins, etc...

18:08 <sagax> ?

18:08 <FromGitter> <bew> Yes

18:09 <FromGitter> <Blacksmoke16> https://github.com/veelenga/awesome-crystal

19:00 <FromGitter> <Prutheus> Hello. I am on Ubuntu Server. I am using selenium-webdriver, on my macbook following code works well: ⏎ ⏎ ` ⏎ ⏎ ```code paste, see link``` ... [https://gitter.im/crystal-lang/crystal?at=5c816a33e527821f0a1e5a32]

19:00 <FromGitter> <Prutheus> why happens that error? o.O

19:03 <FromGitter> <Prutheus> Can please someone help me … I need to fix that asap

19:06 <FromGitter> <Prutheus> how can this happen? Cannot define class using reflection

19:23 <z64> thats an error from selenium's API it looks like. if you google that error message, you can find some cases of other users getting it, but i don't know anything about selenium to derive what the issue might be

19:26 <FromGitter> <Prutheus> okay thans

19:39 <FromGitter> <HCLarsen> Hey folks, haven't been at this in a while, can someone remind me how to see the code generated by my macro? I remember there's a debug keyword, I just don't remember how to use it.

19:42 <z64> {% debug %} ; https://carc.in/#/cr

19:42 <z64> * https://carc.in/#/r/6g1w

19:43 <FromGitter> <HCLarsen> Thanks.

19:43 <z64> yw

23:33 <FromGitter> <vladfaust> Not sure if it is a dirty hack or not, but `Type | _` restriction looks powerful and works in my case 💪 ⏎ ⏎ ```def get(path, &proc : ::HTTP::Server::Context -> View | _)``` [https://gitter.im/crystal-lang/crystal?at=5c81aa588f294b134a069b83]

23:35 <FromGitter> <vladfaust> cc @paulcsmith

23:36 <FromGitter> <dscottboggs_gitlab> what's the advantage of that over `-> _` ?

23:40 <FromGitter> <vladfaust> None, I guess :thinking:

23:41 <FromGitter> <dscottboggs_gitlab> I mean, it's definitely super powerful. Generics in crystal are awesome

23:41 <FromGitter> <dscottboggs_gitlab> There's also ` -> View | T forall T`

23:42 <robacarp> I _do not_ get forall T

23:43 <robacarp> the docs just did not land for me on that one

23:44 <FromGitter> <vladfaust> You can understand it as a separate method is generated for every argument type used in the program ⏎ ⏎ ```def foo(bar : T) forall T ⏎ end ⏎ ⏎ foo("bar") ⏎ foo(42)``` ⏎ ⏎ Two methods in this case [https://gitter.im/crystal-lang/crystal?at=5c81ace5f895944c085a611d]

23:45 <FromGitter> <vladfaust> And the T can be access in macro

23:46 <FromGitter> <dscottboggs_gitlab> interesting... I always thought of it as just generic functions... is it not?

23:46 <robacarp> what's the benefit to doing that vs just leaving it untyped

23:46 <FromGitter> <dscottboggs_gitlab> back in a few

23:46 <FromGitter> <vladfaust> @dscottboggs_gitlab I don't know how it is inside. But it can be *understood* as I described

23:47 <FromGitter> <vladfaust> @robacarp oh so many cases. Knowing `T` in macros is super-useful

23:47 <robacarp> okay, so the use case is that you know T pre-compile time

23:48 <robacarp> I've been wanting to enforce duck-typing at the method level, will this allow that sort of thing with some macro manipulation?

23:49 <FromGitter> <vladfaust> Yeah, `T` is fully known at this moment. You can do `.has_method?`, for example

23:50 <FromGitter> <vladfaust> Also *annotations* ✨

23:50 <robacarp> I've been dreaming about something like this: `def method(arg : #duck_typed)`

23:50 <FromGitter> <vladfaust> Nope

23:50 <FromGitter> <vladfaust> With modules, may be

23:51 <robacarp> well, for example maybe I want it to respond to #to_i, and any object which can be converted to an Int is acceptable

23:51 <robacarp> it gets complicated quick

23:52 <robacarp> when you leave the types off of an interface, the stack traces become really intractable to the next developer

23:52 <robacarp> my goal is really to reduce that, so the developer has some idea what they did wrong and how to fix it

23:54 <robacarp> especially because so often the method isn't actually called on the passed-in-object until several calls down the stack

23:57 <FromGitter> <dscottboggs_gitlab> > *<robacarp>* my goal is really to reduce that, so the developer has some idea what they did wrong and how to fix it ⏎ ⏎ that would be really nice

23:59 <FromGitter> <dscottboggs_gitlab> I use `forall` with blocks a lot to annotate that the block return value is returned from the method, like ⏎ ⏎ ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=5c81b06a25e4e24c0731efce]