(define(flatten lst)(fold-right(lambda(x a)(if(list? x)(append(flatten x)a)(cons x a)))'()lst))

def flatten(xs:List[Any]):List[Any]=xs flatMap{case y::ys=>flatten(y::ys);case x=>List(x)}

(define(flatten lst)(append-map(lambda(x)(if(list? x)(flatten x)(list x)))lst))

class Something {
  public void close() {...}
}

class SomethingElse {
  public void close() {...}
}

interface Closeable {
  void close();
}

class Wrappers {
  public static Closeable closeable(Something s) {
    return new Closeable() {public void close() {s.close();}}

  public static Closeable closeable(SomethingElse s) {
    return new Closeable() {public void close() {s.close();}}
}

// imagine this is somewhere with appropriate imports and more boilerplate
public void foo(Closeable closeable) {
  // ...
  closeable.close();
}

// and somewhere else
import static Wrappers.*
// blah blah blah, yada yada yada
x.foo(closeable(new Something()));
x.foo(closeable(new SomethingElse()));

def foo(closeable : {def close}) {
  // ...
  closeable.close
}

// and now
x.foo(new Something)
x.foo(new SomethingElse)