22:28 <FromGitter> <plambert> I have a class like `class Foo(T); end` and I have a method like `def succ(thing : T); thing.responds_to?(:succ) ? thing.succ : thing.responds_to?(:next_float) ? thing.next_float : raise "#{thing}: does not have a succ or next_float method"; end`

22:29 <FromGitter> <plambert> Is it possible to do this with a macro, such that whatever T is, it's figured out at compile time and I'm not evaluating the conditional every time?

22:29 <FromGitter> <plambert> Or does the compiler do that optimization already?

22:30 <FromGitter> <Blacksmoke16> it wouldnt compiler it whatever `T` is doesnt have that method

22:30 <FromGitter> <Blacksmoke16> essentially duck typed

22:31 <FromGitter> <Blacksmoke16> another option would be define like two modules that have one of the methods as abstract defs. then can have a `succ` overload for each

22:31 <FromGitter> <Blacksmoke16> this approach would error because of no valid overload on the method, instead of on the method call within the method

22:33 <FromGitter> <plambert> So I can drop the check for :next_float and just do `thing.responds_to?(:succ) ? thing.succ : thing.next_float` and let the compiler tell me if I pass it something with neither of those methods?

22:34 <FromGitter> <Blacksmoke16> is `thing` going to be a custom type you define?

22:34 <FromGitter> <plambert> No, it's always some sort of Int or Float

22:35 <FromGitter> <Blacksmoke16> oh

22:35 <FromGitter> <Blacksmoke16> ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=62ec49b59d3c186299f4daec]

22:35 <FromGitter> <Blacksmoke16> tada?

22:36 <FromGitter> <plambert> That should do the trick; the compiler will know which to use at compile time, so no performance hit. Yay!

22:36 <FromGitter> <Blacksmoke16> another option would be have a single method but use some macro code to define the body of the method based on `T`

22:37 <FromGitter> <Blacksmoke16> ```code paste, see link``` [https://gitter.im/crystal-lang/crystal?at=62ec4a17443b7927a70a1b40]

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

22:39 <FromGitter> <plambert> I'm trying the first one. Once it works, I'll probably try to move to the second, because I like it better. :)

22:40 <FromGitter> <Blacksmoke16> might have to do like `T < Int`and `elseif T < Float` then an `else` that does like `T.raise "#{@type} only supports Int | Float types"`

22:56 <FromGitter> <plambert> Is there an equivalent of "responds_to?" in macros?

22:56 <FromGitter> <Blacksmoke16> `.has_method?` iirc

23:03 <FromGitter> <Blacksmoke16> 👍

23:04 <FromGitter> <Blacksmoke16> shouldnt really need to use `.has_method?` if you only need to support int and float types, as its define on the base type so you could just base things on the type versus checking for the method