jade-lang 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba543580eec5d50cae2249c010a03f7a56a96f276705b3b87df7f25f06ff8eeb
-  data.tar.gz: 15923caf94302e7326aef6cc8a0e581c349b7b46d54ae4898e6bd8d8529657cf
+  metadata.gz: b73668e7e5ab3a62df195d2f978ffcba2ef69e3a2e578eb084ab56dccfe0770f
+  data.tar.gz: 6d7420d31cf750127e51ad9191ac068231e92b041779ef4927d0e6feea26fd2f
 SHA512:
-  metadata.gz: 3906343d3094e2b9142aebc9324722c584db45dfb0951d6546d917794559a8cb9249d9ff4243bb380dc383932e78b93609455743a9e349ec3b60086450693846
-  data.tar.gz: 841c318dc43aa3e99df702eba6ffda7621b5a8c0f97e9302f2d75ef2149a36bcc19a1287d26a3cef5091c1361508d333a964f9eb70094e30a5791e8c4f8394a9
+  metadata.gz: 0036c6f868f892ff83938bfbf5eda69531d4a4fa11aa1abd27978efafddc936bb64320acd6a181caa0b2f55cccb70957c9ba80aad833584857a4b51dc1083ed1
+  data.tar.gz: 95940e59148590400e15d252ed8bbb4a7a6b67cd3febbc481a8b176fbb373afd2e20069e3a91541af52aafbf510baa6d1c9fb3f5cd2277b76adaff07015a75e8

data/CHANGELOG.md

@@ -4,6 +4,84 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.11.0] - 2026-09-15
+
+### Added
+
+- **An interface method may require an interface of another type.** A method
+  can mention a type variable the interface itself does not name, and say what
+  that variable has to satisfy:
+
+      interface Fetchable(x) with
+        projection : x -> Sel(a) with Selectable(a)
+      end
+
+  `a` is settled where `projection` is called, not where the implementation is
+  picked, so each call site resolves the requirement against its own types and
+  passes that dictionary alongside the one for `x`. Left undeclared, the
+  requirement is inferred from the implementations instead. Declared and
+  inferred are reconciled rather than one overriding the other: an
+  implementation may require what the method declares, and anything beyond it
+  is refused by name.
+
+  Two cases stay refused. A requirement *inferred* on an interface from
+  another module, because a declaration is what travels with the interface and
+  there is no foreign entry to amend — declare it and it works across modules.
+  And a requirement on a variable the method's signature never names, which
+  nothing could satisfy.
+
+### Fixed
+
+- **A bare reference to a zero-arg interface method resolves through its
+  dictionary.** Dictionaries were only ever attached where a method was called
+  or passed as an argument, so a function body that was just `selector` — or
+  `Module.selector` — compiled to that name as a Ruby method and died on the
+  first call. It now reads the enclosing function's dictionary, or is a compile
+  error where none is in scope. Code that was silently broken this way may stop
+  compiling.
+
+## [0.10.1] - 2026-09-11
+
+### Added
+
+- **`Decode.decoder`, the derived decoder as a value.** `Decode.from_json` has
+  always picked a decoder off the return type, but there was no way to name
+  that decoder and hand it to a combinator — every project ended up with a
+  `uuid_decoder` and a `date_decoder` per module, reimplementing an instance
+  that already existed. `Decode.field("on", Decode.decoder)` now resolves the
+  `Decodable` instance from the position the decoder stands in, including
+  derived ones, and a type without an instance is a compile error naming the
+  type.
+
+- **`jade init`.** Writes `jade.json`, which is how every tool that runs
+  outside the app finds your sources, creates the source directory, and adds
+  `.jade/` to a `.gitignore` that has one. It refuses to overwrite an existing
+  manifest rather than discarding a source root and extension list that cannot
+  be recovered from the directory. Until now the first thing a new project met
+  was the error telling it to write that file by hand.
+
+### Fixed
+
+- **A function type printed as `(a) -> b`, which means something else.**
+  `Type::Function#to_s` parenthesised its parameters unconditionally, so
+  `jade q api` printed `List.fold : (List(a), b, (b, a) -> b) -> b`, a
+  signature whose outer parentheses read as a tuple argument. It prints the
+  bare form now, `List(a), b, (b, a -> b) -> b`, which is what the formatter
+  writes and what you can paste back into a file.
+
+  Parentheses around a comma list are a tuple everywhere, and a parameter
+  list is bare. A nested function type keeps parentheses of its own, told
+  apart from a tuple by the arrow inside them. `(Int) -> Int` also parses
+  now, which it did not: one element is not a tuple.
+
+- **A record update that does not fit crashed the compiler.** The unification
+  that closes an update was the one call with no error block, and
+  `State#unify` calls the block unconditionally when unification fails, so a
+  mismatch reached `nil.call` and took the compiler out with a `NoMethodError`
+  naming a line in `state.rb`. Changing a field's type is the usual way in;
+  anything the surrounding code cannot accept arrives the same way. It now
+  reads `This update produces Box(Int), but String was expected`.
+
 ## [0.10.0] - 2026-09-02
 
 ### Breaking

