Type restriction a : ModFoo & ModBar

[bew]

Didn't find another issue about that except #1839 (comment)

I think there's no easy way to do that atm, I'd like to restrict my argument to have ModFoo AND ModBar as in:

module ModFoo
  abstract def foo
end

module ModBar
  abstract def bar
end

class FooBar
  include ModFoo
  include ModBar
  def foo; end
  def bar; end
end

class OnlyFoo
  include ModFoo
  def foo; end
end

# The argument should have ModFoo AND ModBar
def need_foo_and_bar(param : ModFoo & ModBar)
  puts param.foo
  puts param.bar
end

need_foo_and_bar(FooBar.new)  # should work
need_foo_and_bar(OnlyFoo.new) # should fail

I know it's not currently possible as is, but has it been considered at some point?

How can I restrict the param without 'workaround' like creating a module that include both, and include that module in all classes that include both (e.g: found using some macro-fu). Or using forall & macro checks at beginning of the method (see #7534 (comment))

I know I could simply not restrict the param and rely on the compiler telling the user that the given arg doesn't have method foo or bar. But what if those methods are generated, the user doesn't necessarily know where they come from and what to do (include some module) to be able to pass their object.

[konovod]

Madskillz, but if you really need to restrict with both you can do something like this:

private def need_foo_and_bar_impl(param : ModBar)
  puts param.foo
  puts param.bar
end

# The argument should have ModFoo AND ModBar
def need_foo_and_bar(param : ModFoo)
  need_foo_and_bar_impl(param)
end

https://carc.in/#/r/6gqk

[bew]

@konovod THAT is a fun workaround 😄

Actually I've found another one: https://carc.in/#/r/6gs1

# The argument should have ModFoo AND ModBar
def need_foo_and_bar(param : T) forall T
  {% unless T < ModFoo && T < ModBar %}
    {% raise "nop!" %}
  {% end %}
  puts param.foo
  puts param.bar
end

But I don't have any trace now..

[straight-shoota]

Also an option: typeof(param_bar : ModBar = param)

[bew]

Also an option: typeof(param_bar : ModBar = param)

What do you mean? An option for a workaround? or for a way to restrict the param?
Also how would I use it for the need_foo_and_bar example?

[straight-shoota]

As a workaround.

# The argument should have ModFoo AND ModBar
def need_foo_and_bar(param : ModFoo)
  typeof(param_bar : ModBar = param)
  param.foo
  param.bar
end

https://carc.in/#/r/6gsb

[HertzDevil]

Related: #2404