define types and specs

Author: nrednav

lib/msgpack.ex

@@ -342,6 +342,7 @@ defmodule Msgpack do
   ]
   ```
   """
+  @spec encode_stream(Enumerable.t(), StreamEncoder.opts_t()) :: StreamEncoder.t()
   def encode_stream(enumerable, opts \\ []) do
     StreamEncoder.encode(enumerable, opts)
   end
@@ -370,6 +371,7 @@ defmodule Msgpack do
   [1, "elixir", true]
   ```
   """
+  @spec decode_stream(Enumerable.t(binary()), StreamDecoder.opts_t()) :: StreamDecoder.t()
   def decode_stream(enumerable, opts \\ []) do
     StreamDecoder.decode(enumerable, opts)
   end

lib/msgpack/stream_decoder.ex

@@ -23,6 +23,12 @@ defmodule Msgpack.StreamDecoder do
   alias Msgpack.Decoder
   alias Msgpack.Decoder.Internal
 
+  @typedoc "A stream that yields decoded Elixir terms."
+  @type t :: Stream.t()
+
+  @typedoc "Options passed to the decoder."
+  @type opts_t :: keyword()
+
   @doc """
   Lazily decodes an enumerable of MessagePack binaries into a stream of Elixir
   terms.
@@ -70,6 +76,7 @@ defmodule Msgpack.StreamDecoder do
   [{:error, :unexpected_eof}]
   ```
   """
+  @spec decode(Enumerable.t(binary()), opts_t()) :: t()
   def decode(enumerable, opts \\ []) do
     start_fun = fn ->
       merged_opts = Keyword.merge(Decoder.default_opts(), opts)
@@ -82,6 +89,8 @@ defmodule Msgpack.StreamDecoder do
     Stream.transform(stream_with_eof, start_fun.(), transform_fun)
   end
 
+  @doc false
+  @spec transform_chunk(binary() | :eof, {binary(), opts_t()}) :: {list(), {binary(), opts_t() | nil}}
   defp transform_chunk(:eof, {<<>>, _opts}) do
     {[], {<<>>, nil}}
   end
@@ -95,6 +104,8 @@ defmodule Msgpack.StreamDecoder do
     {decoded_terms, {leftover_buffer, opts}}
   end
 
+  @doc false
+  @spec do_transform(binary(), opts_t(), list()) :: {list(), binary()}
   defp do_transform(<<>>, _opts, acc) do
     {Enum.reverse(acc), <<>>}
   end

lib/msgpack/stream_encoder.ex

@@ -12,6 +12,15 @@ defmodule Msgpack.StreamEncoder do
   not be encoded.
   """
 
+  @typedoc "A stream that yields encoded MessagePack objects."
+  @type t :: Stream.t(result_t())
+
+  @typedoc "An individual result from the encoding stream."
+  @type result_t :: {:ok, binary()} | {:error, any()}
+
+  @typedoc "Options passed to the encoder."
+  @type opts_t :: keyword()
+
   @doc """
   Lazily encodes an enumerable of Elixir terms into a stream of result tuples.
 
@@ -57,6 +66,7 @@ defmodule Msgpack.StreamEncoder do
   ]
   ```
   """
+  @spec encode(Enumerable.t(), opts_t()) :: t()
   def encode(enumerable, opts \\ []) do
     Stream.map(enumerable, &Msgpack.encode(&1, opts))
   end