data/README.md

@@ -348,6 +348,7 @@ for us so far.
 A single `jade` binary fronts the toolchain:
 
 ```
+jade init                 # write jade.json and the source directory
 jade check [file...]      # type-check; exits 1 on errors, generates nothing
 jade fmt [-i|-c] [file]   # format .jd source (stdin or file)
 jade lsp                  # language server over stdio (hover, defn, refs, diagnostics)

data/docs/json.md

@@ -61,9 +61,23 @@ DecodeJson::Internal.user('{"name":"Ada"}')
 # => Err(MissingField("age"))
 ```
 
-The struct decoder is `Decode.succeed(User(_, _))` piped through one
-`Decode.required` per field — the `_` placeholders are the constructor's holes,
-filled left to right as each field decodes.
+The struct decoder is `Decode.succeed(User(_, _))` piped through one step per
+field — the `_` placeholders are the constructor's holes, filled left to right
+as each field decodes. `Decode.required` fails on a missing key;
+`Decode.optional` takes what a missing key stands for instead, which is a
+`Maybe` when that is the field's type:
+
+```jade
+Decode.succeed(Note(_, _, _))
+  |> Decode.required("body", Decode.nullable(Decode.string))
+  |> Decode.optional("kind", Decode.string, "note")
+  |> Decode.optional("archived_on", Decode.map(Decode.decoder, Just), Nothing)
+```
+
+A nullable field is a required one: the key has to be there, and `null` is a
+value the decoder admits. Pick the step at the field — once a step has run the
+pipeline holds the constructor's remaining arguments, so nothing downstream
+reaches back into one field.
 
 ## Encoding
 
@@ -146,6 +160,23 @@ end
 Reach for the explicit combinators above when the JSON shape doesn't match the
 struct one-to-one — renamed keys, nested lookups, optional fields.
 
+Those combinators still take derived decoders for the leaves. `Decode.decoder`
+is the instance for whatever type is expected of it, so a hand-built shape can
+be filled with types that already know how to read themselves:
+
+```jade
+def decoder -> Decoder(Movement)
+  Decode.succeed(Movement(_, _, _))
+    |> Decode.and_map(Decode.field("from_id", Decode.decoder))
+    |> Decode.and_map(Decode.field("to_id", Decode.decoder))
+    |> Decode.and_map(Decode.field("occurred_on", Decode.decoder))
+end
+```
+
+Two of those fields are `Uuid` and one is a `Date`; each resolves from the
+position it stands in. A type with no instance is a compile error naming the
+type, not a decoder that fails at runtime.
+
 Derivation reaches through the structural types to their elements, so anything
 built out of encodable parts is itself encodable:
 

data/lib/jade/ast.rb

@@ -77,7 +77,8 @@ module Jade
     define(:ImplementationFunction, :name, :fn)
 
     define(:InterfaceDeclaration, :name, :type_param, :functions)
-    define(:InterfaceFunctionDecl, :name, :type)
+    define(:InterfaceFunctionDecl, :name, :type, :constraints)
+    define(:InterfaceConstraint, :interface, :type_param)
 
     module Pattern
       extend self
@@ -751,7 +752,7 @@ module Jade
     end
 
     def interface_function_decl
-      ->((name, type)) do
+      ->((name, type, constraints)) do
         canonical_name =
           case name.type
           in :identifier then name.value
