specify supertype in interface macro (#31)

* specify type in interface macro

* bugfix

* cleanup

Author: rafaqz

src/implements.jl

@@ -56,6 +56,10 @@ function _implements_inner(interface, objtype; show=false)
         optional_keys = ()
     end
     quote
+        # Chreck that the type matches
+        let objtype = $objtype, interface=$interface
+            objtype <: Interfaces.requiredtype(interface) || throw(ArgumentError("$objtype is not a subtype of $(Interfaces.requiredtype(interface))"))  
+        end
         # Define a `implements` trait stating that `objtype` implements `interface`
         $Interfaces.implements(::Type{<:$interfacetype}, ::Type{<:$objtype}) = true
         $Interfaces.implements(T::Type{<:$interfacetype{Options}}, O::Type{<:$objtype}) where Options = 

src/interface.jl

@@ -35,10 +35,17 @@ Returns the components of the interface, as a `NamedTuple` of `NamedTuple`.
 """
 function components end
 
+"""
+    requiredtype(::Type{<:Interface})
+
+Returns the supertype required for all interface implementations.
+"""
+function requiredtype end
+
 """
 @interface(interfacename, components, [description])
 
-Define an interface.
+Define an interface that can apply to types `<: Any`.
 
 ```julia
 components = (
@@ -50,17 +57,19 @@ components = (
 )
 description = "A description of the interface"
 
-@interface MyInterface components description
+@interface MyInterface Any components description
 ```
 """
-macro interface(interface::Symbol, components, description)
+macro interface(interface::Symbol, type, components, description)
     quote
+        @assert $type isa Type
+        @assert $components isa NamedTuple{(:mandatory,:optional)}
+        @assert $description isa String
         # Define the interface type (should it be concrete?)
         abstract type $interface{Components} <: $Interfaces.Interface{Components} end
         # Define the interface component methods
-        @assert $components isa NamedTuple{(:mandatory,:optional)}
+        $Interfaces.requiredtype(::Type{<:$interface}) = $type
         $Interfaces.components(::Type{<:$interface}) = $components
-        @assert $description isa String
         $Interfaces.description(::Type{<:$interface}) = $description
         # Generate a docstring for the interface
         let description=$description,

src/test.jl

@@ -52,6 +52,8 @@ test(T::Type{<:Interface}, obj; kw...) = test(T, typeof(obj), (obj,); kw...)
 function _test(T::Type{<:Interface}, O::Type, objs::TestObjectWrapper;
     show=true, keys=nothing
 )
+
+    O <: requiredtype(T) || throw(ArgumentError("$O is not a subtype of $(requiredtype(T))"))  
     check_coherent_types(O, objs)
     if show
         print("Testing ")

test/advanced.jl

@@ -29,7 +29,7 @@ function neutral end
 function multiplication end
 function inversion end
 
-@interface GroupInterface (
+@interface GroupInterface Number (
     mandatory = (;
         neutral_check = (
             "neutral stable" => a::Arguments -> neutral(typeof(a.x)) isa typeof(a.x),

test/basic.jl

@@ -19,6 +19,8 @@ module Animals
 
 using Interfaces
 
+abstract type Animal end
+
 function age end
 function walk end
 function talk end
@@ -42,7 +44,7 @@ description = """
 Defines a generic interface for animals to do the things they do best.
 """
 
-@interface AnimalInterface components description
+@interface AnimalInterface Animal components description
 
 end;
 
@@ -52,7 +54,7 @@ using Interfaces
 
 # Now we implement the `AnimalInterface`, for a `Duck`.
 
-struct Duck
+struct Duck <: Animals.Animal
     age::Int
 end
 
@@ -80,7 +82,7 @@ The `@implements` macro takes two arguments.
 @implements Animals.AnimalInterface{(:walk,:talk)} Duck
 
 # Now let's see what happens when the interface is not correctly implemented.
-struct Chicken end
+struct Chicken <: Animals.Animal end
 
 # As expected, the tests fail
 chickens = [Chicken()]