$ ocaml
        Objective Caml version 3.08.2

# let foo bar = print_endline bar#baz;;
val foo : < baz : string; .. > -> unit = <fun>
# class wooble = object end;;
class wooble : object  end
# foo (new wooble);;
This expression has type wooble but is here used with type
  < baz : string; .. >
Only the second object type has a method baz
# class ninja = object method baz = "hello" end;;
class ninja : object method baz : string end
# foo (new ninja);;
hello
- : unit = ()
#

foo(x : INTEGER) is
   require
      arg_too_small : x >= 42
   do
      std_output.put_integer(x)
      std_output.put_new_line
   end

debug
{
   writefln("We're debugging!");
}

debug (4) // we can have numbers to represent different debugging levels
   writefln("We can have the debug line apply to just one statement");

debug (hello):
   // we can have string labels for controlling debug blocks,
   // and the debug section can extend to the end of the current block

>>> def pre(pre_f):
...    def decorate(f):
...       def x(*args, **kwds):
...          pre_f()
...          f(*args, **kwds)
...       x.__name__ = f.__name__
...       return x
...    return decorate
...
>>> def yo(): print "yo"
...
>>> @pre(yo)
... def hello(): print "hello"
...
>>> hello()
yo
hello
>>> hello.__name__
'hello'
>>>

>>> def require(*types):
...    def decorate(f):
...       def x(*args, **kwds):
...          for n, (type_name, arg) in enumerate(zip(types, args)):
...             if not isinstance(arg, type_name):
...                raise TypeError("Type mismatch on arg %d.  Should be %s but was %s." % (n + 1, str(type_name), str(type(arg))))
...          return f(*args, **kwds)
...       x.__name__ = f.__name__
...       return x
...    return decorate
...
>>> @require(int, int)
... def foo(a, b):
...    return a + b
...
>>> foo("hello", "foo")
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
  File "<stdin>", line 6, in x
TypeError: Type mismatch on arg 1.  Should be <type 'int'> but was <type 'str'>.
>>> foo(1, 2)
3
>>>

$ irb
irb(main):001:0> class Foo
irb(main):002:1>    def each
irb(main):003:2>       yield 42
irb(main):004:2>       yield 65
irb(main):005:2>    end
irb(main):006:1> end
=> nil
irb(main):007:0> class Foo
irb(main):008:1>    include Enumerable
irb(main):009:1> end
=> Foo
irb(main):010:0> Foo.new.is_a? Enumerable
=> true
irb(main):011:0> Foo.new.sort.reverse
=> [65, 42]

#ifdef 42 < 56

#else

#endif

static if (42 < 56)
{

}
else
{

}

int foo() return 42;

int foo() 42;

Arrays.sort(objArray, new Comparator<SomeClass>()
   public int compare(SomeClass o1, SomeClass o2)     
      return o1.someGetter().compareTo(o2.someGetter())
)

FOOZ
BAZZER
Foo
Bar

if (size > newSize) //etcetc

xml.parse

xml.isParsed

if (size > newSize) //etcetc

abc(def(ghi(abc(def(ghi())))))

_hash.put(c.get_key(), new Integer((Integer)(c.get_value()).intValue() + this.size()));

my_array.length;

my_array_list.size();

abc(def(efg(xyz())))

abc(def(efg(xyz)))

abc def efg xyz

abc(def, efg, xyz)

abc(def, efg(xyz))

abc(def(efg, xyz))

abc(def(efg), xyz)

abc(def(efg(xyz)))

abc(def, efg, xyz)

((abc def) efg) xyz

static class MethodHolder{
     static randomMethodVerb(int n){
              return n*n;
     }
}

def randomFunctionVerb(n):
      return n*n

def iter(lst, func):
    for item in lst:
           print func(lst)

map(func, lst)

class Queue {
    // ...

    public void throwAwayFirst() {
        // ...
    }
}

bar = do
    return "123"

foo = do
    bar
    putStrLn "Hello World!"

foo();
readInput();
bar();
input = getInput();
 .
 .
 .

class TEST
create { ANY }
    make
feature { ANY }
    make is
        local
            line : STRING
            prompt : STRING := "Input something: "
        do
            std_output.put_string(prompt)

            std_input.read_line
            line := std_input.last_string

            std_output.put_string("You said: " + line)
            std_output.put_new_line
end