feat(report): write section about extend statement

report/chapters/03_theory.typ

@@ -121,7 +121,7 @@ A more detailed definition of the syntax is available in @app:midas-syntax.
 Some elements are worth explaining here. Midas offers four base statements through four keywords: `alias`, `type`, `extend` and `predicate`.\
 The first is rather straightforward: ```midas alias X = T``` defines an alias named `X` for the type `T`.\
 The second is a simple subtype definition. ```midas type X = T``` is similar to an alias, but it creates a subtype relationship instead of an equivalence. `X` is thus a subtype of `T`. This also allows defining generic types using type parameters, bounded or not, which can be referenced in the right-hand side of the definition. For example ```midas type Foo[T <: U] = list[T]``` defines a type generic `Foo` with one parameter `T` subtype of `U`, which is a subtype of `list[T]`.\
-The third, `extend`, is linked to a subtype definition. It allows users to define members on a type, such as properties/attributes (`prop`) and methods (`def`). Methods may be overloaded to combine multiple signatures under the same name. The type specific after `extend` must obviously be defined.\
+The third, `extend`, is linked to a subtype definition. It allows users to define members on a type, such as properties/attributes (`prop`) and methods (`def`). Methods may be overloaded to combine multiple signatures under the same name. The type specified after `extend` must obviously be defined.\
 The last kind of statement provides user with a way to define named constraint expressions and reuse them as functions in other constraint expressions. Predicates are defined like functions, with a list of parameters. This list may be split into multiple parameter specifications, for example ```midas predicate foo(a: float)(b: int) = a < b``` to allow partial application.
 
 A particularity of Midas are its constraint types. A constraint type `T where e` is built from a base type `T` and a constraint expression `e`. It allows binding a constraint on the values belonging to this type, which will be materialized by assertions at runtime.

report/chapters/04_implementation/04_midas_language.typ

@@ -347,7 +347,29 @@ When processing a predicate definition, we first need to gather all parameters a
 
 === Extend statement <sec:midas-extend-stmt>
 
-#todo[]
+The last kind of statement available in our definition language is the `extend` statement. As explained in @sec:theory-syntax-midas, this allows defining members (properties and methods) on an already defined type. Processing it is rather straightforward, and comes down to two steps. First, we need to get the type being extended from the registry. The second step is simply iterating over each member statement and calling `TypesRegistry.define_member`. @fig:midas-visit_extend_stmt presents the short implementation of the method handling `extend`statements.
+
+#figure(
+  ```python
+  def visit_extend_stmt(self, stmt: m.ExtendStmt) -> None:
+      self._resolve_type_params(stmt.params)
+      base_name: str = stmt.name.lexeme
+      try:
+          _ = self.get_type(base_name)
+      except NameError:
+          self.reporter.error(stmt.name.get_location(), f"Unknown type '{base_name}'")
+
+      for member in stmt.members:
+          member_type: Type = member.type.accept(self)
+          self.types.define_member(
+              base_name,
+              member.name.lexeme,
+              member_type,
+              member.kind,
+          )
+  ```,
+  caption: [Midas Typer: implementation of `visit_extend_stmt`]
+) <fig:midas-visit_extend_stmt>
 
 === Example