catbird 0.9.0

This release updates the Cats version to 0.8.1 and Finagle to 6.40.0, and introduces Scala 2.12 support for catbird-util (although not yet for catbird-finagle, since Finagle is not yet published for 2.12).

We are also no longer publishing catbird-bijections, which had shrunk to a single injection in 0.8.0 and (to the best of my knowledge) was not being used by anyone.

catbird 0.8.0

This release updates the Cats version to 0.8.0 and Finagle to 6.39.0.

The biggest change to the code is related to the removal of cats.data.Xor in Cats 0.8.0 (in favor of the standard library's Either). The io.catbird.bijections.util package has been removed altogether, since the only conversions it included involved Xor.

catbird 0.7.0

Most of the changes in this release are related to the update to Cats 0.7.0, but there are a couple of unrelated changes:

• Eq instances for Try and Future now require an Eq instance for Throwable (instead of simply using universal equality).
• Several type class instances have been renamed for consistency. This will not affect normal usage, but if you're referring to these instances explicitly, you'll need to update the names.

catbird 0.6.0

This release updates the Finagle version to 6.36.0 and removes support for Scala 2.10 and Java 7.

catbird 0.5.0

This release updates the Cats version to 0.6.0.

catbird 0.4.0

This release updates the Finagle, Util, and Cats versions to 6.35.0, 6.34.0, and 0.5.0 respectively and includes one other change: the names of type class instances for Twitter futures are more specific to avoid shadowing (or getting shadowed by) the standard library future instances in Cats (thanks, @aeons!).

catbird 0.3.0

New bijection module

There are two major changes in this release. The first is that the catbird-util and catbird-finagle modules no longer depend on Twitter Bijection, and the bijections have been moved to a new catbird-bijection module.

Rerunnables

The other major change is the introduction of a new io.catbird.util.Rerunnable that wraps com.twitter.util.Future and provides the ability to suspend computations (they don't automatically start on definition) and rerun them:

scala> import io.catbird.util.Rerunnable
import io.catbird.util.Rerunnable

scala> val action = Rerunnable(println("Firing missiles"))
action: io.catbird.util.Rerunnable[Unit] = io.catbird.util.Rerunnable$$anon$8@66b0af20

scala> action.run
Firing missiles
res0: com.twitter.util.Future[Unit] = ConstFuture(Return(()))

scala> action.run
Firing missiles
res1: com.twitter.util.Future[Unit] = ConstFuture(Return(()))

Rerunnable maintains stack safety by reifying binds and reassociating them when you "run" the computation to get a Future.

Rerunnable should be considered experimental for now, but may be used in a future release of Finch (see e.g. the discussion, benchmarks, etc. here).

Other changes

There are a few minor changes to instances (Future now has a MonadError instance, not just Monad, etc.) and the Util and Finagle dependencies have been updated to the latest versions (6.33.0 and 6.34.0 respectively).