public class Name {
   private String first, last;

   public Name(String f, String l)
   {
      first = f;
      last = l;
   }

   public String getFirst {return first;}
   public String getLast {return last;}
}

import java.util.*; ...

Name[] names = {new Name("Bob", "Smith"), new Name("John", "Doe")};

Arrays.sort(names,
    new Comparator() {
        public int compare(Name n1, Name n2) {
            return n1.getLast().compareTo(n2.getLast());
        }
    }
);

def foo
   "foo"
end

class Bar
   def initialize
      puts foo
   end
end

class Object
   def foo
      "foo"
   end
end

class Bar < Object
   def initialize
      puts foo
   end
end

#include <string>
#include <vector>

class Name
{
        private:
                const std::string _first, _last;
        public:
                Name(std::string f, std::string l): _first(f), _last(l) { }
               
                std::string first() const
                {
                        return _first;
                }
               
                std::string last() const
                {
                        return _last;
                }
};

class GradesCollection : public std::vector<int>
{
        public:
                GradesCollection() : std::vector<int>() { }

                int sum_grades() const
                {
                        int sum = 0;
                        for (const_iterator i(begin()); i != end(); ++i)
                                sum += *i;
                        return sum;
                }
               
                double average_grade() const
                {
                        return sum_grades() / size();
                }
};

class Student : public Name, public GradesCollection
{
        public:
                Student(std::string f, std::string l)
                : Name(f, l)
                , GradesCollection()
                { }
};

template <size_t N> LotteryTicket

LotteryTicket<7>

int[] foo = new int[10];
int[] bar = new int[10];

for (int i = 0; i < 10; i++)
   foo[i] = i;

for (int i = 0; i < 10; i++)
   bar[i] = foo[i] * 2;

foo = [0..9]
bar = map (* 2) foo

#include <stdlib.h>

class MyVector
{
   private:
      int *_data;
      size_t _size;
   public:
      MyVector() : _data(new int[0]), _size(0) { }
      MyVector(size_t size) : _data(new int[size]), _size(size) { }
      ~MyVector() { delete [] _data; _size = 0; }
      /* yada yada */
};

data Name = Name {first::String, last::String}

names = [Name "Bob" "Smith", Name "John" "Doe"]
sortedNames = sortBy (\a b -> last a `compare` last b) names

compareNames a b = last a `compare` last b

compareNames (Name _ a) (Name _ b) = a `compare` b

sortNames = sortBy compareNames

sortedNames = sortNames names

class Dog
{
        public Dog() { super(); }

        public void talk()
        {
                System.out.println("Woof!");
        }
}

class Robot
{
        public Robot() { super(); }

        public void talk()
        {
                System.out.println("More oil, please.");
        }
}

class Tree
{
        public Tree() { super(); }

        public void bark()
        {
                System.out.println("Rough");
        }
}

public class Test
{
        public static void main(String[] args)
        {
                speak(new Dog());
                speak(new Robot());
                speak(new Tree());
        }

        private static <T> void speak(T speaker)
        {
                speaker.talk();
        }
}

speak(new Tree());

Test.java:42: cannot find symbol
symbol  : method talk()
location: class java.lang.Object
                speaker.talk();
                       ^
1 error

interface Speaks
{
        public void talk();
}

class Dog implements Speaks
{
        public Dog() { super(); }

        public void talk()
        {
                System.out.println("Woof!");
        }
}

class Robot implements Speaks
{
        public Robot() { super(); }

        public void talk()
        {
                System.out.println("More oil, please.");
        }
}

class Tree
{
        public Tree() { super(); }

        public void bark()
        {
                System.out.println("Rough");
        }
}

public class Test
{
        public static void main(String[] args)
        {
                speak(new Dog());
                speak(new Robot());
//              speak(new Tree());
        }

        private static <T extends Speaks> void speak(T speaker)
        {
                speaker.talk();
        }
}

interface Speaks
{
        public void talk();
}

class Dog implements Speaks
{
        public Dog() { super(); }

        public void talk()
        {
                System.out.println("Woof!");
        }
}

class Robot implements Speaks
{
        public Robot() { super(); }

        public void talk()
        {
                System.out.println("More oil, please.");
        }
}

class Tree
{
        public Tree() { super(); }

        public void bark()
        {
                System.out.println("Rough");
        }
}

public class Test
{
        public static void main(String[] args)
        {
                speak(new Dog());
                speak(new Robot());
//              speak(new Tree());
        }

        private static void speak(Speaks speaker)
        {
                speaker.talk();
        }
}

data Name = Name2 {first::String, last::String} | Name3 {first::String , middle::String, last::String} deriving (Eq)

instance Show Name where
   show (Name2 f l) = f ++ " " ++ l
   show (Name3 f m l) = f ++ " " ++ m ++ " " ++ l

instance Ord Name where
   compare (Name2 f1 l1) (Name2 f2 l2) =
      case compare l1 l2 of
         EQ -> compare f1 f2
         n  -> n
   compare (Name3 f1 m1 l1) (Name3 f2 m2 l2) =
      case compare l1 l2 of
         EQ -> case compare f1 f2 of
            EQ -> compare m1 m2
            n  -> n
         n  -> n
   compare (Name2 f1 l1) (Name3 f2 _ l2) =
      case compare l1 l2 of
         EQ -> compare f1 f2
         n  -> n
   compare (Name3 f1 _ l1) (Name2 f2 l2) =
      case compare l1 l2 of
         EQ -> compare f1 f2
         n  -> n

import List

data Column = NameCol | AgeCol | WeightCol
data Row = Row {name::Name, age::Int, weight::Int}
type Table = [Row]
 
sortByCol col =
   sortBy (\a b -> case col of
      NameCol -> compare (name a) (name b)
      AgeCol -> compare (age a) (age b)
      WeightCol -> compare (weight a) (weight b))