@@ -761,7 +762,18 @@ module Jade
         InterfaceFunctionDecl[
           canonical_name,
           type,
-          name.range.begin...type.range.end,
+          constraints,
+          name.range.begin...(constraints.last&.range&.end || type.range.end),
+        ]
+      end
+    end
+
+    def interface_constraint
+      ->((name, type_param)) do
+        InterfaceConstraint[
+          name.value,
+          type_param,
+          name.range.begin...type_param.range.end,
         ]
       end
     end

data/lib/jade/cli/init.rb

@@ -0,0 +1,86 @@
+require 'fileutils'
+require 'json'
+
+require 'jade'
+
+module Jade
+  module CLI
+    # Writes the manifest every tool outside the app reads. Without one,
+    # the CLI and the language server have to guess where the sources are,
+    # which is why `Project::NotFound` says to write this file by hand.
+    module Init
+      module_function
+
+      IGNORED = '.jade/'.freeze
+
+      def run(argv)
+        usage if argv.any? { it == '-h' || it == '--help' }
+
+        source_root(argv)
+          .then { [it, File.expand_path(Project::MANIFEST)] }
+          .then { |root, manifest| write(root, manifest) }
+      end
+
+      def write(root, manifest)
+        refuse(manifest) if File.exist?(manifest)
+
+        File.write(manifest, "#{JSON.pretty_generate(config(root))}\n")
+        FileUtils.mkdir_p(root)
+
+        report(root, manifest)
+      end
+
+      # Only what the defaults do not already say. A manifest naming every
+      # setting reads as though each were a decision.
+      def config(root)
+        { 'source_roots' => [root], 'extensions' => [] }
+      end
+
+      def source_root(argv)
+        argv
+          .each_cons(2)
+          .find { |flag, _| flag == '--source-root' }
+          &.last || Project::DEFAULTS[:source_roots].first
+      end
+
+      def refuse(manifest)
+        warn "jade: #{File.basename(manifest)} already exists in #{File.dirname(manifest)}"
+        exit 1
+      end
+
+      def report(root, manifest)
+        puts <<~TXT
+          Wrote #{File.basename(manifest)} and #{root}/.
+
+          Put a module in #{root}/, then:
+
+            jade check              type-check it
+            jade fmt #{root}/x.jd#{' ' * [0, 7 - root.length].max}   format it
+
+          #{gitignore_note}
+        TXT
+      end
+
+      # Build and cache output, which nobody wants in a diff.
+      def gitignore_note
+        path = File.expand_path('.gitignore')
+        return "Add #{IGNORED} to .gitignore." unless File.exist?(path)
+        return "#{IGNORED} is already ignored." if File.read(path).match?(/^\.jade\b/)
+
+        File.write(path, "#{File.read(path).chomp}\n#{IGNORED}\n")
+        "Added #{IGNORED} to .gitignore."
+      end
+
+      def usage
+        warn <<~USAGE
+          Usage: jade init [--source-root DIR]
+
+          Writes jade.json, which is how every tool outside the app finds
+          your sources, and creates the source directory. Refuses to
+          overwrite an existing manifest.
+        USAGE
+        exit 1
+      end
+    end
+  end
+end

data/lib/jade/cli.rb

@@ -6,6 +6,7 @@ module Jade
       'check' => 'Check',
       'eject' => 'Eject',
       'fmt' => 'Fmt',
+      'init' => 'Init',
       'lsp' => 'Lsp',
       'q' => 'Q',
     }.freeze
@@ -40,6 +41,7 @@ module Jade
           check  Type-check the project (or the given files).
           eject  Write the project as Ruby that runs without the gem.
           fmt    Format .jd source (stdin or file).
+          init   Write jade.json and the source directory.
           lsp    Run the language server (stdio JSON-RPC).
           q      Headless query interface (hover/symbols/defn/refs/api).
 

data/lib/jade/codegen/function_call.rb

@@ -16,6 +16,9 @@ module Jade
         Inline.try_for(callee, args, dictionaries, registry)
           .then { return it if it }
 
+        constrained_constant(callee, dictionaries, registry)
+          .then { return it if it }
+
         return constructor_call(callee, args, registry) if constructor_callee?(callee, registry)
 
         [generate_many(args, registry), generate_dict_args(callee, dictionaries, registry)]
