diff --git a/AUTHORS.md b/AUTHORS.md
index 6c21099b34..566870a664 100644
--- a/AUTHORS.md
+++ b/AUTHORS.md
@@ -149,8 +149,10 @@ possible:
  * P. Oscar Boykin
  * Paolo G. Giarrusso
  * Pascal Voitot
+ * Paul Chiusano
  * Paul Phillips
  * Paulo "JCranky" Siqueira
+ * Pavel Chlupacek
  * Pavkin Vladimir
  * Pepe García
  * Pere Villega
diff --git a/COPYING b/COPYING
index 2bbc695e99..6e5add81f8 100644
--- a/COPYING
+++ b/COPYING
@@ -1,4 +1,4 @@
-Cats Copyright (c) 2015 Erik Osheim.
+Cats Copyright (c) 2015 Cats Contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
diff --git a/bench/src/main/scala/cats/bench/ChainBench.scala b/bench/src/main/scala/cats/bench/ChainBench.scala
new file mode 100644
index 0000000000..a8e64b3409
--- /dev/null
+++ b/bench/src/main/scala/cats/bench/ChainBench.scala
@@ -0,0 +1,79 @@
+package cats.bench
+
+import cats.data.Chain
+import fs2.Catenable
+import chain.{Chain => OldChain}
+import org.openjdk.jmh.annotations.{Benchmark, Scope, State}
+
+@State(Scope.Thread)
+class ChainBench {
+
+  private val smallChain = Chain(1, 2, 3, 4, 5)
+  private val smallCatenable = Catenable(1, 2, 3, 4, 5)
+  private val smallVector = Vector(1, 2, 3, 4, 5)
+  private val smallList = List(1, 2, 3, 4, 5)
+  private val smallOldChain = OldChain(smallList)
+
+  private val largeChain = (0 to 1000)
+    .foldLeft(Chain.empty[Int])((acc, _) => acc ++ Chain.fromSeq(0 to 1000))
+  private val largeCatenable = Catenable.fromSeq(0 to 1000000)
+  private val largeVector = (0 to 1000000).toVector
+  private val largeList = (0 to 1000000).toList
+  private val largeOldChain = (0 to 1000).foldLeft(OldChain.empty[Int])((acc, _) => acc ++ OldChain(0 to 1000))
+
+
+  @Benchmark def mapSmallChain: Chain[Int] = smallChain.map(_ + 1)
+  @Benchmark def mapSmallCatenable: Catenable[Int] = smallCatenable.map(_ + 1)
+  @Benchmark def mapSmallVector: Vector[Int] = smallVector.map(_ + 1)
+  @Benchmark def mapSmallList: List[Int] = smallList.map(_ + 1)
+  @Benchmark def mapSmallOldChain: OldChain[Int] = smallOldChain.map(_ + 1)
+
+
+  @Benchmark def mapLargeChain: Chain[Int] = largeChain.map(_ + 1)
+  @Benchmark def mapLargeCatenable: Catenable[Int] = largeCatenable.map(_ + 1)
+  @Benchmark def mapLargeVector: Vector[Int] = largeVector.map(_ + 1)
+  @Benchmark def mapLargeList: List[Int] = largeList.map(_ + 1)
+  @Benchmark def mapLargeOldChain: OldChain[Int] = largeOldChain.map(_ + 1)
+
+
+
+  @Benchmark def foldLeftSmallChain: Int = smallChain.foldLeft(0)(_ + _)
+  @Benchmark def foldLeftSmallCatenable: Int = smallCatenable.foldLeft(0)(_ + _)
+  @Benchmark def foldLeftSmallVector: Int = smallVector.foldLeft(0)(_ + _)
+  @Benchmark def foldLeftSmallList: Int = smallList.foldLeft(0)(_ + _)
+  @Benchmark def foldLeftSmallOldChain: Int = smallOldChain.foldLeft(0)(_ + _)
+
+
+  @Benchmark def foldLeftLargeChain: Int = largeChain.foldLeft(0)(_ + _)
+  @Benchmark def foldLeftLargeCatenable: Int = largeCatenable.foldLeft(0)(_ + _)
+  @Benchmark def foldLeftLargeVector: Int = largeVector.foldLeft(0)(_ + _)
+  @Benchmark def foldLeftLargeList: Int = largeList.foldLeft(0)(_ + _)
+  @Benchmark def foldLeftLargeOldChain: Int = largeOldChain.foldLeft(0)(_ + _)
+
+
+
+
+  @Benchmark def consSmallChain: Chain[Int] = 0 +: smallChain
+  @Benchmark def consSmallCatenable: Catenable[Int] = 0 +: smallCatenable
+  @Benchmark def consSmallVector: Vector[Int] = 0 +: smallVector
+  @Benchmark def consSmallList: List[Int] = 0 +: smallList
+  @Benchmark def consSmallOldChain: OldChain[Int] = 0 +: smallOldChain
+
+  @Benchmark def consLargeChain: Chain[Int] = 0 +: largeChain
+  @Benchmark def consLargeCatenable: Catenable[Int] = 0 +: largeCatenable
+  @Benchmark def consLargeVector: Vector[Int] = 0 +: largeVector
+  @Benchmark def consLargeList: List[Int] = 0 +: largeList
+  @Benchmark def consLargeOldChain: OldChain[Int] = 0 +: largeOldChain
+
+  @Benchmark def createTinyChain: Chain[Int] = Chain(1)
+  @Benchmark def createTinyCatenable: Catenable[Int] = Catenable(1)
+  @Benchmark def createTinyVector: Vector[Int] = Vector(1)
+  @Benchmark def createTinyList: List[Int] = List(1)
+  @Benchmark def createTinyOldChain: OldChain[Int] = OldChain.single(1)
+
+  @Benchmark def createSmallChain: Chain[Int] = Chain(1, 2, 3, 4, 5)
+  @Benchmark def createSmallCatenable: Catenable[Int] = Catenable(1, 2, 3, 4, 5)
+  @Benchmark def createSmallVector: Vector[Int] = Vector(1, 2, 3, 4, 5)
+  @Benchmark def createSmallList: List[Int] = List(1, 2, 3, 4, 5)
+  @Benchmark def createSmallOldChain: OldChain[Int] = OldChain(Seq(1, 2, 3, 4, 5))
+}
diff --git a/bench/src/main/scala/cats/bench/CollectionMonoidBench.scala b/bench/src/main/scala/cats/bench/CollectionMonoidBench.scala
new file mode 100644
index 0000000000..81d4ec1970
--- /dev/null
+++ b/bench/src/main/scala/cats/bench/CollectionMonoidBench.scala
@@ -0,0 +1,24 @@
+package cats.bench
+
+import cats.Monoid
+import cats.data.Chain
+import cats.implicits._
+import chain.{Chain => OldChain}
+import org.openjdk.jmh.annotations.{Benchmark, Scope, State}
+
+@State(Scope.Thread)
+class CollectionMonoidBench {
+
+  private val largeList = (0 to 1000000).toList
+
+  implicit def monoidOldChain[A]: Monoid[OldChain[A]] = new Monoid[OldChain[A]] {
+    def empty: OldChain[A] = OldChain.empty[A]
+
+    def combine(x: OldChain[A], y: OldChain[A]): OldChain[A] = x ++ y
+  }
+
+  @Benchmark def accumulateChain: Chain[Int] = largeList.foldMap(Chain.one)
+  @Benchmark def accumulateVector: Vector[Int] = largeList.foldMap(Vector(_))
+  @Benchmark def accumulateList: List[Int] = largeList.foldMap(List(_))
+  @Benchmark def accumulateOldChain: OldChain[Int] = largeList.foldMap(OldChain.single)
+}
diff --git a/build.sbt b/build.sbt
index 588726cc24..fee016a7fa 100644
--- a/build.sbt
+++ b/build.sbt
@@ -491,7 +491,10 @@ lazy val bench = project.dependsOn(macrosJVM, coreJVM, freeJVM, lawsJVM)
   .settings(commonJvmSettings)
   .settings(coverageEnabled := false)
   .settings(libraryDependencies ++= Seq(
-    "org.scalaz" %% "scalaz-core" % "7.2.23"))
+    "org.scalaz" %% "scalaz-core" % "7.2.23",
+    "org.spire-math" %% "chain" % "0.3.0",
+    "co.fs2" %% "fs2-core" % "0.10.4"
+  ))
   .enablePlugins(JmhPlugin)
 
 // cats-js is JS-only
