Mergemiles

.travis.yml

@@ -4,7 +4,7 @@ git:
   depth: 9999
 
 scala:
-- 2.10.5
+- 2.10.6
 - 2.11.7
 
 cache:

AUTHORS.md

@@ -14,47 +14,66 @@ possible:
 
  * Adelbert Chang
  * Alessandro Lacava
+ * Alexey Levan
  * Alissa Pajer
  * Alistair Johnson
  * Amir Mohammad Saied
  * Andrew Jones
+ * Antoine Comte
  * Arya Irani
+ * Ash Pook
  * Benjamin Thuillier
- * Bobby
+ * Bobby Rauchenberg
  * Brendan McAdams
  * Cody Allen
  * Colt Frederickson
  * Dale Wijnand
  * Dave Rostron
  * David Allsopp
+ * David Gregory
+ * Denis Mikhaylov
  * Derek Wickern
  * Edmund Noble
+ * Erik LaBianca
  * Erik Osheim
  * Eugene Burmako
  * Eugene Yokota
  * Feynman Liang
  * Frank S. Thomas
+ * Jean-Rémi Desjardins
  * Jisoo Park
  * Josh Marcus
+ * Julien Richard-Foy
  * Julien Truffaut
  * Kenji Yoshida
+ * Long Cao
  * Luis Angel Vicente Sanchez
+ * Luke Wyman
  * Marc Siegel
+ * Markus Hauck
+ * Matthias Lüneberg
  * Michael Pilquist
  * Mike Curry
  * Miles Sabin
+ * Olli Helenius
  * Owen Parry
  * Pascal Voitot
+ * Paul Phillips
  * Philip Wills
+ * Raúl Raja Martínez
  * Rintcius Blok
  * Rob Norris
  * Romain Ruetschi
  * Ross A. Baker
+ * Sarunas Valaskevicius
+ * Shunsuke Otani
  * Sinisa Louc
  * Stephen Judkins
  * Stew O'Connor
+ * Sumedh Mungee
  * Travis Brown
  * Wedens
+ * Yosef Fertel
  * Zach Abbott
 
 We've tried to include everyone, but if you've made a contribution to

CONTRIBUTING.md

@@ -115,7 +115,7 @@ Write about https://github.com/non/cats/pull/36#issuecomment-72892359
 ### Write tests
 
 - Tests for cats-core go into the tests module, under the `cats.tests` package.
