The haskell code is — as far as I can see anyway — nominative typing. It can be post-implemented, but you still need your type to be explicitly made into a Stream instance.

Contrast OCaml, an object type is represented as a set of (method, types) tuples and type-checking is a subset check (if type A has all the methods of type B, then it's a subtype of B regardless of anything else from visibility to semantics):

    # let x =
          object
              method foo = 42
          end;;
    val x : < foo : int > = <obj>
    # let y =
          object
              method foo = 63
              method bar = 12
          end;;
    val y : < bar : int; foo : int > = <obj>
    # x = y;;
    Error: This expression has type < bar : int; foo : int >
           but an expression was expected of type < foo : int >
           The second object type has no method bar
    # type simple = < foo : int >;;
    type simple = < foo : int >
    # (y :> simple) = x;;
    - : bool = false
    #