In this hypothetical Heron a function becomes a class with an implicit public result field.

Here is what it might look like if Heron functions became classes:

unit heron.collections;

interface Sequence[T : type]
{
  // deferred function classes
  define Foreach[F[T]]();
  define Concat(x : self);

  // public type ( alias )
  define Element = T;

  // extension class
  define Count() : int {
    define counter[T](T x) {
      enclosing.result++;
    }
    Foreach[counter]();
  }
}

// implicitly implements Sequence
define List[T : type](h : T, t : self)
{
  T head;
  self tail;
  head = h;
  tail = t;

  define Foreach[F[T]]() {
    F[T](Head);
    if (tail != null) {
      Tail.Foreach[F[T]]();
    }
  }
  define Last() : self {
    self curr = this;
    while (curr.tail != null) {
      curr = curr.tail;
    }
  }
  define Concat(x : self) {
    Last().tail = x.Clone();
  }
}

// type aliasing
define List[T : type](h : T)
  = List[T](h, null);

// class as function
define Pair[T : type](T x0, T x1) : List[T] {
  result = List[T](x0, List[T](x1));
}