@@ -24,6 +27,18 @@ module Jade
           .then { "#{generate_callee(callee, args, registry, dictionaries)}#{invocation_op(callee, registry)}(#{it})" }
       end
 
+      # A constrained constant — `Decode.decoder` — has no parameters, so its
+      # dictionary slot holds the value itself rather than something to call.
+      # generate_callee already produced that value; invoking it would be
+      # calling a Decoder.
+      def constrained_constant(callee, dictionaries, registry)
+        symbol = resolve_callee_symbol(callee, registry)
+        return nil unless symbol.is_a?(Symbol::StdlibFunction)
+        return nil unless symbol.params.empty? && symbol.constraints.any?
+
+        generate_callee(callee, [], registry, dictionaries)
+      end
+
       def constructor_call(callee, args, registry)
         resolve_callee_symbol(callee, registry)
           .then { "::#{to_qualified(it.qualified_name)}" }
@@ -231,15 +246,6 @@ module Jade
         end
       end
 
-      # When a user fn has var-typed constraints, two definitions are emitted:
-      # `name` (Ruby-boundary wrapper, no dicts) and `__name__impl__` (takes
-      # dicts). Jade-internal calls target the latter.
-      def fn_target_name(fn_sym, registry)
-        return fn_sym.name if dict_constraints(fn_sym, registry).empty?
-
-        fn_impl_synthetic_name(fn_sym.name)
-      end
-
       # Returns the list of dict args to pass after regular args. Only
       # Symbol::Function callees take dict params; other branches dispatch
       # via `dictionaries` directly inside generate_callee. dictionaries are
@@ -252,6 +258,7 @@ module Jade
           else callee.symbol
           end
 
+        return interface_dict_args(symbol, dictionaries, registry) if symbol.is_a?(Symbol::InterfaceFunction)
         return "" unless symbol.is_a?(Symbol::Function)
 
         fn_constraints(symbol, registry)
@@ -260,6 +267,14 @@ module Jade
           .join(', ')
       end
 
+      def interface_dict_args(_symbol, dictionaries, registry)
+        dictionaries
+          .drop(1)
+          .compact
+          .filter_map { dispatch_value(it, registry) }
+          .join(', ')
+      end
+
       # Ruby-block intrinsics (Dict's `Eq k`, etc.) ignore dispatches — the
       # `in String` body of `generate_impl_fn` drops them.
       def dispatch_dict(entry, registry)
@@ -341,7 +356,7 @@ module Jade
           "#{internal(fn.module_name)}.#{fn.name}"
 
         in Symbol::Function => fn
-          "#{internal(fn.module_name)}.method(:#{fn.name})"
+          "#{internal(fn.module_name)}.method(:#{fn_target_name(fn, registry)})"
         end
       end
 

data/lib/jade/codegen/function_declaration.rb

@@ -34,10 +34,9 @@ module Jade
 
         var_cs      = dict_constraints(symbol, registry)
         param_names = params.map { generate_node(it, registry) }
-        dict_params = var_cs.each_index.map { dict_synthetic_name(it) }
 
-        body_code = build_dict_env(var_cs)
-          .then { Codegen.with_dict_env(it) { emit_body(body, symbol, param_names, registry) } }
+        dict_params, body_code =
+          with_dict_params(var_cs) { emit_body(body, symbol, param_names, registry) }
 
         target  = var_cs.empty? ? name : fn_impl_synthetic_name(name)
         sig     = (param_names + dict_params).join(', ')
@@ -200,13 +199,6 @@ module Jade
           .then { it.substitution.apply(it.bindings[symbol.qualified_name].type) }
       end
 
-      def build_dict_env(var_cs)
-        var_cs
-          .each_with_index
-          .reduce({}) do |env, (c, i)|
-            env.merge([c.interface, c.type.id] => dict_synthetic_name(i))
-          end
-      end
     end
   end
 end

data/lib/jade/codegen/helpers.rb

@@ -74,6 +74,48 @@ module Jade
           .then { "__#{it}__impl__" }
       end
 
