Generics

___________________________________________________________________________________________________

	class C { 
		Bird m() { return new Penguin() }
	}

	class D extends C {
		Animal m() { return new Bat() }
	}

	C c = new D()
	Bird x = c.m()

	Covariant return types => subclass return type must be a subtype of superclass return type

	class C { 
		m(Bird x) { x.fly() }
	}

	class D extends C {
		m(Penguin x) { x.eatKrill() }	
	}

	C c = new D()
	c.m( Penguin )
	
	c.m( new Duck )			[ doesn't work!! ]

	class D extends C {
		m(Penguin x) { x.layEggs() }	
	}

	c.m( new Duck )			[ works! ]

	contravariant arguments types -> can override with supertype arguments

	Side Note:
		Overloading is encoded as 
		m$Bird
		m$Dinosour

___________________________________________________________________________________________________

	T1' <: T1 	  T2 <: T2'
	______________________
	T1 -> T2 <: T1' -> T2'

	(a => b) === (!a v b)			(a -> b) -> c
									 +    - 	-

___________________________________________________________________________________________________

	class List<A> {
		A get(int i)
		add(A)
	}

	List <String>

	class List&String {
		String get(i)
		add(String)
	}

	Templates (in C++) are not generics. They solve the same problem tho.

	What the subtyping expansion between

	List<Integer> <: List<Number>
				  :>
				  =
				  !=

	List<Number> ys = new List<Number>()
	List<Integer> xs = ys					

	does this work?	List<Integer> <: List<Number>

	xs.add(new Integer)
	ys.add(new Integer)
	ys.add(new Float)
	Integer i = xs.get(2) 		X (this will fail)

	Integer get(int) 		Number get(int)
X 	add(Integer)			add(Number)


	and now if we look at: 
		List<Integer> >: List<Number>
	i.e List<Number> <: List<Integer>

	does this work?

	ys = xs
	ys.add(new Integer())
	ys.add(new Float)
X 	ys.get(1)


	So a a List<A> cant be covariant and it cant be contravariant ... it can only be invariant (==)
	(does not change)


	Most people want this:
		List<Integer> <: List<Number>

	So when your designing a language - you have to deside ... its a trade off between

		expressiveness vs safety vs simplicity


		expressiveness && safety 		( <- this is java )

		safty && simplicity 			( <- C# )
			C# ist<S> and List<T> are unrelated

		expressiveness && simplicity 	( <- Dart )


		Dart: homework
		Scala: 

___________________________________________________________________________________________________

	Java Wildcards

	List<T>
	List<? extends T>
	List<? super T>
	List<?>
	List 					( != List<Object>     they are the almost the same but not )

	A <: B
		List<A> incomparable List<B> 					
		List<? ext A> <: List<? ext B>				covariant
		List<? super A> :> List<? super B> 			contravariant


	List<A> <: List<? ext A>

	C <: A

	List<C> <: List<? ext A>

		class List<> ext A>
			? ext A get(i)
			add(? ext A)

		Ax xs.get(0)
		xs.add(new A) 			X - should not work ... ????


	class List<E> { 
		E get()
		add(E)
	}

	List<? ext Number> xs = new List<Integer>()
	xs = new List<Float>()
	xs.add( new Integer() )

___________________________________________________________________________________________________

	class List<E> {
		E x;
		E get() { return x; }
		void add(E x) { this.x = x; }
	}

	public class Main {

		void a() {
			List<Number xs = new List<Number>();
			Number n = xs.get();
			xs.add( new Integer(3) );
		}

		void b() {
			List<? extends Number> xs = new List<Integer>();
			Number n = xs.get();
			xs.add( new Integer(3) );
		}

		void c() {
			List<? extends Number> xs = new List<Integer>();
			Number n = xs.get();
			xs.add((Number) new Integer(3) );
			
			class  C {
				<T> m(List<T> xs) {
					xs.add(xs.get());
				}
			}

			new C().m(xs);
		}

	}

___________________________________________________________________________________________________

	Scala

immutable
	class List [T]				{	def add(T) }					X - cant do this
mutable
	class ListBuffer[T]
	class Map[-K,+V]
		put(K,V)
		V get(K)

		List[Number] :> List[Integer]
		
___________________________________________________________________________________________________