Add some instances we were missing.

core/src/main/scala/cats/data/NonEmptyVector.scala

@@ -244,7 +244,7 @@ private[data] sealed trait NonEmptyVectorInstances {
         fa.foldRight(lb)(f)
 
       override def get[A](fa: NonEmptyVector[A])(idx: Long): Option[A] =
-        if (idx < Int.MaxValue) fa.get(idx.toInt) else None
+        if (0 <= idx && idx < Int.MaxValue) fa.get(idx.toInt) else None
 
       def tailRecM[A, B](a: A)(f: A => NonEmptyVector[Either[A, B]]): NonEmptyVector[B] = {
         val buf = new VectorBuilder[B]

core/src/main/scala/cats/instances/all.scala

@@ -2,26 +2,30 @@ package cats
 package instances
 
 trait AllInstances
-  extends FunctionInstances
-  with    StringInstances
+  extends AnyValInstances
+  with    BigIntInstances
+  with    BigDecimalInstances
+  with    BitSetInstances
   with    EitherInstances
   with    EqInstances
+  with    EquivInstances
+  with    FunctionInstances
+  with    FutureInstances
   with    ListInstances
+  with    MapInstances
+  with    MonoidInstances
   with    OptionInstances
   with    OrderInstances
-  with    MonoidInstances
+  with    OrderingInstances
   with    PartialOrderInstances
+  with    PartialOrderingInstances
+  with    QueueInstances
   with    SemigroupInstances
   with    SetInstances
   with    StreamInstances
-  with    VectorInstances
-  with    AnyValInstances
-  with    MapInstances
-  with    BigIntInstances
-  with    BigDecimalInstances
-  with    BitSetInstances
-  with    FutureInstances
+  with    StringInstances
+  with    SymbolInstances
   with    TryInstances
   with    TupleInstances
   with    UUIDInstances
-  with    SymbolInstances
+  with    VectorInstances

core/src/main/scala/cats/instances/duration.scala

@@ -0,0 +1,9 @@
+package cats
+package instances
+
+import scala.concurrent.duration.Duration
+
+trait DurationInstances extends cats.kernel.instances.DurationInstances {
+  implicit val catsStdShowForDuration: Show[Duration] =
+    Show.fromToString[Duration]
+}

core/src/main/scala/cats/instances/eq.scala

@@ -2,9 +2,11 @@ package cats
 package instances
 
 trait EqInstances {
-  implicit val catsContravariantCartesianEq: ContravariantCartesian[Eq] = new ContravariantCartesian[Eq] {
-    def contramap[A, B](fa: Eq[A])(fn: B => A): Eq[B] = fa.on(fn)
-    def product[A, B](fa: Eq[A], fb: Eq[B]): Eq[(A, B)] =
-      Eq.instance { (left, right) => fa.eqv(left._1, right._1) && fb.eqv(left._2, right._2) }
-  }
+  implicit val catsContravariantCartesianForEq: ContravariantCartesian[Eq] =
+    new ContravariantCartesian[Eq] {
+      def contramap[A, B](fa: Eq[A])(fn: B => A): Eq[B] =
+        fa.on(fn)
+      def product[A, B](fa: Eq[A], fb: Eq[B]): Eq[(A, B)] =
+        Eq.instance { (left, right) => fa.eqv(left._1, right._1) && fb.eqv(left._2, right._2) }
+    }
 }

core/src/main/scala/cats/instances/equiv.scala

@@ -0,0 +1,18 @@
+package cats
+package instances
+
+trait EquivInstances {
+  implicit val catsContravariantCartesianEquiv: ContravariantCartesian[Equiv] =
+    new ContravariantCartesian[Equiv] {
+      def contramap[A, B](fa: Equiv[A])(f: B => A): Equiv[B] =
+        new Equiv[B] {
+          def equiv(x: B, y: B): Boolean = fa.equiv(f(x), f(y))
+        }
+
+      def product[A, B](fa: Equiv[A], fb: Equiv[B]): Equiv[(A, B)] =
+        new Equiv[(A, B)] {
+          def equiv(x: (A, B), y: (A, B)): Boolean =
+            fa.equiv(x._1, y._1) && fb.equiv(x._2, y._2)
+        }
+    }
+}

core/src/main/scala/cats/instances/map.scala

@@ -74,11 +74,13 @@ trait MapInstances extends cats.kernel.instances.MapInstances {
 
       override def size[A](fa: Map[K, A]): Long = fa.size.toLong
 
-      override def get[A](fa: Map[K, A])(idx: Long): Option[A] = {
-        if (idx >= 0L && idx < fa.size && idx < Int.MaxValue)
-          Some(fa.valuesIterator.drop(idx.toInt - 1).next)
-        else None
-      }
+      override def get[A](fa: Map[K, A])(idx: Long): Option[A] =
+        if (idx < 0L || Int.MaxValue < idx) None
+        else {
+          val n = idx.toInt
+          if (n >= fa.size) None
+          else Some(fa.valuesIterator.drop(n).next)
+        }
 
       override def isEmpty[A](fa: Map[K, A]): Boolean = fa.isEmpty
 

core/src/main/scala/cats/instances/order.scala

@@ -1,17 +1,23 @@
 package cats
 package instances
 
-import cats.functor.Contravariant
-
 trait OrderInstances extends cats.kernel.OrderToOrderingConversion {
 
-  implicit val catsFunctorContravariantForOrder: Contravariant[Order] =
-    new Contravariant[Order] {
+  implicit val catsContravariantCartesianForOrder: ContravariantCartesian[Order] =
+    new ContravariantCartesian[Order] {
       /** Derive an `Order` for `B` given an `Order[A]` and a function `B => A`.
        *
        * Note: resulting instances are law-abiding only when the functions used are injective (represent a one-to-one mapping)
        */
       def contramap[A, B](fa: Order[A])(f: B => A): Order[B] = fa.on(f)
+
+      def product[A, B](fa: Order[A], fb: Order[B]): Order[(A, B)] =
+        new Order[(A, B)] {
+          def compare(x: (A, B), y: (A, B)): Int = {
+            val z = fa.compare(x._1, y._1)
+            if (z == 0) fb.compare(x._2, y._2) else z
+          }
+        }
     }
 }
 

core/src/main/scala/cats/instances/ordering.scala

@@ -0,0 +1,22 @@
+package cats
+package instances
+
+trait OrderingInstances {
+
+  implicit val catsContravariantCartesianForOrdering: ContravariantCartesian[Ordering] =
+    new ContravariantCartesian[Ordering] {
+      /** Derive an `Ordering` for `B` given an `Ordering[A]` and a function `B => A`.
+       *
+       * Note: resulting instances are law-abiding only when the functions used are injective (represent a one-to-one mapping)
+       */
+      def contramap[A, B](fa: Ordering[A])(f: B => A): Ordering[B] = fa.on(f)
+
+      def product[A, B](fa: Ordering[A], fb: Ordering[B]): Ordering[(A, B)] =
+        new Ordering[(A, B)] {
+          def compare(x: (A, B), y: (A, B)): Int = {
+            val z = fa.compare(x._1, y._1)
+            if (z == 0) fb.compare(x._2, y._2) else z
+          }
+        }
+    }
+}

core/src/main/scala/cats/instances/package.scala

@@ -1,40 +1,40 @@
 package cats
 
 package object instances {
-  object all      extends AllInstances
-
-  object either extends EitherInstances
-  object eq extends EqInstances
-  object function extends FunctionInstances
-  object order extends OrderInstances
-  object partialOrder extends PartialOrderInstances
-  object monoid extends MonoidInstances
-  object semigroup extends SemigroupInstances
-
-  object list       extends ListInstances
-  object option     extends OptionInstances
-  object set        extends SetInstances
-  object bitSet     extends BitSetInstances
-  object stream     extends StreamInstances
-  object vector     extends VectorInstances
-  object map        extends MapInstances
-  object future     extends FutureInstances
-
-  object string     extends StringInstances
-  object int        extends IntInstances
-  object byte       extends ByteInstances
-  object long       extends LongInstances
-  object char       extends CharInstances
-  object short      extends ShortInstances
-  object float      extends FloatInstances
-  object double     extends DoubleInstances
-  object boolean    extends BooleanInstances
-  object unit       extends UnitInstances
-
-  object bigInt     extends BigIntInstances
-  object bigDecimal extends BigDecimalInstances
-
-  object try_       extends TryInstances
-  object tuple      extends TupleInstances
-  object uuid       extends UUIDInstances
+  object all             extends AllInstances
+  object bigInt          extends BigIntInstances
+  object bigDecimal      extends BigDecimalInstances
+  object bitSet          extends BitSetInstances
+  object boolean         extends BooleanInstances
+  object byte            extends ByteInstances
+  object char            extends CharInstances
+  object double          extends DoubleInstances
+  object duration        extends DurationInstances
+  object either          extends EitherInstances
+  object eq              extends EqInstances
+  object equiv           extends EquivInstances
+  object float           extends FloatInstances
+  object function        extends FunctionInstances
+  object future          extends FutureInstances
+  object int             extends IntInstances
+  object list            extends ListInstances
+  object long            extends LongInstances
+  object map             extends MapInstances
+  object monoid          extends MonoidInstances
+  object option          extends OptionInstances
+  object order           extends OrderInstances
+  object ordering        extends OrderingInstances
+  object partialOrder    extends PartialOrderInstances
+  object partialOrdering extends PartialOrderingInstances
+  object queue           extends QueueInstances
+  object semigroup       extends SemigroupInstances
+  object set             extends SetInstances
+  object short           extends ShortInstances
+  object stream          extends StreamInstances
+  object string          extends StringInstances
+  object try_            extends TryInstances
+  object tuple           extends TupleInstances
+  object unit            extends UnitInstances
+  object uuid            extends UUIDInstances
+  object vector          extends VectorInstances
 }

core/src/main/scala/cats/instances/partialOrder.scala

@@ -1,15 +1,21 @@
 package cats
 package instances
 
-import cats.functor.Contravariant
-
 trait PartialOrderInstances {
-  implicit val catsFunctorContravariantForPartialOrder: Contravariant[PartialOrder] =
-    new Contravariant[PartialOrder] {
+  implicit val catsContravariantCartesianForPartialOrder: ContravariantCartesian[PartialOrder] =
+    new ContravariantCartesian[PartialOrder] {
       /** Derive a `PartialOrder` for `B` given a `PartialOrder[A]` and a function `B => A`.
        *
        * Note: resulting instances are law-abiding only when the functions used are injective (represent a one-to-one mapping)
        */
       def contramap[A, B](fa: PartialOrder[A])(f: B => A): PartialOrder[B] = fa.on(f)
+
+      def product[A, B](fa: PartialOrder[A], fb: PartialOrder[B]): PartialOrder[(A, B)] =
+        new PartialOrder[(A, B)] {
+          def partialCompare(x: (A, B), y: (A, B)): Double = {
+            val z = fa.partialCompare(x._1, y._1)
+            if (z == 0.0) fb.partialCompare(x._2, y._2) else z
+          }
+        }
     }
 }

core/src/main/scala/cats/instances/partialOrdering.scala

@@ -0,0 +1,28 @@
+package cats
+package instances
+
+trait PartialOrderingInstances {
+  implicit val catsContravariantCartesianForPartialOrdering: ContravariantCartesian[PartialOrdering] =
+    new ContravariantCartesian[PartialOrdering] {
+      /** Derive a `PartialOrdering` for `B` given a `PartialOrdering[A]` and a function `B => A`.
+       *
+       * Note: resulting instances are law-abiding only when the functions used are injective (represent a one-to-one mapping)
+       */
+      def contramap[A, B](fa: PartialOrdering[A])(f: B => A): PartialOrdering[B] =
+        new PartialOrdering[B] {
+          def lteq(x: B, y: B): Boolean = fa.lteq(f(x), f(y))
+          def tryCompare(x: B, y: B): Option[Int] = fa.tryCompare(f(x), f(y))
+        }
+
+      def product[A, B](fa: PartialOrdering[A], fb: PartialOrdering[B]): PartialOrdering[(A, B)] =
+        new PartialOrdering[(A, B)] {
+          def lteq(x: (A, B), y: (A, B)): Boolean =
+            tryCompare(x, y).exists(_ <= 0)
+          def tryCompare(x: (A, B), y: (A, B)): Option[Int] =
+            fa.tryCompare(x._1, y._1) match {
+              case Some(0) => fb.tryCompare(x._2, y._2)
+              case option => option
+            }
+        }
+    }
+}