diff --git a/core/src/main/scala/cats/data/Chain.scala b/core/src/main/scala/cats/data/Chain.scala
new file mode 100644
index 0000000000..99c95eaa89
--- /dev/null
+++ b/core/src/main/scala/cats/data/Chain.scala
@@ -0,0 +1,652 @@
+package cats
+package data
+
+import Chain._
+
+import scala.annotation.tailrec
+import scala.collection.immutable.SortedMap
+import scala.collection.mutable.ListBuffer
+
+/**
+ * Trivial catenable sequence. Supports O(1) append, and (amortized)
+ * O(1) `uncons`, such that walking the sequence via N successive `uncons`
+ * steps takes O(N).
+ */
+sealed abstract class Chain[+A] {
+
+  /**
+   * Returns the head and tail of this Chain if non empty, none otherwise. Amortized O(1).
+   */
+  final def uncons: Option[(A, Chain[A])] = {
+    var c: Chain[A] = this
+    val rights = new collection.mutable.ArrayBuffer[Chain[A]]
+    // scalastyle:off null
+    var result: Option[(A, Chain[A])] = null
+    while (result eq null) {
+      c match {
+        case Singleton(a) =>
+          val next =
+            if (rights.isEmpty) nil
+            else rights.reduceLeft((x, y) => Append(y, x))
+          result = Some(a -> next)
+        case Append(l, r) => c = l; rights += r
+        case Wrap(seq) =>
+          val tail = seq.tail
+          val next = fromSeq(tail)
+          result = Some((seq.head, next))
+        case Empty =>
+          if (rights.isEmpty) {
+            result = None
+          } else {
+            c = rights.last
+            rights.trimEnd(1)
+          }
+      }
+    }
+    // scalastyle:on null
+    result
+  }
+
+  /**
+   * Returns true if there are no elements in this collection.
+   */
+  def isEmpty: Boolean
+
+  /**
+   * Returns false if there are no elements in this collection.
+   */
+  final def nonEmpty: Boolean = !isEmpty
+
+  /**
+   * Concatenates this with `c` in O(1) runtime.
+   */
+  final def concat[A2 >: A](c: Chain[A2]): Chain[A2] =
+    Chain.concat(this, c)
+
+  /**
+   * Alias for concat
+   */
+  final def ++[A2 >: A](c: Chain[A2]): Chain[A2] =
+    concat(c)
+
+  /**
+   * Returns a new Chain consisting of `a` followed by this. O(1) runtime.
+   */
+  final def prepend[A2 >: A](a: A2): Chain[A2] =
+    Chain.concat(one(a), this)
+
+  /**
+   * Alias for [[prepend]].
+   */
+  final def +:[A2 >: A](a: A2): Chain[A2] =
+    prepend(a)
+
+  /**
+   * Returns a new Chain consisting of this followed by `a`. O(1) runtime.
+   */
+  final def append[A2 >: A](a: A2): Chain[A2] =
+    Chain.concat(this, one(a))
+
+  /**
+   * Alias for [[append]].
+   */
+  final def :+[A2 >: A](a: A2): Chain[A2] =
+    append(a)
+
+  /**
+   * Applies the supplied function to each element and returns a new Chain.
+   */
+  final def map[B](f: A => B): Chain[B] =
+    fromSeq(iterator.map(f).toVector)
+
+
+  /**
+   * Applies the supplied function to each element and returns a new Chain from the concatenated results
+   */
+  final def flatMap[B](f: A => Chain[B]): Chain[B] = {
+    var result = empty[B]
+    val iter = iterator
+    while (iter.hasNext) { result = result ++ f(iter.next) }
+    result
+  }
+
+  /**
+   * Folds over the elements from left to right using the supplied initial value and function.
+   */
+  final def foldLeft[B](z: B)(f: (B, A) => B): B = {
+    var result = z
+    val iter = iterator
+    while (iter.hasNext) { result = f(result, iter.next) }
+    result
+  }
+
+  /**
+   * Folds over the elements from right to left using the supplied initial value and function.
+   */
+  final def foldRight[B](z: B)(f: (A, B) => B): B = {
+    var result = z
+    val iter = reverseIterator
+    while (iter.hasNext) { result = f(iter.next, result) }
+    result
+  }
+
+  /**
+   * Collect `B` from this for which `f` is defined
+   */
+  final def collect[B](pf: PartialFunction[A, B]): Chain[B] =
+    foldLeft(Chain.nil: Chain[B]) { (acc, a) =>
+      // trick from TraversableOnce, used to avoid calling both isDefined and apply (or calling lift)
+      val x = pf.applyOrElse(a, sentinel)
+      if (x.asInstanceOf[AnyRef] ne sentinel) acc :+ x.asInstanceOf[B]
+      else acc
+    }
+
+  /**
+   * Remove elements not matching the predicate
+   */
+  final def filter(f: A => Boolean): Chain[A] =
+    collect { case a if f(a) => a }
+
+  /**
+   * Remove elements matching the predicate
+   */
+  final def filterNot(f: A => Boolean): Chain[A] =
+    filter(a => !f(a))
+
+  /**
+   * Find the first element matching the predicate, if one exists
+   */
+  final def find(f: A => Boolean): Option[A] = {
+    var result: Option[A] = Option.empty[A]
+    foreachUntil { a =>
+      val b = f(a)
+      if (b) result = Option(a)
+      b
+    }
+    result
+  }
+
+  /**
+   * Check whether at least one element satisfies the predicate
+   */
+  final def exists(f: A => Boolean): Boolean = {
+    var result: Boolean = false
+    foreachUntil { a =>
+      val b = f(a)
+      if (b) result = true
+      b
+    }
+    result
+  }
+
+  /**
+   * Check whether all elements satisfy the predicate
+   */
+  final def forall(f: A => Boolean): Boolean = {
+    var result: Boolean = true
+    foreachUntil { a =>
+      val b = f(a)
+      if (!b) result = false
+      !b
+    }
+    result
+  }
+
+  /**
+   * Check whether an element is in this structure
+   */
+  final def contains[AA >: A](a: AA)(implicit A: Eq[AA]): Boolean =
+    exists(A.eqv(a, _))
+
+  /**
+   * Zips this `Chain` with another `Chain` and applies a function for each pair of elements.
+   */
+  final def zipWith[B, C](other: Chain[B])(f: (A, B) => C): Chain[C] =
+    if (this.isEmpty || other.isEmpty) Chain.Empty
+    else {
+      val iterA = iterator
+      val iterB = other.iterator
+
+      var result: Chain[C] = Chain.one(f(iterA.next(), iterB.next()))
+
+      while (iterA.hasNext && iterB.hasNext) {
+        result = result :+ f(iterA.next(), iterB.next())
+      }
+      result
+    }
+
+  /**
+   * Groups elements inside this `Chain` according to the `Order`
+   * of the keys produced by the given mapping function.
+   */
+  final def groupBy[B](f: A => B)(implicit B: Order[B]): SortedMap[B, Chain[A]] = {
+    implicit val ordering: Ordering[B] = B.toOrdering
+    var m = SortedMap.empty[B, Chain[A]]
+    val iter = iterator
+
+    while (iter.hasNext) {
+      val elem = iter.next
+      val k = f(elem)
+
+      m.get(k) match {
+        case None => m += ((k, one(elem))); ()
+        case Some(cat) => m = m.updated(k, cat :+ elem)
+      }
+    }
+    m
+  }
+
+  /**
+   * Reverses this `Chain`
+   */
+  def reverse: Chain[A] =
+    fromSeq(reverseIterator.toVector)
+
+
+  /**
+   * Yields to Some(a, Chain[A]) with `a` removed where `f` holds for the first time,
+   * otherwise yields None, if `a` was not found
+   * Traverses only until `a` is found.
+   */
+  final def deleteFirst(f: A => Boolean): Option[(A, Chain[A])] = {
+    @tailrec
+    def go(rem: Chain[A], acc: Chain[A]): Option[(A, Chain[A])] =
+      rem.uncons match {
+        case Some((a, tail)) =>
+          if (!f(a)) go(tail, acc :+ a)
+          else Some((a, acc ++ tail))
+
+        case None => None
+      }
+    go(this, Chain.nil)
+  }
+
+  /**
+   * Applies the supplied function to each element, left to right.
+   */
+  private final def foreach(f: A => Unit): Unit = foreachUntil { a => f(a); false }
+
+  /**
+   * Applies the supplied function to each element, left to right, but stops when true is returned
+   */
+  // scalastyle:off null return cyclomatic.complexity
+  private final def foreachUntil(f: A => Boolean): Unit = {
+    var c: Chain[A] = this
+    val rights = new collection.mutable.ArrayBuffer[Chain[A]]
+
+    while (c ne null) {
+      c match {
+        case Singleton(a) =>
+          val b = f(a)
+          if (b) return ();
+          c =
+            if (rights.isEmpty) Empty
+            else rights.reduceLeft((x, y) => Append(y, x))
+          rights.clear()
+        case Append(l, r) => c = l; rights += r
+        case Wrap(seq) =>
+          val iterator = seq.iterator
+          while (iterator.hasNext) {
+            val b = f(iterator.next)
+            if (b) return ()
+          }
+          c =
+            if (rights.isEmpty) Empty
+            else rights.reduceLeft((x, y) => Append(y, x))
+          rights.clear()
+        case Empty =>
+          if (rights.isEmpty) {
+            c = null
+          } else {
+            c = rights.last
+            rights.trimEnd(1)
+          }
+      }
+    }
+  }
+  // scalastyle:on null return cyclomatic.complexity
+
+
+  final def iterator: Iterator[A] = this match {
+    case Wrap(seq) => seq.iterator
+    case _ => new ChainIterator[A](this)
+  }
+
+  final def reverseIterator: Iterator[A] = this match {
+    case Wrap(seq) => seq.reverseIterator
+    case _ => new ChainReverseIterator[A](this)
+  }
+
+  /**
+   * Returns the number of elements in this structure
+   */
+  final def length: Int = {
+    val iter = iterator
+    var i: Int = 0
+    while(iter.hasNext) { i += 1; iter.next; }
+    i
+  }
+
+  /**
+   * Alias for length
+   */
+  final def size: Int = length
+
+
+  /**
+   * Converts to a list.
+   */
+  final def toList: List[A] =
+    iterator.toList
+
+  /**
+   * Converts to a vector.
+   */
+  final def toVector: Vector[A] =
+    iterator.toVector
+
+  /**
+   * Typesafe equality operator.
+   *
+   * This method is similar to == except that it only allows two
+   * Chain[A] values to be compared to each other, and uses
+   * equality provided by Eq[_] instances, rather than using the
+   * universal equality provided by .equals.
+   */
+  def ===[AA >: A](that: Chain[AA])(implicit A: Eq[AA]): Boolean =
+    (this eq that) || {
+      val iterX = iterator
+      val iterY = that.iterator
+      while (iterX.hasNext && iterY.hasNext) {
+        // scalastyle:off return
+        if (!A.eqv(iterX.next, iterY.next)) return false
+        // scalastyle:on return
+      }
+
+      iterX.hasNext == iterY.hasNext
+    }
+
+  def show[AA >: A](implicit AA: Show[AA]): String = {
+    val builder = new StringBuilder("Chain(")
+    var first = true
+
+    foreach { a =>
+      if (first) { builder ++= AA.show(a); first = false }
+      else builder ++= ", " + AA.show(a)
+      ()
+    }
+    builder += ')'
+    builder.result
+  }
+
+  override def toString: String = show(Show.show[A](_.toString))
+}
+
+object Chain extends ChainInstances {
+
+  private val sentinel: Function1[Any, Any] = new scala.runtime.AbstractFunction1[Any, Any]{ def apply(a: Any) = this }
+
+  private[data] final case object Empty extends Chain[Nothing] {
+    def isEmpty: Boolean = true
+  }
+  private[data] final case class Singleton[A](a: A) extends Chain[A] {
+    def isEmpty: Boolean = false
+  }
+  private[data] final case class Append[A](left: Chain[A], right: Chain[A])
+    extends Chain[A] {
+    def isEmpty: Boolean =
+      false // b/c `concat` constructor doesn't allow either branch to be empty
+  }
+  private[data] final case class Wrap[A](seq: Seq[A]) extends Chain[A] {
+    override def isEmpty: Boolean =
+      false // b/c `fromSeq` constructor doesn't allow either branch to be empty
+  }
+
+  /** Empty Chain. */
+  val nil: Chain[Nothing] = Empty
+
+  def empty[A]: Chain[A] = nil
+
+  /** Creates a Chain of 1 element. */
+  def one[A](a: A): Chain[A] = Singleton(a)
+
+  /** Concatenates two Chains. */
+  def concat[A](c: Chain[A], c2: Chain[A]): Chain[A] =
+    if (c.isEmpty) c2
+    else if (c2.isEmpty) c
+    else Append(c, c2)
+
+  /** Creates a Chain from the specified sequence. */
+  def fromSeq[A](s: Seq[A]): Chain[A] =
+    if (s.isEmpty) nil
+    else if (s.lengthCompare(1) == 0) one(s.head)
+    else Wrap(s)
+
+  /** Creates a Chain from the specified elements. */
+  def apply[A](as: A*): Chain[A] =
+    as match {
+      case w: collection.mutable.WrappedArray[A] =>
+        if (w.isEmpty) nil
+        else if (w.size == 1) one(w.head)
+        else {
+          val arr: Array[A] = w.array
+          var c: Chain[A] = one(arr.last)
+          var idx = arr.size - 2
+          while (idx >= 0) {
+            c = Append(one(arr(idx)), c)
+            idx -= 1
+          }
+          c
+        }
+      case _ => fromSeq(as)
+    }
+
+  // scalastyle:off null
+  class ChainIterator[A](self: Chain[A]) extends Iterator[A] {
+    var c: Chain[A] = if (self.isEmpty) null else self
+    val rights = new collection.mutable.ArrayBuffer[Chain[A]]
+    var currentIterator: Iterator[A] = null
+
+    override def hasNext: Boolean = (c ne null) || ((currentIterator ne null) && currentIterator.hasNext)
+
+    override def next(): A = {
+      @tailrec def go: A =
+        if ((currentIterator ne null) && currentIterator.hasNext)
+          currentIterator.next()
+        else {
+          currentIterator = null
+
+          c match {
+            case Singleton(a) =>
+              c =
+                if (rights.isEmpty) null
+                else rights.reduceLeft((x, y) => Append(y, x))
+              rights.clear()
+              a
+            case Append(l, r) =>
+              c = l
+              rights += r
+              go
+            case Wrap(seq) =>
+              c =
+                if (rights.isEmpty) null
+                else rights.reduceLeft((x, y) => Append(y, x))
+              rights.clear()
+              currentIterator = seq.iterator
+              currentIterator.next
+            case Empty =>
+              go // This shouldn't happen
+          }
+        }
+
+      go
+    }
+  }
+  // scalastyle:on null
+
+
+  // scalastyle:off null
+  class ChainReverseIterator[A](self: Chain[A]) extends Iterator[A] {
+    var c: Chain[A] = if (self.isEmpty) null else self
+    val lefts = new collection.mutable.ArrayBuffer[Chain[A]]
+    var currentIterator: Iterator[A] = null
+
+    override def hasNext: Boolean = (c ne null) || ((currentIterator ne null) && currentIterator.hasNext)
+
+    override def next(): A = {
+      @tailrec def go: A =
+        if ((currentIterator ne null) && currentIterator.hasNext)
+          currentIterator.next()
+        else {
+          currentIterator = null
+
+          c match {
+            case Singleton(a) =>
+              c =
+                if (lefts.isEmpty) null
+                else lefts.reduceLeft((x, y) => Append(x, y))
+              lefts.clear()
+              a
+            case Append(l, r) =>
+              c = r
+              lefts += l
+              go
+            case Wrap(seq) =>
+              c =
+                if (lefts.isEmpty) null
+                else lefts.reduceLeft((x, y) => Append(x, y))
+              lefts.clear()
+              currentIterator = seq.reverseIterator
+              currentIterator.next
+            case Empty =>
+              go // This shouldn't happen
+          }
+        }
+
+      go
+    }
+  }
+  // scalastyle:on null
+}
+
+private[data] sealed abstract class ChainInstances extends ChainInstances1 {
+  implicit def catsDataMonoidForChain[A]: Monoid[Chain[A]] = new Monoid[Chain[A]] {
+    def empty: Chain[A] = Chain.nil
+    def combine(c: Chain[A], c2: Chain[A]): Chain[A] = Chain.concat(c, c2)
+  }
+
+  implicit val catsDataInstancesForChain: Traverse[Chain] with Alternative[Chain]
+    with Monad[Chain] with CoflatMap[Chain] =
+    new Traverse[Chain] with Alternative[Chain] with Monad[Chain] with CoflatMap[Chain] {
+      def foldLeft[A, B](fa: Chain[A], b: B)(f: (B, A) => B): B =
+        fa.foldLeft(b)(f)
+      def foldRight[A, B](fa: Chain[A], lb: Eval[B])(f: (A, Eval[B]) => Eval[B]): Eval[B] =
+        Eval.defer(fa.foldRight(lb) { (a, lb) =>
+          Eval.defer(f(a, lb))
+        })
+
+      override def map[A, B](fa: Chain[A])(f: A => B): Chain[B] = fa.map(f)
+      override def toList[A](fa: Chain[A]): List[A] = fa.toList
+      override def isEmpty[A](fa: Chain[A]): Boolean = fa.isEmpty
+      override def exists[A](fa: Chain[A])(p: A => Boolean): Boolean = fa.exists(p)
+      override def forall[A](fa: Chain[A])(p: A => Boolean): Boolean = fa.forall(p)
+      override def find[A](fa: Chain[A])(f: A => Boolean): Option[A] = fa.find(f)
+
+      def coflatMap[A, B](fa: Chain[A])(f: Chain[A] => B): Chain[B] = {
+        @tailrec def go(as: Chain[A], res: ListBuffer[B]): Chain[B] =
+          as.uncons match {
+            case Some((h, t)) => go(t, res += f(t))
+            case None => Chain.fromSeq(res.result())
+          }
+
+        go(fa, ListBuffer.empty)
+      }
+
+      def traverse[G[_], A, B](fa: Chain[A])(f: A => G[B])(implicit G: Applicative[G]): G[Chain[B]] =
+        fa.foldRight[G[Chain[B]]](G.pure(nil)) { (a, gcatb) =>
+          G.map2(f(a), gcatb)(_ +: _)
+        }
+      def empty[A]: Chain[A] = Chain.nil
+      def combineK[A](c: Chain[A], c2: Chain[A]): Chain[A] = Chain.concat(c, c2)
+      def pure[A](a: A): Chain[A] = Chain.one(a)
+      def flatMap[A, B](fa: Chain[A])(f: A => Chain[B]): Chain[B] =
+        fa.flatMap(f)
+      def tailRecM[A, B](a: A)(f: A => Chain[Either[A, B]]): Chain[B] = {
+        var acc: Chain[B] = Chain.nil
+        @tailrec def go(rest: List[Chain[Either[A, B]]]): Unit =
+          rest match {
+            case hd :: tl =>
+              hd.uncons match {
+                case Some((hdh, hdt)) =>
+                  hdh match {
+                    case Right(b) =>
+                      acc = acc :+ b
+                      go(hdt :: tl)
+                    case Left(a) =>
+                      go(f(a) :: hdt :: tl)
+                  }
+                case None =>
+                  go(tl)
+              }
+            case _ => ()
+          }
+        go(f(a) :: Nil)
+        acc
+      }
+    }
+
+  implicit def catsDataShowForChain[A](implicit A: Show[A]): Show[Chain[A]] =
+    Show.show[Chain[A]](_.show)
+
+  implicit def catsDataOrderForChain[A](implicit A0: Order[A]): Order[Chain[A]] =
+    new Order[Chain[A]] with ChainPartialOrder[A] {
+      implicit def A: PartialOrder[A] = A0
+      def compare(x: Chain[A], y: Chain[A]): Int = if (x eq y) 0 else {
+        val iterX = x.iterator
+        val iterY = y.iterator
+        while (iterX.hasNext && iterY.hasNext) {
+          val n = A0.compare(iterX.next, iterY.next)
+          // scalastyle:off return
+          if (n != 0) return n
+          // scalastyle:on return
+        }
+
+        if (iterX.hasNext) 1
+        else if (iterY.hasNext) -1
+        else 0
+      }
+    }
+
+}
+
+private[data] sealed abstract class ChainInstances1 extends ChainInstances2 {
+  implicit def catsDataPartialOrderForChain[A](implicit A0: PartialOrder[A]): PartialOrder[Chain[A]] =
+    new ChainPartialOrder[A] { implicit def A: PartialOrder[A] = A0 }
+}
+
+private[data] sealed abstract class ChainInstances2 {
+  implicit def catsDataEqForChain[A](implicit A: Eq[A]): Eq[Chain[A]] = new Eq[Chain[A]] {
+    def eqv(x: Chain[A], y: Chain[A]): Boolean = x === y
+  }
+}
+
+private[data] trait ChainPartialOrder[A] extends PartialOrder[Chain[A]] {
+  implicit def A: PartialOrder[A]
+
+  override def partialCompare(x: Chain[A], y: Chain[A]): Double = if (x eq y) 0.0 else {
+    val iterX = x.iterator
+    val iterY = y.iterator
+    while (iterX.hasNext && iterY.hasNext) {
+      val n = A.partialCompare(iterX.next, iterY.next)
+      // scalastyle:off return
+      if (n != 0.0) return n
+      // scalastyle:on return
+    }
+
+    if (iterX.hasNext) 1.0
+    else if (iterY.hasNext) -1.0
+    else 0.0
+  }
+
+  override def eqv(x: Chain[A], y: Chain[A]): Boolean = x === y
+}
diff --git a/laws/src/main/scala/cats/laws/discipline/Arbitrary.scala b/laws/src/main/scala/cats/laws/discipline/Arbitrary.scala
index c7d077dfd6..fcb6d16ac7 100644
--- a/laws/src/main/scala/cats/laws/discipline/Arbitrary.scala
+++ b/laws/src/main/scala/cats/laws/discipline/Arbitrary.scala
@@ -276,6 +276,20 @@ object arbitrary extends ArbitraryInstances0 {
   implicit def catsLawsCogenForAndThen[A, B](implicit F: Cogen[A => B]): Cogen[AndThen[A, B]] =
     Cogen((seed, x) => F.perturb(seed, x))
 
+  implicit def catsLawsArbitraryForChain[A](implicit A: Arbitrary[A]): Arbitrary[Chain[A]] =
+    Arbitrary(Gen.sized {
+      case 0 => Gen.const(Chain.nil)
+      case 1 => A.arbitrary.map(Chain.one)
+      case 2 => A.arbitrary.flatMap(a1 => A.arbitrary.flatMap(a2 =>
+        Chain.concat(Chain.one(a1), Chain.one(a2))))
+      case n => Chain.fromSeq(Range.apply(0, n)).foldLeft(Gen.const(Chain.empty[A])) { (gen, _) =>
+        gen.flatMap(cat => A.arbitrary.map(a => cat :+ a))
+      }
+    })
+
+  implicit def catsLawsCogenForChain[A](implicit A: Cogen[A]): Cogen[Chain[A]] =
+    Cogen[List[A]].contramap(_.toList)
+
 }
 
 private[discipline] sealed trait ArbitraryInstances0 {
diff --git a/tests/src/test/scala/cats/tests/ChainSuite.scala b/tests/src/test/scala/cats/tests/ChainSuite.scala
new file mode 100644
index 0000000000..a83a3d77d1
--- /dev/null
+++ b/tests/src/test/scala/cats/tests/ChainSuite.scala
@@ -0,0 +1,113 @@
+package cats
+package tests
+
+import cats.data.Chain
+import cats.kernel.laws.discipline.{MonoidTests, OrderTests}
+import cats.laws.discipline.{AlternativeTests, CoflatMapTests, MonadTests, SerializableTests, TraverseTests}
+import cats.laws.discipline.arbitrary._
+
+class ChainSuite extends CatsSuite {
+  checkAll("Chain[Int]", AlternativeTests[Chain].alternative[Int, Int, Int])
+  checkAll("Alternative[Chain]", SerializableTests.serializable(Alternative[Chain]))
+
+  checkAll("Chain[Int] with Option", TraverseTests[Chain].traverse[Int, Int, Int, Set[Int], Option, Option])
+  checkAll("Traverse[Chain]", SerializableTests.serializable(Traverse[Chain]))
+
+  checkAll("Chain[Int]", MonadTests[Chain].monad[Int, Int, Int])
+  checkAll("Monad[Chain]", SerializableTests.serializable(Monad[Chain]))
+
+  checkAll("Chain[Int]", CoflatMapTests[Chain].coflatMap[Int, Int, Int])
+  checkAll("Coflatmap[Chain]", SerializableTests.serializable(CoflatMap[Chain]))
+
+  checkAll("Chain[Int]", MonoidTests[Chain[Int]].monoid)
+  checkAll("Monoid[Chain]", SerializableTests.serializable(Monoid[Chain[Int]]))
+
+  checkAll("Chain[Int]", OrderTests[Chain[Int]].order)
+  checkAll("Order[Chain]", SerializableTests.serializable(Order[Chain[Int]]))
+
+  test("show"){
+    Show[Chain[Int]].show(Chain(1, 2, 3)) should === ("Chain(1, 2, 3)")
+    Chain.empty[Int].show should === ("Chain()")
+    forAll { l: Chain[String] =>
+      l.show should === (l.toString)
+    }
+  }
+
+  test("size is consistent with toList.size") {
+    forAll { (ci: Chain[Int]) =>
+      ci.size should === (ci.toList.size)
+    }
+  }
+
+  test("filterNot and then exists should always be false") {
+    forAll { (ci: Chain[Int], f: Int => Boolean) =>
+      ci.filterNot(f).exists(f) should === (false)
+    }
+  }
+
+  test("filter and then forall should always be true") {
+    forAll { (ci: Chain[Int], f: Int => Boolean) =>
+      ci.filter(f).forall(f) should === (true)
+    }
+  }
+
+  test("exists should be consistent with find + isDefined") {
+    forAll { (ci: Chain[Int], f: Int => Boolean) =>
+      ci.exists(f) should === (ci.find(f).isDefined)
+    }
+  }
+
+  test("deleteFirst consistent with find") {
+    forAll { (ci: Chain[Int], f: Int => Boolean) =>
+      ci.find(f) should === (ci.deleteFirst(f).map(_._1))
+    }
+  }
+
+  test("filterNot element and then contains should be false") {
+    forAll { (ci: Chain[Int], i: Int) =>
+      ci.filterNot(_ === i).contains(i) should === (false)
+    }
+  }
+
+  test("Always nonempty after cons") {
+    forAll { (ci: Chain[Int], i: Int) =>
+      (i +: ci).nonEmpty should === (true)
+    }
+  }
+
+  test("fromSeq . toVector is id") {
+    forAll { (ci: Chain[Int]) =>
+      Chain.fromSeq(ci.toVector) should === (ci)
+    }
+  }
+
+  test("fromSeq . toList . iterator is id") {
+    forAll { (ci: Chain[Int]) =>
+      Chain.fromSeq(ci.iterator.toList) should === (ci)
+    }
+  }
+
+  test("zipWith consistent with List#zip and then List#map") {
+    forAll { (a: Chain[String], b: Chain[Int], f: (String, Int) => Int) =>
+      a.zipWith(b)(f).toList should === (a.toList.zip(b.toList).map { case (x, y) => f(x, y) })
+    }
+  }
+
+  test("groupBy consistent with List#groupBy") {
+    forAll { (cs: Chain[String], f: String => Int) =>
+      cs.groupBy(f).map { case (k, v) => (k, v.toList) }.toMap should === (cs.toList.groupBy(f).toMap)
+    }
+  }
+
+  test("reverse . reverse is id") {
+    forAll { (ci: Chain[Int]) =>
+      ci.reverse.reverse should === (ci)
+    }
+  }
+
+  test("reverse consistent with List#reverse") {
+    forAll { (ci: Chain[Int]) =>
+      ci.reverse.toList should === (ci.toList.reverse)
+    }
+  }
+}