concept Stack {
    refines  {
      Container;
    }
    signature {
      is_empty() : bool;
      push(element x);
      pop() : element;
    }
  }

  concept Container {
    types {
      Value element;
    }
    signature {
      for_each(Functor f);
    }
  }

In Heron you will be able to write a function using concepts as parameters instead of actual types as follows:

  fubar(Stack x, Stack y) {... }

  fubar(Stack x, y) { ... } 

  fubar(Stack x, x::self y) { ... } 

  fubar[Stack T](T x, T y) { ... } 

  fubar(Stack x, type[x] y) { ... } 

foobar(Stack x,Stack y)
  where (typeof(x) == typeof(y))
   && (x != nil)
   && (y != nil)
{ ... }

> foobar(Stack x,Stack y)
>   where (typeof(x) == typeof(y))
>    && (x != nil)
>    && (y != nil)
> { ... }
> 

template<typename T>
bool lt(T x, T y) {
  return x < y; 
}

bool lt(Comparable x, typeof[x] y) {
  return x < y; 
}

template<typename Iter_T>
std::accumulate(Iter_T x, Iter_T y) { ... }

concept Stack[type T] {
  refines {
    Stack;
  }
  extends {
    define element = T; 
  }
}

class stack[type T] {
  // models Stack concept 
}

swap_tops(Stack x, Stack y) {
  x::element x_top = x.pop();
  y::element y_top = y.pop();
  // the following two lines may or may not work, 
  // depending on whether the two stacks hold compatible type
  x.push(y_top); 
  y.push(x_top);
}

main() {
  stack[int] ints;
  stack[string] strings;
  swap_tops(ints, strings);
}

MyConcept c;
MyInterface i;

fu(SomeConcept x) {
  c = x; // only works if the actual type of c supports assignment from the actual type of x.
}

bar(SomeInterface y) {
  i = y; // always works. 
}

fubar(Stack x, Stack y) {
  static_assert<type_eq<x, y>>;
  ...
}

> fubar(Stack x, Stack y) {
>   static_assert<type_eq<x, y>>;
>   ...
> }
> 

// blah models the Function concept
blah(int a) { ... }

// fubar models the my_function concept
my_function fubar(Stack x, Stack y) : bool {
  ...
}

concept my_function {
  refines  {
    Function;
  }
  returns {
    bool;
  }
  // well, hum...
  parameter<T> {
    T, T; // order is important!
  }
}

concept Function {
  // empty
}

// blah(int a, bool b)
parameter {
  int, bool;
}

// blah(int a, a_type b, an_other c)
parameter<T, U> {
  int, U, T;
}

// blah()
parameter {

}

parameter<T, U> {
  int, U, T;
  assert {
    static_assert<...>;
    meta_if<...>;
    // etc.
  }
}

concept Comparable {
    signature {
      compare(Comparable x) : bool;
    }
}

compare(MyType x) : bool;
or
compare(Comparable x) : bool;