add module documentation and bump version for publishing

Author: CrowdHailer

Diff for: .gitignore

@@ -1,5 +1,7 @@
 /_build
 /cover
 /deps
+/docs
+/doc
 erl_crash.dump
 *.ez

Diff for: README.md

@@ -2,6 +2,8 @@
 
 **Effecient error handling in elixir pipelines. See [Handling Errors in Elixir](http://insights.workshop14.io/2015/10/18/handling-errors-in-elixir-no-one-say-monad.html) for a more detailed explination**
 
+[Documentation for OK is available on hexdoc](https://hexdocs.pm/ok)
+
 ## Installation
 
 [Available in Hex](https://hex.pm/docs/publish), the package can be installed as:
@@ -12,10 +14,6 @@
           [{:ok, "~> 0.0.1"}]
         end
 
-  2. Refetch the dependencies, execute:
-
-        $ mix deps.get
-
 ## Usage
 
 The OK module works with the native error handling in Erlang/Elixir, that is a result tuple.
@@ -25,21 +23,6 @@ A result tuple is a two-tuple tagged either as a success(`:ok`) or a failure(`:e
 {:ok, value} | {:error, reason}
 ```
 
-### Bind
-
-The primary functionality is the `OK.bind/2` function.
-This function takes a result tuple and a next function.
-If the result tuple is tagged as a success then it will be passed to the next function.
-If the tag is failure then the next function is skipped
-
-```elixir
-OK.bind({:ok, 2}, fn (x) -> {:ok, 2 * x} end)
-# => {:ok, 4}
-
-OK.bind({:error, :some_reason}, fn (x) -> {:ok, 2 * x} end)
-# => {:error, :some_reason}
-```
-
 ### '~>>' Macro
 
 This macro allows pipelining results through a pipeline of anonymous functions.
@@ -62,22 +45,3 @@ def handle_user_data({:error, :key_not_found}), do: IO.puts("Could not find empl
 get_employee_data("my_company/employees.json")
 |> handle_user_data
 ```
-
-### Success
-
-Wraps a value in a successful result tuple.
-
-```elixir
-OK.success(:value)
-# => {:ok, :value}
-```
-
-### Failure
-
-Wraps a reason in a failure result tuple.
-
-```elixir
-Ok.failure("reason")
-# => {:error, "reason"}
-```
-

Diff for: lib/ok.ex

@@ -1,9 +1,67 @@
 defmodule OK do
+  @moduledoc """
+  The `OK` module enables clean and expressive error handling in pipelines.
+
+  Many Elixir libraries follow the tagged tuple convention for functions that will not alway return a valid response.
+  In case of a success the value is returned in an `:ok` tagged tuple.
+  If the function fails then a reason is returned in an `:error` tagged tuple.
+
+  Calling code the matches on these two possible outcomes.
+
+  ```elixir
+  case my_func(args) do
+    {:ok, value} ->
+      do_more(value) # continue with subsequent processing
+    {:error, reason} ->
+      {:error, reason} # return early.
+  end
+  ```
+
+  `OK` allows this code to be replaced by a result pipeline.
+
+  ```elixir
+  my_func(args)
+  ~>> &do_more/1
+  ```
+
+  *`OK` treates the combination of tagged tuples `{:ok, value} | {:error, reason}` as a result monad.
+  The result monad is sometimes know as the try or either monad.*
+  """
+
+  @doc """
+  Takes a result tuple and a next function.
+  If the result tuple is tagged as a success then its value will be passed to the next function.
+  If the tag is failure then the next function is skipped.
+
+  ## Examples
+
+      iex> OK.bind({:ok, 2}, fn (x) -> {:ok, 2 * x} end)
+      {:ok, 4}
+
+      iex> OK.bind({:error, :some_reason}, fn (x) -> {:ok, 2 * x} end)
+      {:error, :some_reason}
+  """
   def bind({:ok, value}, func) when is_function(func, 1), do: func.(value)
   def bind(failure = {:error, _reason}, _func), do: failure
 
+  @doc """
+  Wraps a value as a successful result tuple.
+
+  ## Examples
+
+      iex> OK.success(:value)
+      {:ok, :value}
+  """
   def success(value), do: {:ok, value}
 
+  @doc """
+  Creates a failed result tuple with the given reason.
+
+  ## Examples
+
+      iex> OK.failure("reason")
+      {:error, "reason"}
+  """
   def failure(reason), do: {:error, reason}
 
   defmacro lhs ~>> rhs do

Diff for: mix.exs

@@ -3,33 +3,24 @@ defmodule OK.Mixfile do
 
   def project do
     [app: :ok,
-     version: "0.1.3",
+     version: "0.1.4",
      elixir: "~> 1.1",
      build_embedded: Mix.env == :prod,
      start_permanent: Mix.env == :prod,
      deps: deps,
-     package: package,
-     description: description]
+     description: description,
+     docs: [extras: ["README.md"], main: "readme"],
+     package: package]
   end
 
-  # Configuration for the OTP application
-  #
-  # Type "mix help compile.app" for more information
   def application do
     [applications: [:logger]]
   end
 
-  # Dependencies can be Hex packages:
-  #
-  #   {:mydep, "~> 0.3.0"}
-  #
-  # Or git/path repositories:
-  #
-  #   {:mydep, git: "https://github.com/elixir-lang/mydep.git", tag: "0.1.0"}
-  #
-  # Type "mix help deps" for more examples and options
   defp deps do
-    []
+    [
+      {:ex_doc, ">= 0.0.0", only: :dev}
+    ]
   end
 
   defp description do