-- Tests for additional modules, such as `free`, go into the tests directory within that module.  
+- Tests for additional modules, such as 'jvm', go into the tests directory within that module.
 - Cats tests should extend `CatsSuite`.  `CatsSuite` integrates [ScalaTest](http://www.scalatest.org/)
 with [Discipline](https://github.com/typelevel/discipline) for law checking, and imports all syntax and standard instances for convenience.
 - The first parameter to the `checkAll` method provided by

README.md

@@ -1,7 +1,7 @@
 ## Cats
 
-[![Build Status](https://api.travis-ci.org/non/cats.png)](https://travis-ci.org/non/cats)
-[![Workflow](https://badge.waffle.io/non/cats.png?label=ready&title=Ready)](https://waffle.io/non/cats)
+[![Build Status](https://api.travis-ci.org/non/cats.svg)](https://travis-ci.org/non/cats)
+[![Workflow](https://badge.waffle.io/non/cats.svg?label=ready&title=Ready)](https://waffle.io/non/cats)
 [![Chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/non/cats)
 [![codecov.io](http://codecov.io/github/non/cats/coverage.svg?branch=master)](http://codecov.io/github/non/cats?branch=master)
 [![Maven Central](https://img.shields.io/maven-central/v/org.spire-math/cats_2.11.svg)](https://maven-badges.herokuapp.com/maven-central/org.spire-math/cats_2.11)
@@ -33,8 +33,6 @@ functionality, you can pick-and-choose from amongst these modules
  * `cats-macros`: Macros used by Cats syntax (*required*).
  * `cats-core`: Core type classes and functionality (*required*).
  * `cats-laws`: Laws for testing type class instances.
- * `cats-free`: "Free" data constructors for various type classes.
- * `cats-state`: Monad and transformer support for state.
 
 Release notes for Cats are available in [CHANGES.md](CHANGES.md).
 
@@ -113,8 +111,6 @@ Initially Cats will support the following modules:
  * `macros`: Macro definitions needed for `core` and other projects.
  * `core`: Definitions for widely-used type classes and data types.
  * `laws`: The encoded laws for type classes, exported to assist third-party testing.
- * `free`: "Free" data constructors for various type classes.
- * `state`: Monad and transformer support for state.
  * `tests`: Verifies the laws, and runs any other tests. Not published.
 
 As the type class families grow, it's possible that additional modules

build.sbt

@@ -15,7 +15,7 @@ lazy val scoverageSettings = Seq(
 lazy val buildSettings = Seq(
   organization := "org.spire-math",
   scalaVersion := "2.11.7",
-  crossScalaVersions := Seq("2.10.5", "2.11.7")
+  crossScalaVersions := Seq("2.10.6", "2.11.7")
 )
 
 lazy val catsDoctestSettings = Seq(
@@ -30,14 +30,15 @@ lazy val commonSettings = Seq(
     Resolver.sonatypeRepo("snapshots")
   ),
   libraryDependencies ++= Seq(
-    "com.github.mpilquist" %%% "simulacrum" % "0.5.0",
+    "com.github.mpilquist" %%% "simulacrum" % "0.6.1",
     "org.spire-math" %%% "algebra" % "0.3.1",
     "org.spire-math" %%% "algebra-std" % "0.3.1",
     "org.typelevel" %%% "machinist" % "0.4.1",
     compilerPlugin("org.scalamacros" %% "paradise" % "2.1.0-M5" cross CrossVersion.full),
     compilerPlugin("org.spire-math" %% "kind-projector" % "0.6.3")
   ),
-  parallelExecution in Test := false
+  parallelExecution in Test := false,
+  scalacOptions in (Compile, doc) := (scalacOptions in (Compile, doc)).value.filter(_ != "-Xfatal-warnings")
 ) ++ warnUnusedImport
 
 lazy val commonJsSettings = Seq(
@@ -62,12 +63,13 @@ lazy val disciplineDependencies = Seq(
 
 lazy val docSettings = Seq(
   autoAPIMappings := true,
-  unidocProjectFilter in (ScalaUnidoc, unidoc) := inProjects(coreJVM, freeJVM, stateJVM),
+  unidocProjectFilter in (ScalaUnidoc, unidoc) := inProjects(coreJVM),
   site.addMappingsToSiteDir(mappings in (ScalaUnidoc, packageDoc), "api"),
   site.addMappingsToSiteDir(tut, "_tut"),
   ghpagesNoJekyll := false,
   siteMappings += file("CONTRIBUTING.md") -> "contributing.md",
   scalacOptions in (ScalaUnidoc, unidoc) ++= Seq(
+    "-Xfatal-warnings",
     "-doc-source-url", scmInfo.value.get.browseUrl + "/tree/master€{FILE_PATH}.scala",
     "-sourcepath", baseDirectory.in(LocalRootProject).value.getAbsolutePath,
     "-diagrams"
@@ -87,7 +89,7 @@ lazy val docs = project
   .settings(tutSettings)
   .settings(tutScalacOptions ~= (_.filterNot(Set("-Ywarn-unused-import", "-Ywarn-dead-code"))))
   .settings(commonJvmSettings)
-  .dependsOn(coreJVM, freeJVM, stateJVM)
+  .dependsOn(coreJVM)
 
 lazy val cats = project.in(file("."))
   .settings(moduleName := "root")
@@ -100,15 +102,15 @@ lazy val catsJVM = project.in(file(".catsJVM"))
   .settings(moduleName := "cats")
   .settings(catsSettings)
   .settings(commonJvmSettings)
-  .aggregate(macrosJVM, coreJVM, lawsJVM, freeJVM, stateJVM, testsJVM, jvm, docs, bench)
-  .dependsOn(macrosJVM, coreJVM, lawsJVM, freeJVM, stateJVM, testsJVM % "test-internal -> test", jvm, bench % "compile-internal;test-internal -> test")
+  .aggregate(macrosJVM, coreJVM, lawsJVM, testsJVM, jvm, docs, bench)
+  .dependsOn(macrosJVM, coreJVM, lawsJVM, testsJVM % "test-internal -> test", jvm, bench % "compile-internal;test-internal -> test")
 
 lazy val catsJS = project.in(file(".catsJS"))
   .settings(moduleName := "cats")
   .settings(catsSettings)
   .settings(commonJsSettings)
-  .aggregate(macrosJS, coreJS, lawsJS, freeJS, stateJS, testsJS, js)
-  .dependsOn(macrosJS, coreJS, lawsJS, freeJS, stateJS, testsJS % "test-internal -> test", js)
+  .aggregate(macrosJS, coreJS, lawsJS, testsJS, js)
+  .dependsOn(macrosJS, coreJS, lawsJS, testsJS % "test-internal -> test", js)
   .enablePlugins(ScalaJSPlugin)
 
 
@@ -151,26 +153,6 @@ lazy val laws = crossProject.crossType(CrossType.Pure)
 lazy val lawsJVM = laws.jvm
 lazy val lawsJS = laws.js
 
-lazy val free = crossProject.crossType(CrossType.Pure)
-  .dependsOn(macros, core, tests % "test-internal -> test")
-  .settings(moduleName := "cats-free")
-  .settings(catsSettings:_*)
-  .jsSettings(commonJsSettings:_*)
-  .jvmSettings(commonJvmSettings:_*)
-
-lazy val freeJVM = free.jvm
-lazy val freeJS = free.js
-
-lazy val state = crossProject.crossType(CrossType.Pure)
-  .dependsOn(macros, core, free % "compile-internal;test-internal -> test", tests % "test-internal -> test")
-  .settings(moduleName := "cats-state")
-  .settings(catsSettings:_*)
-  .jsSettings(commonJsSettings:_*)
-  .jvmSettings(commonJvmSettings:_*)
-
-lazy val stateJVM = state.jvm
-lazy val stateJS = state.js
-
 lazy val tests = crossProject.crossType(CrossType.Pure)
   .dependsOn(macros, core, laws)
   .settings(moduleName := "cats-tests")
@@ -194,7 +176,7 @@ lazy val jvm = project
   .settings(commonJvmSettings:_*)
 
 // bench is currently JVM-only
-lazy val bench = project.dependsOn(macrosJVM, coreJVM, freeJVM, lawsJVM)
+lazy val bench = project.dependsOn(macrosJVM, coreJVM, lawsJVM)
   .settings(moduleName := "cats-bench")
   .settings(catsSettings)
   .settings(noPublishSettings)
@@ -227,11 +209,11 @@ lazy val publishSettings = Seq(
 ) ++ credentialSettings ++ sharedPublishSettings ++ sharedReleaseProcess 
 
 // These aliases serialise the build for the benefit of Travis-CI.
-addCommandAlias("buildJVM", ";macrosJVM/compile;coreJVM/compile;coreJVM/test;freeJVM/compile;freeJVM/test;stateJVM/compile;stateJVM/test;lawsJVM/compile;testsJVM/test;jvm/test;bench/test")
+addCommandAlias("buildJVM", ";macrosJVM/compile;coreJVM/compile;coreJVM/test;lawsJVM/compile;testsJVM/test;jvm/test;bench/test")
 
 addCommandAlias("validateJVM", ";scalastyle;buildJVM;makeSite")
 
-addCommandAlias("validateJS", ";macrosJS/compile;coreJS/compile;lawsJS/compile;testsJS/test;js/test;freeJS/compile;freeJS/test;stateJS/compile;stateJS/test")
+addCommandAlias("validateJS", ";macrosJS/compile;coreJS/compile;lawsJS/compile;testsJS/test;js/test")
 
 addCommandAlias("validate", ";validateJS;validateJVM")
 

core/src/main/scala/cats/ApplicativeError.scala

@@ -0,0 +1,81 @@
+package cats
+
+import cats.data.{Xor, XorT}
+
+/**
+ * An applicative that also allows you to raise and or handle an error value.
+ *
+ * This type class allows one to abstract over error-handling applicatives.
+ */
+trait ApplicativeError[F[_], E] extends Applicative[F] {
+  /**
+   * Lift an error into the `F` context.
+   */
+  def raiseError[A](e: E): F[A]
+
+  /**
+   * Handle any error, potentially recovering from it, by mapping it to an
+   * `F[A]` value.
+   *
+   * @see [[handleError]] to handle any error by simply mapping it to an `A`
+   * value instead of an `F[A]`.
+   *
+   * @see [[recoverWith]] to recover from only certain errors.
+   */
+  def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
+
+  /**
+   * Handle any error, by mapping it to an `A` value.
+   *
+   * @see [[handleErrorWith]] to map to an `F[A]` value instead of simply an
+   * `A` value.
+   *
+   * @see [[recover]] to only recover from certain errors.
+   */
+  def handleError[A](fa: F[A])(f: E => A): F[A] = handleErrorWith(fa)(f andThen pure)
+
+  /**
+   * Handle errors by turning them into [[cats.data.Xor.Left]] values.
+   *
+   * If there is no error, then an [[cats.data.Xor.Right]] value will be returned instead.
+   *
+   * All non-fatal errors should be handled by this method.
+   */
+  def attempt[A](fa: F[A]): F[E Xor A] = handleErrorWith(
+    map(fa)(Xor.right[E, A])
+  )(e => pure(Xor.left(e)))
+
+  /**
+   * Similar to [[attempt]], but wraps the result in a [[cats.data.XorT]] for
+   * convenience.
+   */
+  def attemptT[A](fa: F[A]): XorT[F, E, A] = XorT(attempt(fa))
+
+  /**
+   * Recover from certain errors by mapping them to an `A` value.
+   *
+   * @see [[handleError]] to handle any/all errors.
+   *
+   * @see [[recoverWith]] to recover from certain errors by mapping them to
+   * `F[A]` values.
+   */
+  def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A] =
+    handleErrorWith(fa)(e =>
+      (pf andThen pure) applyOrElse(e, raiseError))
+
+  /**
+   * Recover from certain errors by mapping them to an `F[A]` value.
+   *
+   * @see [[handleErrorWith]] to handle any/all errors.
+   *
+   * @see [[recover]] to recover from certain errors by mapping them to `A`
+   * values.
+   */
+  def recoverWith[A](fa: F[A])(pf: PartialFunction[E, F[A]]): F[A] =
+    handleErrorWith(fa)(e =>
+      pf applyOrElse(e, raiseError))
+}
+
+object ApplicativeError {
+  def apply[F[_], E](implicit F: ApplicativeError[F, E]): ApplicativeError[F, E] = F
+}

core/src/main/scala/cats/Apply.scala

@@ -8,7 +8,7 @@ import simulacrum.typeclass
  * Must obey the laws defined in cats.laws.ApplyLaws.
  */
 @typeclass(excludeParents=List("ApplyArityFunctions"))
-trait Apply[F[_]] extends Functor[F] with Monoidal[F] with ApplyArityFunctions[F] { self =>
+trait Apply[F[_]] extends Functor[F] with Cartesian[F] with ApplyArityFunctions[F] { self =>
 
   /**
    * Given a value and a function in the Apply context, applies the

core/src/main/scala/cats/Cartesian.scala

@@ -0,0 +1,19 @@
+package cats
+
+import simulacrum.typeclass
+
+/**
+ * [[Cartesian]] captures the idea of composing independent effectful values.
+ * It is of particular interest when taken together with [[Functor]] - where [[Functor]]
+ * captures the idea of applying a unary pure function to an effectful value,
+ * calling `product` with `map` allows one to apply a function of arbitrary arity to multiple
+ * independent effectful values.
+ *
+ * That same idea is also manifested in the form of [[Apply]], and indeed [[Apply]] extends both
+ * [[Cartesian]] and [[Functor]] to illustrate this.
+ */
+@typeclass trait Cartesian[F[_]] {
+  def product[A, B](fa: F[A], fb: F[B]): F[(A, B)]
+}
+
+object Cartesian extends CartesianArityFunctions

core/src/main/scala/cats/Eval.scala

@@ -222,8 +222,23 @@ object Eval extends EvalInstances {
    * they will be automatically created when needed.
    */
   sealed abstract class Call[A](val thunk: () => Eval[A]) extends Eval[A] {
-    def memoize: Eval[A] = new Later(() => thunk().value)
-    def value: A = thunk().value
+    def memoize: Eval[A] = new Later(() => value)
+    def value: A = Call.loop(this).value
+  }
+
+  object Call {
+    /** Collapse the call stack for eager evaluations */
+    private def loop[A](fa: Eval[A]): Eval[A] = fa match {
+      case call: Eval.Call[A] =>
+        loop(call.thunk())
+      case compute: Eval.Compute[A] =>
+        new Eval.Compute[A] {
+          type Start = compute.Start
+          val start: () => Eval[Start] = () => compute.start()
+          val run: Start => Eval[A] = s => loop(compute.run(s))
+        }
+      case other => other
+    }
   }
 
   /**