Pathikrit Bhowmick pathikrit

Let C<A> be a higher-kinded type e.g. in List<Animal>, List is C and Animal is A.
Let S be a subtype of T e.g. in class Cat extends Animal, Cat is S and Animal is T

See Liskov substitution principle .

If C<S> is a subtype of C<T>, then C is covaraint on T e.g. List<Cat> is a subtype of List<Animal>
If C<T> is a subtype of C<S>, then C is contravariant on T e.g. Predicate<Animal> is a subtype of Predicate<Cat>
If neither C<T> and nor C<S> are subtypes of the other, thenC is invariant on T
If both C<T> and C<S> are subtypes of each other, then C is phantom variant on T. This is possible in languages which support phantom types like Haskell

In Scala:

	import better.files._

	def moveDupes(
	dir: File,
	logFile: File = (File.home / "dupes.txt"),
	dupeFolder: File = (File.home / 'dupes).createDirectory()
	) = {
	for {
	log <- logFile.printWriter()
	(hash, toKeep :: toMove) <- dir.listRecursively.toSeq.groupBy(_.md5).mapValues(_.toList)

	/**
	* Quick and dirty Scala app to print git commit punch-card e.g.
	*
	* ┃08┃09┃10┃11┃12┃13┃14┃15┃16┃17┃18┃19┃20┃21┃22┃23┃00┃01┃02┃03┃04┃05┃06┃07┃
	* Sun┃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
	* Mon┃▁▁▁▄▄▄▅▅▅▅▅▅▄▄▄▆▆▆▇▇▇▇▇▇███▆▆▆▅▅▅▄▄▄▃▃▃▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
	* Tue┃▁▁▁▃▃▃▆▆▆▅▅▅▅▅▅▅▅▅▆▆▆▇▇▇▆▆▆▆▆▆▅▅▅▅▅▅▄▄▄▃▃▃▂▂▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
	* Wed┃▁▁▁▄▄▄▅▅▅▇▇▇▅▅▅▅▅▅███▇▇▇▅▅▅▆▆▆▇▇▇▃▃▃▃▃▃▂▂▂▂▂▂▂▂▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
	* Thu┃▁▁▁▂▂▂▄▄▄▆▆▆▅▅▅▆▆▆▇▇▇▇▇▇▆▆▆▇▇▇▅▅▅▄▄▄▃▃▃▂▂▂▂▂▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁
	* Fri┃▁▁▁▂▂▂▄▄▄▅▅▅▅▅▅▄▄▄▄▄▄▅▅▅▅▅▅▃▃▃▃▃▃▂▂▂▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁▁

	triggeredMessage := Watched.clearWhenTriggered

	libraryDependencies += "com.lihaoyi" % "ammonite" % "latest.release" % "test" cross CrossVersion.full

	initialCommands in (Test, console) := """ammonite.Main().run()"""

	watchSources ++= (
	(baseDirectory.value * "*.sbt").get
	++ (baseDirectory.value / "project" * "*.scala").get
	++ (baseDirectory.value / "project" * "*.sbt").get

	import scala.collection.generic.Growable

	/**
	* Boyer–Moore majority vote algorithm (https://en.wikipedia.org/wiki/Boyer–Moore_majority_vote_algorithm)
	* A Data structure that supports O(1) tracking of the majority element in streaming data
	* (i.e. something that occurs strictly > 50% of the time)
	*/
	class MajorityElement[A] extends Growable[A] {
	private[this] var majorityElement = Option.empty[A]
	private[this] var count = 0

	/**
	* Dumb O(n^3) version: Check if all n^2 substrings are palindromes
	*/
	def countPalindromes3(s: String): Int =
	(1 to s.length).flatMap(s.sliding).count(t => t.reverse == t)

	/***********************************************************************/
	/**
	* O(n^2) solution - count how many (odd and even) palindromes are centered at index i by expanding left and right
	*/

	import scala.util.control.NonFatal
	import better.files.Scanner.Read

	/**
	* Extend this trait to create your application config
	*
	* Pros of this approach:
	* 1) Library free approach - only 15 lines of dependency free "library" (four one-line defs for you to override)
	* 2) Failures happen when the Config object is loaded instead of when a config value is accessed
	* 3) Strongly typed

	import scala.collection.mutable

	/**
	* A thread-safe Scala port of the KShingling implementation of https://github.com/tdebatty/java-string-similarity
	*/
	class KShingling(k: Int = 3) {self =>

	private[this] val shingles = mutable.Map.empty[String, Int]

	def profile(s: String) = {

	class CircularBuffer<T> {
	private T[] array = (T[]) new Object[1<<4];
	private int start = 0, end = 0;

	public T get(int i) {
	assert(0 <= i && i < size());
	return array[mod(start + i)];
	}

	public void set(int i, T elem) {