+      def fn_target_name(fn_sym, registry)
+        return fn_sym.name if dict_constraints(fn_sym, registry).empty?
+
+        fn_impl_synthetic_name(fn_sym.name)
+      end
+
+      def with_dict_params(constraints)
+        constraints
+          .each_with_index
+          .to_h { |c, i| [[c.interface, c.type.id], dict_synthetic_name(i)] }
+          .then { |env| Codegen.with_dict_env(env) { yield } }
+          .then { |body| [constraints.each_index.map { dict_synthetic_name(it) }, body] }
+      end
+
+      def body_markers(node)
+        return [] unless node.is_a?(AST::Node)
+
+        node
+          .deconstruct_keys(nil)
+          .each_value
+          .flat_map { marker_children(it) }
+          .flat_map { body_markers(it) }
+          .then { own_markers(node) + it }
+      end
+
+      def own_markers(node)
+        return [] unless node.respond_to?(:dictionaries)
+
+        node
+          .dictionaries
+          .select { it.is_a?(Type::Constraint) && it.type.is_a?(Type::Var) }
+      end
+
+      def marker_children(value)
+        case value
+        in Array then value.flat_map { marker_children(it) }
+        in Hash then value.each_value.flat_map { marker_children(it) }
+        in AST::Node then [value]
+        else []
+        end
+      end
+
       def fn_constraints(fn_symbol, registry)
         env = registry.get(fn_symbol.module_name).env
 

data/lib/jade/codegen/implementation.rb

@@ -106,7 +106,7 @@ module Jade
       end
 
       def generate_defs(node, registry)
-        node => AST::Implementation(interface:, applied_type:, functions:)
+        node => AST::Implementation(interface:, applied_type:, functions:, symbol:)
 
         type_name =
           case applied_type.constructor
@@ -115,7 +115,7 @@ module Jade
           end
 
         functions
-          .filter_map { generate_function(it, registry, interface, type_name) }
+          .filter_map { generate_function(it, registry, interface, type_name, symbol) }
           .join(Pretty.newline(2))
       end
 
@@ -143,7 +143,7 @@ module Jade
         fn_map = symbol.functions.filter_map { |fn_name, ref|
           next unless ref.is_a?(Symbol::ValueRef)
 
-          [fn_name, "->(*args) { #{internal(ref.module_name)}.#{ref.name}(*args) }"]
+          [fn_name, "->(*args) { #{internal(ref.module_name)}.#{registered_target(ref, registry)}(*args) }"]
         }.to_h
 
         return "" if fn_map.empty?
@@ -155,16 +155,41 @@ module Jade
           .join(Pretty.newline)
       end
 
-      def generate_function(impl_fn, registry, interface, type_name)
+      def requirement_markers(body, impl_sym, fn_name, registry)
+        required = registry
+          .lookup(impl_sym.interface)
+          .functions
+          .find { it.name == fn_name }
+          .constraints
+
+        return [] if required.empty?
+
+        body_markers(body)
+          .uniq { [it.interface, it.type.id] }
+          .sort_by { |c| required.index { |iface, _| iface == c.interface } || required.size }
+      end
+
+      def registered_target(ref, registry)
+        case registry.lookup(ref)
+        in Symbol::Function => fn then FunctionCall.fn_target_name(fn, registry)
+        else ref.name
+        end
+      end
+
+      def generate_function(impl_fn, registry, interface, type_name, impl_sym)
         impl_fn => AST::ImplementationFunction(name: fn_name, fn:)
 
         case fn
         in AST::Lambda(params:, body:)
-          synth     = impl_synthetic_name(interface, type_name, fn_name)
-          param_str = params.map { generate_node(it, registry) }.join(', ')
-          sig       = param_str.empty? ? '' : "(#{param_str})"
+          synth = impl_synthetic_name(interface, type_name, fn_name)
+
+          dicts, body_code = requirement_markers(body, impl_sym, fn_name, registry)
+            .then { with_dict_params(it) { generate_node(body, registry) } }
 
-          Pretty.block("def #{synth}#{sig}", generate_node(body, registry))
+          (params.map { generate_node(it, registry) } + dicts)
+            .join(', ')
+            .then { it.empty? ? '' : "(#{it})" }
+            .then { Pretty.block("def #{synth}#{it}", body_code) }
 
         # Bare VariableReference, and the auto-invoke FunctionCall the
         # desugar pass synthesises for zero-arg fn refs, both dispatch via

data/lib/jade/formatter/leaves.rb

