Initial implementation (#1)

Author: mtfishman

src/BackendSelection.jl

@@ -1,5 +1,6 @@
 module BackendSelection
 
-# Write your package code here.
+include("abstractbackend.jl")
+include("backend_types.jl")
 
 end

src/abstractbackend.jl

@@ -0,0 +1,4 @@
+abstract type AbstractBackend end
+
+backend_string(::AbstractBackend) = error("Not implemented")
+parameters(::AbstractBackend) = error("Not implemented")

src/backend_types.jl

@@ -0,0 +1,73 @@
+macro generate_backend_type(type::Symbol)
+  return generate_backend_type_expr(type)
+end
+
+function generate_backend_type_expr(type::Symbol)
+  return esc(
+    quote
+      """
+          $($type)
+
+      A type representing a backend for a function.
+
+      For example, a function might have multiple backends
+      implementations, which internally are selected with a `$($type)` type.
+
+      This allows users to extend functionality with a new implementation but
+      use the same interface.
+      """
+      struct $type{Back,Kwargs<:NamedTuple} <: AbstractBackend
+        kwargs::Kwargs
+      end
+
+      $type{Back}(kwargs::NamedTuple) where {Back} = $type{Back,typeof(kwargs)}(kwargs)
+      $type{Back}(; kwargs...) where {Back} = $type{Back}(NamedTuple(kwargs))
+      $type(s; kwargs...) = $type{Symbol(s)}(NamedTuple(kwargs))
+
+      $type(backend::$type) = backend
+
+      # TODO: Use `SetParameters`.
+      backend_string(::$type{Back}) where {Back} = string(Back)
+      parameters(backend::$type) = getfield(backend, :kwargs)
+
+      Base.getproperty(backend::$type, name::Symbol) = parameters(backend)[name]
+      Base.propertynames(backend::$type) = propertynames(parameters(backend))
+
+      function Base.show(io::IO, backend::$type)
+        return print(
+          io, "$($type) type ", backend_string(backend), ", ", parameters(backend)
+        )
+      end
+      function Base.print(io::IO, backend::$type)
+        return print(io, backend_string(backend), ", ", parameters(backend))
+      end
+    end,
+  )
+end
+
+@generate_backend_type Algorithm
+@generate_backend_type Backend
+
+function backend_macro_docstring(backend)
+  return """
+      @$(backend)_str
+
+  A convenience macro for writing [`$backend`](@ref) types, typically used when
+  adding methods to a function that supports multiple backends.
+  """
+end
+
+# TODO: See if these can be moved inside of `@eval`.
+"""
+$(backend_macro_docstring(:Algorithm))
+"""
+macro Algorithm_str(s)
+  return :(Algorithm{$(Expr(:quote, Symbol(s)))})
+end
+
+"""
+$(backend_macro_docstring(:Backend))
+"""
+macro Backend_str(s)
+  return :(Backend{$(Expr(:quote, Symbol(s)))})
+end

test/test_basics.jl

@@ -1,6 +1,24 @@
-using BackendSelection: BackendSelection
+using BackendSelection: BackendSelection, @Algorithm_str, @Backend_str, Algorithm, Backend
 using Test: @test, @testset
 
 @testset "BackendSelection" begin
-  # Tests go here.
+  for type in (Algorithm, Backend)
+    @testset "$type" begin
+      @test type("backend") isa type{:backend}
+      @test type(:backend) isa type{:backend}
+      backend = type("backend"; x=2, y=3)
+      @test backend isa type{:backend}
+      @test backend.x == 2
+      @test backend.y == 3
+      @test propertynames(backend) == (:x, :y)
+      (; x, y) = backend
+      @test x == 2
+      @test y == 3
+      @test BackendSelection.parameters(backend) === (; x=2, y=3)
+    end
+  end
+  # Macro syntax.
+  @test Algorithm"backend"(; x=2, y=3) === Algorithm("backend"; x=2, y=3)
+  @test Backend"backend"(; x=2, y=3) === Backend("backend"; x=2, y=3)
+  @test isnothing(show(Algorithm("")))
 end