Adding libs
Adding project definition and scalacheck dep
Adding some test data
Define the interface we want for the base classes

To avoid method collisions, we're renaming `ObjectMapper`'s `parseTree` to
just `parse`. Since parseTree throws exceptions on failure, we'll return an
instance of `util.Try`.

For `JsonNode`, we'll use `apply` and `lift`, which should make accessing
properties feel nearly native.
Define the implicit conversion functions

We'll need to enable implicit conversions, either by enabling the flag
`-language:implicitConversions` on `scalac`, or by adding
`import scala.language.implicitConversions` to every file you will
use implicit conversions in.
Implemement JsonNode's lift and apply

Since `JsonNode.get(...)` can take either a string (accessing Object
properties) or an int (accessing array elements), we need a good, typesafe
way to wrap this overloaded function.

Type classes provide a great way to wrap overloaded functions. Define only
the types that work, let the compiler catch type errors for you.

--

"Why not just use the overloaded methods?" you might ask. One of the easiest
cases to make is that it confuses type inference. `node.get _` now needs
an explicit type.

For more examples, please check out the answers here:
http://stackoverflow.com/questions/2510108/why-avoid-method-overloading
Implement ObjectMapper.parse(...)

Continuing with type classes, we define `Readable.read(...)` for supported types
Adding Helpers

To create JSON structures, it would be more helpful to have some helpers
to wrap the cumbersome Java classes. Let's define some.
Add some tests for ObjectMapper

ObjectMapper's first purpose is to parse JSON, so let's see if it can.

We can use `Try`'s `.isSuccess` and `.isFailure` here, but for real code
you'd probably want to `match` on `Success(x)` and `Failure(e: Throwable)`.
Adding tests for JsonNode

Defining some tests for `JsonNode`. `Try` is only relevant when parsing data,
so we switch it to an `Option` then proceed to work with it.

Additionally, in the spirit of DRY, let's break out the `ObjectMapper` builder
into a trait.
Add tests for Helper object

Each of our helpers should return the JSON representation from `.toString`
Wrap Option[JsonNode] to provide a cleaner syntax

Since we can provide wrappers around anything, we can also provide a nicer
syntax around `Option[JsonNode]`. `/` will return an Option[JsonNode] at
every step of the way, so it's completly safe to use.
Adding JsonNode.getOrElse(key, fallback)

Since we don't want fallback to be evaluated until it's used, we use
"call by name" parameter passing.
Adding helpers to create Objects and Arrays