Lambda the Ultimate

See the Scala changelog:

It is now possible to declare structural types using type refinements. For example:

class File(name: String) {
  def getName(): String = name
  def open() { /*..*/ }
  def close() { println("close file") }
}
def test(f: { def getName(): String }) { println(f.getName) }

test(new File("test.txt"))
test(new java.io.File("test.txt"))

I think "Duck Typing" is just structural subtyping, with the added implication that the language doesn't attempt to statically verify anything. It's true but misleading to say that structural subtyping checks the argument for all parts of the expected type rather than just the part that is used - nice languages with structural subtyping and anonymous object types (like O'Caml) will infer an expected type that contains mostly just the parts you actually use anyway.

As usual, if you have been "too tricky" you may have to do a little more work to make your program obviously sound (to the type system), the payoff being that the type system warns you if you do something not "obviously" sound.

While Boo is primarily statically typed, operations on "duck" aren't statically checked, so it doesn't count as static structural subtyping.

Static duck typing is already a central functionality in all languages that provide for genericity or type inference.
Examples are C++ and the ML family of programming languages.