@@ -113,7 +113,18 @@ module Jade
       extend Helper
 
       def format(node, indent:, source:)
-        "#{node.name} : #{format_type(node.type)}".then(&and_indent(indent))
+        "#{node.name} : #{format_type(node.type)}#{constraints_clause(node)}"
+          .then(&and_indent(indent))
+      end
+
+      def constraints_clause(node)
+        return '' if node.constraints.empty?
+
+        node
+          .constraints
+          .map { "#{it.interface}(#{it.type_param.name})" }
+          .join(', ')
+          .then { " with #{it}" }
       end
     end
   end

data/lib/jade/formatter/type.rb

@@ -26,11 +26,9 @@ module Jade
           end
 
         in AST::TypeFunction(params:, return_type:)
-          params_str = params.empty? ?
-            "()" :
-            params.map { format_atom(it) }.join(', ')
-
-          "#{params_str} -> #{format_atom(return_type)}"
+          params
+            .then { it.empty? ? '()' : it.map { |p| format_atom(p) }.join(', ') }
+            .then { "#{it} -> #{format_atom(return_type)}" }
 
         in AST::TypeRecord(fields:, row_var:)
           fields_str = fields.map { |k, v| "#{k}: #{format(v)}" }.join(", ")

data/lib/jade/frontend/forward_declaration/interface_declaration.rb

@@ -50,10 +50,14 @@ module Jade
         private
 
         def build_interface_function(entry, interface_ref, fn_decl)
-          fn_decl => AST::InterfaceFunctionDecl(name:, type:, range:)
+          fn_decl => AST::InterfaceFunctionDecl(name:, type:, constraints:, range:)
 
           figure_out_type(entry, type)
-            .map do |type_symbol|
+            .and_then do |type_symbol|
+              declared_constraints(entry, constraints)
+                .map { [type_symbol, it] }
+            end
+            .map do |(type_symbol, declared)|
               params, return_type =
                 case type_symbol
                 in Symbol::FunctionType(params:, return_type:)
@@ -63,9 +67,18 @@ module Jade
                 end
 
               Symbol
-                .interface_function(name, interface_ref, params, return_type, range)
+                .interface_function(name, interface_ref, params, return_type, range, declared)
             end
         end
+
+        def declared_constraints(entry, constraints)
+          constraints
+            .map do |constraint|
+              require_type(entry, constraint.interface, constraint.range)
+                .map { [it.to_ref.qualified_name, constraint.type_param.name] }
+            end
+            .then { Results.sequence(it) }
+        end
       end
     end
   end

data/lib/jade/frontend/type_checking/error/cross_module_requirement.rb

@@ -0,0 +1,36 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class CrossModuleRequirement < Jade::Error
+          def initialize(entry, span, interface:, fn_name:, constraint:)
+            super(entry:, span:)
+            @interface  = interface
+            @fn_name    = fn_name
+            @constraint = constraint
+          end
+
+          def message
+            "Implementation of #{@interface}.#{@fn_name} requires #{@constraint}, " \
+              "but #{@interface} is declared in another module. A requirement " \
+              'can only be added to an interface this module declares'
+          end
+
+          def label
+            "requires #{@constraint}"
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :help,
+                'give the function a concrete type for that parameter, or move ' \
+                  'the implementation into the module that declares the interface',
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jade/frontend/type_checking/error/implementation_function_constraint.rb

@@ -0,0 +1,36 @@
+module Jade
+  module Frontend
+    module TypeChecking
+      module Error
+        class ImplementationFunctionConstraint < Jade::Error
+          def initialize(entry, span, interface:, fn_name:, constraint:)
+            super(entry:, span:)
+            @interface  = interface
+            @fn_name    = fn_name
+            @constraint = constraint
+          end
+
+          def message
+            "Implementation of #{@interface}.#{@fn_name} requires #{@constraint}, " \
+              'whose type is not the one being implemented. An implementation ' \
+              'can only require interfaces of the type it implements'
+          end
+
+          def label
+            "requires #{@constraint}"
+          end
+
+          def notes
+            [
+              Jade::Diagnostics::Annotation[
+                :help,
+                'give the function a concrete type for that parameter, or move ' \
+                  'the requirement onto the type being implemented',
+              ],
+            ]
+          end
+        end
+      end
+    end
+  end
+end