Implement interfaces

[amomchilov]

Interfaces are modules that define abstract methods, which must be implemented by the classes that implement the interface.

Example usage:

module Notifier
  interface!
  
  #: (String) -> void
  abstract def send_notification(message); end
end

class SlackNotifier
  include Notifier
  
  #: (String) -> void
  def send_notification(message)
    # Post to Slack API
  end
end

class EmailNotifier
  include Notifier
  
  #: (String) -> void
  def send_notification(message)
    # Send an email
  end
end

[amomchilov]

• Implement abstract classes #3
• Implement interfaces #2 👈 (View in Graphite)
• Initial README #13
• main

This stack of pull requests is managed by Graphite. Learn more about stacking.

[bitwise-aiden]

Is this a fair comparison when the check include will only include once across the whole run? Wouldn't it be better to create a class, include it then re-include it?

[amomchilov]

Ah, this was me toying with making it so calling abstract lazily does the correct module inclusions in the right places. You probably have multiple abstract methods per class, so I was just curious how repeated attempts to reinclude the same module would work.

[amomchilov]

TODO: follow-up on @vinistock's suggestion to merge these modules into one.

I only had these split because I was moving around which pieces should go where, and that just made it easier during development.

However, this raises a new question. Some people might not want the method_missing? behaviour, and are okay with just hitting NoMethodError instead. In that case, what's the best way to make this behaviour configurable?

#!/usr/bin/ruby

$config = {
  nicer_error_messages_for_abstract_methods: true
}

class YourClass; end

# Approach 1: Conditionally define method
module TypeToolKit
  # Some method needed under all configurations
  def f1; end
  def f2; end
  def f3; end
  
  if $config[:nicer_error_messages_for_abstract_methods]
    def method_missing
      # magic to raise a nicer message for abstract methods
    end
  end
end

YourClass.include(TypeToolKit)

# Approach 2: Unconditionally define method on an optional module
module TypeToolKit
  # Some method needed under all configurations
  def f1; end
  def f2; end
  def f3; end
end

module TypeToolKit::NicerErrorMessages
  def method_missing
    # magic to raise a nicer message for abstract methods
  end
end

YourClass.include(TypeToolKit)
YourClass.include(TypeToolKit::NicerErrorMessages) if $config[:nicer_error_messages_for_abstract_methods]

[amomchilov]

Vini and I paired on this, and these modules can't me combined as much as I thought.

1. TypeToolkit::Interface needs to standalone, because its purpose is to define an included hook that only applies to interfaces, and not any classes that use interfaces
2. DSL and MethodDefRecorder are the only pair that could be combined, but I found it useful to be able to have MethodDefRecorder isolated for testing
3. HasAbstractMethods needs to appear on both an interface and implementers of the interface

This separation does also happen to help with making the method_missing behaviour optional in the future, if we ever want to do that.

[Morriar]

Where is this used?

[amomchilov]

Abstract class methods in the up-stack PR

... which I realize aren't tested.

[Morriar]

The instance method error uses method_name.inspect here, but the class method version (line 23) doesn't. With .inspect, Symbol output includes a : prefix — so you'd get Abstract method #:send_notification was never implemented. which looks odd. Should we be consistent and drop the .inspect?

[amomchilov]

Good eye, I intended to drop the .inspect.

Should test this message, too.

[Morriar]

This will go stale

[amomchilov]

That's fine, I'd rather have the results checked in here than pasted around some random Slack conversations or GitHub gists

[Morriar]

Shouldn't this be under DSL?

[Morriar]

Ah okay I see how DSL gets appended later. Unfortunate.

[amomchilov]

Yeah I guess there's two parts to the DSL. I don't want to pollute your class with the .abstract macro if you don't opt-in with abstract! or interface!