diff --git a/lib/erl/src/thrift.app.src b/lib/erl/src/thrift.app.src
index 32e1721..0e25b67 100644
--- a/lib/erl/src/thrift.app.src
+++ b/lib/erl/src/thrift.app.src
@@ -18,57 +18,34 @@
 %%
 %%% -*- mode:erlang -*-
 {application, thrift, [
-  % A quick description of the application.
-  {description, "Thrift bindings"},
+    % A quick description of the application.
+    {description, "Thrift bindings"},
 
   % The version of the applicaton
   {vsn, "0.20.0"},
 
-  % All modules used by the application.
-  {modules, [
-    thrift_base64_transport,
-    thrift_binary_protocol,
-    thrift_buffered_transport,
-    thrift_client_util,
-    thrift_client,
-    thrift_disk_log_transport,
-    thrift_file_transport,
-    thrift_framed_transport,
-    thrift_http_transport,
-    thrift_json_parser,
-    thrift_json_protocol,
-    thrift_membuffer_transport,
-    thrift_memory_buffer,
-    thrift_processor,
-    thrift_protocol,
-    thrift_reconnecting_client,
-    thrift_server,
-    thrift_service,
-    thrift_socket_server,
-    thrift_socket_transport,
-    thrift_transport_state_test,
-    thrift_transport
-  ]},
+    % All modules used by the application.
+    {modules, []},
 
-  % All of the registered names the application uses. This can be ignored.
-  {registered, []},
+    % All of the registered names the application uses. This can be ignored.
+    {registered, []},
 
-  % Applications that are to be started prior to this one. This can be ignored
-  % leave it alone unless you understand it well and let the .rel files in
-  % your release handle this.
-  {applications, [kernel, stdlib]},
+    % Applications that are to be started prior to this one. This can be ignored
+    % leave it alone unless you understand it well and let the .rel files in
+    % your release handle this.
+    {applications, [kernel, stdlib]},
 
-  % OTP application loader will load, but not start, included apps. Again
-  % this can be ignored as well.  To load but not start an application it
-  % is easier to include it in the .rel file followed by the atom 'none'
-  {included_applications, []},
+    % OTP application loader will load, but not start, included apps. Again
+    % this can be ignored as well.  To load but not start an application it
+    % is easier to include it in the .rel file followed by the atom 'none'
+    {included_applications, []},
 
-  % configuration parameters similar to those in the config file specified
-  % on the command line. can be fetched with gas:get_env
-  {env, [
-    % If an error/crash occurs during processing of a function,
-    % should the TApplicationException serialized back to the client
-    % include the erlang backtrace?
-    {exceptions_include_traces, true}
-  ]}
+    % configuration parameters similar to those in the config file specified
+    % on the command line. can be fetched with gas:get_env
+    {env, [
+        % If an error/crash occurs during processing of a function,
+        % should the TApplicationException serialized back to the client
+        % include the erlang backtrace?
+        {exceptions_include_traces, true}
+    ]}
 ]}.
diff --git a/lib/erl/src/thrift_base64_transport.erl b/lib/erl/src/thrift_base64_transport.erl
index d31f2ba..9aa629f 100644
--- a/lib/erl/src/thrift_base64_transport.erl
+++ b/lib/erl/src/thrift_base64_transport.erl
@@ -28,42 +28,37 @@
 -export([write/2, read/2, flush/1, close/1]).
 
 %% State
--record(b64_transport, {wrapped}).
--type state() :: #b64_transport{}.
--include("thrift_transport_behaviour.hrl").
+-record(b64_transport, {
+    wrapped :: thrift_transport:t_transport()
+}).
 
 new(Wrapped) ->
     State = #b64_transport{wrapped = Wrapped},
     thrift_transport:new(?MODULE, State).
 
-
 write(This = #b64_transport{wrapped = Wrapped}, Data) ->
     {NewWrapped, Result} = thrift_transport:write(Wrapped, base64:encode(iolist_to_binary(Data))),
     {This#b64_transport{wrapped = NewWrapped}, Result}.
 
-
 %% base64 doesn't support reading quite yet since it would involve
 %% nasty buffering and such
 read(This = #b64_transport{}, _Data) ->
     {This, {error, no_reads_allowed}}.
 
-
 flush(This = #b64_transport{wrapped = Wrapped0}) ->
     {Wrapped1, ok} = thrift_transport:write(Wrapped0, <<"\n">>),
     {Wrapped2, ok} = thrift_transport:flush(Wrapped1),
     {This#b64_transport{wrapped = Wrapped2}, ok}.
 
-
 close(This0) ->
     {This1 = #b64_transport{wrapped = Wrapped}, ok} = flush(This0),
     {NewWrapped, ok} = thrift_transport:close(Wrapped),
     {This1#b64_transport{wrapped = NewWrapped}, ok}.
 
-
 %%%% FACTORY GENERATION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 new_transport_factory(WrapFactory) ->
     F = fun() ->
-                {ok, Wrapped} = WrapFactory(),
-                new(Wrapped)
-        end,
+        {ok, Wrapped} = WrapFactory(),
+        new(Wrapped)
+    end,
     {ok, F}.
diff --git a/lib/erl/src/thrift_binary_protocol.erl b/lib/erl/src/thrift_binary_protocol.erl
index 85abb62..d2c89d3 100644
--- a/lib/erl/src/thrift_binary_protocol.erl
+++ b/lib/erl/src/thrift_binary_protocol.erl
@@ -24,21 +24,21 @@
 -include("thrift_constants.hrl").
 -include("thrift_protocol.hrl").
 
--export([new/1, new/2,
-         read/2,
-         write/2,
-         flush_transport/1,
-         close_transport/1,
+-export([
+    new/1, new/2,
+    read/2,
+    write/2,
+    flush_transport/1,
+    close_transport/1,
 
-         new_protocol_factory/2
-        ]).
+    new_protocol_factory/2
+]).
 
--record(binary_protocol, {transport,
-                          strict_read=true,
-                          strict_write=true
-                         }).
--type state() :: #binary_protocol{}.
--include("thrift_protocol_behaviour.hrl").
+-record(binary_protocol, {
+    transport :: term(),
+    strict_read = true :: boolean(),
+    strict_write = true :: boolean()
+}).
 
 -define(VERSION_MASK, 16#FFFF0000).
 -define(VERSION_1, 16#80010000).
@@ -48,17 +48,16 @@
     new(Transport, _Options = []).
 
 new(Transport, Options) ->
-    State  = #binary_protocol{transport = Transport},
+    State = #binary_protocol{transport = Transport},
     State1 = parse_options(Options, State),
     thrift_protocol:new(?MODULE, State1).
 
 parse_options([], State) ->
     State;
 parse_options([{strict_read, Bool} | Rest], State) when is_boolean(Bool) ->
-    parse_options(Rest, State#binary_protocol{strict_read=Bool});
+    parse_options(Rest, State#binary_protocol{strict_read = Bool});
 parse_options([{strict_write, Bool} | Rest], State) when is_boolean(Bool) ->
-    parse_options(Rest, State#binary_protocol{strict_write=Bool}).
-
+    parse_options(Rest, State#binary_protocol{strict_write = Bool}).
 
 flush_transport(This = #binary_protocol{transport = Transport}) ->
     {NewTransport, Result} = thrift_transport:flush(Transport),
@@ -73,9 +72,10 @@
 %%%
 
 write(This0, #protocol_message_begin{
-        name = Name,
-        type = Type,
-        seqid = Seqid}) ->
+    name = Name,
+    type = Type,
+    seqid = Seqid
+}) ->
     case This0#binary_protocol.strict_write of
         true ->
             {This1, ok} = write(This0, {i32, ?VERSION_1 bor Type}),
@@ -88,82 +88,75 @@
             {This3, ok} = write(This2, {i32, Seqid}),
             {This3, ok}
     end;
-
-write(This, message_end) -> {This, ok};
-
+write(This, message_end) ->
+    {This, ok};
 write(This0, #protocol_field_begin{
-       name = _Name,
-       type = Type,
-       id = Id}) ->
+    name = _Name,
+    type = Type,
+    id = Id
+}) ->
     {This1, ok} = write(This0, {byte, Type}),
     {This2, ok} = write(This1, {i16, Id}),
     {This2, ok};
-
 write(This, field_stop) ->
     write(This, {byte, ?tType_STOP});
-
-write(This, field_end) -> {This, ok};
-
+write(This, field_end) ->
+    {This, ok};
 write(This0, #protocol_map_begin{
-       ktype = Ktype,
-       vtype = Vtype,
-       size = Size}) ->
+    ktype = Ktype,
+    vtype = Vtype,
+    size = Size
+}) ->
     {This1, ok} = write(This0, {byte, Ktype}),
     {This2, ok} = write(This1, {byte, Vtype}),
     {This3, ok} = write(This2, {i32, Size}),
     {This3, ok};
-
-write(This, map_end) -> {This, ok};
-
+write(This, map_end) ->
+    {This, ok};
 write(This0, #protocol_list_begin{
-        etype = Etype,
-        size = Size}) ->
+    etype = Etype,
+    size = Size
+}) ->
     {This1, ok} = write(This0, {byte, Etype}),
     {This2, ok} = write(This1, {i32, Size}),
     {This2, ok};
-
-write(This, list_end) -> {This, ok};
-
+write(This, list_end) ->
+    {This, ok};
 write(This0, #protocol_set_begin{
-        etype = Etype,
-        size = Size}) ->
+    etype = Etype,
+    size = Size
+}) ->
     {This1, ok} = write(This0, {byte, Etype}),
     {This2, ok} = write(This1, {i32, Size}),
     {This2, ok};
-
-write(This, set_end) -> {This, ok};
-
-write(This, #protocol_struct_begin{}) -> {This, ok};
-write(This, struct_end) -> {This, ok};
-
-write(This, {bool, true})  -> write(This, {byte, 1});
-write(This, {bool, false}) -> write(This, {byte, 0});
-
+write(This, set_end) ->
+    {This, ok};
+write(This, #protocol_struct_begin{}) ->
+    {This, ok};
+write(This, struct_end) ->
+    {This, ok};
+write(This, {bool, true}) ->
+    write(This, {byte, 1});
+write(This, {bool, false}) ->
+    write(This, {byte, 0});
 write(This, {byte, Byte}) ->
     write(This, <<Byte:8/big-signed>>);
-
 write(This, {i16, I16}) ->
     write(This, <<I16:16/big-signed>>);
-
 write(This, {i32, I32}) ->
     write(This, <<I32:32/big-signed>>);
-
 write(This, {i64, I64}) ->
     write(This, <<I64:64/big-signed>>);
-
 write(This, {double, Double}) ->
     write(This, <<Double:64/big-signed-float>>);
-
 write(This0, {string, Str}) when is_list(Str) ->
     {This1, ok} = write(This0, {i32, length(Str)}),
     {This2, ok} = write(This1, list_to_binary(Str)),
     {This2, ok};
-
 write(This0, {string, Bin}) when is_binary(Bin) ->
     {This1, ok} = write(This0, {i32, size(Bin)}),
     {This2, ok} = write(This1, Bin),
     {This2, ok};
-
 %% Data :: iolist()
 write(This = #binary_protocol{transport = Trans}, Data) ->
     {NewTransport, Result} = thrift_transport:write(Trans, Data),
@@ -176,39 +169,39 @@
     case Initial of
         {ok, Sz} when Sz band ?VERSION_MASK =:= ?VERSION_1 ->
             %% we're at version 1
-            {This2, {ok, Name}}  = read(This1, string),
+            {This2, {ok, Name}} = read(This1, string),
             {This3, {ok, SeqId}} = read(This2, i32),
-            Type                 = Sz band ?TYPE_MASK,
-            {This3, #protocol_message_begin{name  = binary_to_list(Name),
-                                            type  = Type,
-                                            seqid = SeqId}};
-
+            Type = Sz band ?TYPE_MASK,
+            {This3, #protocol_message_begin{
+                name = binary_to_list(Name),
+                type = Type,
+                seqid = SeqId
+            }};
         {ok, Sz} when Sz < 0 ->
             %% there's a version number but it's unexpected
             {This1, {error, {bad_binary_protocol_version, Sz}}};
-
         {ok, _Sz} when This1#binary_protocol.strict_read =:= true ->
             %% strict_read is true and there's no version header; that's an error
             {This1, {error, no_binary_protocol_version}};
-
         {ok, Sz} when This1#binary_protocol.strict_read =:= false ->
             %% strict_read is false, so just read the old way
-            {This2, {ok, Name}}  = read_data(This1, Sz),
-            {This3, {ok, Type}}  = read(This2, byte),
+            {This2, {ok, Name}} = read_data(This1, Sz),
+            {This3, {ok, Type}} = read(This2, byte),
             {This4, {ok, SeqId}} = read(This3, i32),
-            {This4, #protocol_message_begin{name  = binary_to_list(Name),
-                                            type  = Type,
-                                            seqid = SeqId}};
-
+            {This4, #protocol_message_begin{
+                name = binary_to_list(Name),
+                type = Type,
+                seqid = SeqId
+            }};
         Else ->
             {This1, Else}
     end;
-
-read(This, message_end) -> {This, ok};
-
-read(This, struct_begin) -> {This, ok};
-read(This, struct_end) -> {This, ok};
-
+read(This, message_end) ->
+    {This, ok};
+read(This, struct_begin) ->
+    {This, ok};
+read(This, struct_end) ->
+    {This, ok};
 read(This0, field_begin) ->
     {This1, Result} = read(This0, byte),
     case Result of
@@ -216,39 +209,45 @@
             {This1, #protocol_field_begin{type = Type}};
         {ok, Type} ->
             {This2, {ok, Id}} = read(This1, i16),
-            {This2, #protocol_field_begin{type = Type,
-                                          id = Id}}
+            {This2, #protocol_field_begin{
+                type = Type,
+                id = Id
+            }}
     end;
-
-read(This, field_end) -> {This, ok};
-
+read(This, field_end) ->
+    {This, ok};
 read(This0, map_begin) ->
     {This1, {ok, Ktype}} = read(This0, byte),
     {This2, {ok, Vtype}} = read(This1, byte),
-    {This3, {ok, Size}}  = read(This2, i32),
-    {This3, #protocol_map_begin{ktype = Ktype,
-                                vtype = Vtype,
-                                size = Size}};
-read(This, map_end) -> {This, ok};
-
+    {This3, {ok, Size}} = read(This2, i32),
+    {This3, #protocol_map_begin{
+        ktype = Ktype,
+        vtype = Vtype,
+        size = Size
+    }};
+read(This, map_end) ->
+    {This, ok};
 read(This0, list_begin) ->
     {This1, {ok, Etype}} = read(This0, byte),
-    {This2, {ok, Size}}  = read(This1, i32),
-    {This2, #protocol_list_begin{etype = Etype,
-                                 size = Size}};
-read(This, list_end) -> {This, ok};
-
+    {This2, {ok, Size}} = read(This1, i32),
+    {This2, #protocol_list_begin{
+        etype = Etype,
+        size = Size
+    }};
+read(This, list_end) ->
+    {This, ok};
 read(This0, set_begin) ->
     {This1, {ok, Etype}} = read(This0, byte),
-    {This2, {ok, Size}}  = read(This1, i32),
-    {This2, #protocol_set_begin{etype = Etype,
-                                 size = Size}};
-read(This, set_end) -> {This, ok};
-
+    {This2, {ok, Size}} = read(This1, i32),
+    {This2, #protocol_set_begin{
+        etype = Etype,
+        size = Size
+    }};
+read(This, set_end) ->
+    {This, ok};
 read(This0, field_stop) ->
     {This1, {ok, ?tType_STOP}} = read(This0, byte),
     {This1, ok};
-
 %%
 
 read(This0, bool) ->
@@ -257,28 +256,24 @@
         {ok, Byte} -> {This1, {ok, Byte /= 0}};
         Else -> {This1, Else}
     end;
-
 read(This0, byte) ->
     {This1, Bytes} = read_data(This0, 1),
     case Bytes of
         {ok, <<Val:8/integer-signed-big, _/binary>>} -> {This1, {ok, Val}};
         Else -> {This1, Else}
     end;
-
 read(This0, i16) ->
     {This1, Bytes} = read_data(This0, 2),
     case Bytes of
         {ok, <<Val:16/integer-signed-big, _/binary>>} -> {This1, {ok, Val}};
         Else -> {This1, Else}
     end;
-
 read(This0, i32) ->
     {This1, Bytes} = read_data(This0, 4),
     case Bytes of
         {ok, <<Val:32/integer-signed-big, _/binary>>} -> {This1, {ok, Val}};
         Else -> {This1, Else}
     end;
-
 %% unsigned ints aren't used by thrift itself, but it's used for the parsing
 %% of the packet version header. Without this special function BEAM works fine
 %% but hipe thinks it received a bad version header.
@@ -288,60 +283,60 @@
         {ok, <<Val:32/integer-unsigned-big, _/binary>>} -> {This1, {ok, Val}};
         Else -> {This1, Else}
     end;
-
 read(This0, i64) ->
     {This1, Bytes} = read_data(This0, 8),
     case Bytes of
         {ok, <<Val:64/integer-signed-big, _/binary>>} -> {This1, {ok, Val}};
         Else -> {This1, Else}
     end;
-
 read(This0, double) ->
     {This1, Bytes} = read_data(This0, 8),
     case Bytes of
         {ok, <<Val:64/float-signed-big, _/binary>>} -> {This1, {ok, Val}};
         Else -> {This1, Else}
     end;
-
 % returns a binary directly, call binary_to_list if necessary
 read(This0, string) ->
-    {This1, {ok, Sz}}  = read(This0, i32),
+    {This1, {ok, Sz}} = read(This0, i32),
     read_data(This1, Sz).
 
 -spec read_data(#binary_protocol{}, non_neg_integer()) ->
     {#binary_protocol{}, {ok, binary()} | {error, _Reason}}.
-read_data(This, 0) -> {This, {ok, <<>>}};
+read_data(This, 0) ->
+    {This, {ok, <<>>}};
 read_data(This = #binary_protocol{transport = Trans}, Len) when is_integer(Len) andalso Len > 0 ->
     {NewTransport, Result} = thrift_transport:read(Trans, Len),
     {This#binary_protocol{transport = NewTransport}, Result}.
 
-
 %%%% FACTORY GENERATION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
--record(tbp_opts, {strict_read = true,
-                   strict_write = true}).
+-record(tbp_opts, {
+    strict_read = true :: boolean(),
+    strict_write = true :: boolean()
+}).
 
 parse_factory_options([], Opts) ->
     Opts;
 parse_factory_options([{strict_read, Bool} | Rest], Opts) when is_boolean(Bool) ->
-    parse_factory_options(Rest, Opts#tbp_opts{strict_read=Bool});
+    parse_factory_options(Rest, Opts#tbp_opts{strict_read = Bool});
 parse_factory_options([{strict_write, Bool} | Rest], Opts) when is_boolean(Bool) ->
-    parse_factory_options(Rest, Opts#tbp_opts{strict_write=Bool}).
-
+    parse_factory_options(Rest, Opts#tbp_opts{strict_write = Bool}).
 
 %% returns a (fun() -> thrift_protocol())
 new_protocol_factory(TransportFactory, Options) ->
     ParsedOpts = parse_factory_options(Options, #tbp_opts{}),
     F = fun() ->
-               case TransportFactory() of
-                    {ok, Transport} ->
-                        thrift_binary_protocol:new(
-                            Transport,
-                            [{strict_read,  ParsedOpts#tbp_opts.strict_read},
-                             {strict_write, ParsedOpts#tbp_opts.strict_write}]);
-                    {error, Error} ->
-                        {error, Error}
-                end
-        end,
+        case TransportFactory() of
+            {ok, Transport} ->
+                thrift_binary_protocol:new(
+                    Transport,
+                    [
+                        {strict_read, ParsedOpts#tbp_opts.strict_read},
+                        {strict_write, ParsedOpts#tbp_opts.strict_write}
+                    ]
+                );
+            {error, Error} ->
+                {error, Error}
+        end
+    end,
     {ok, F}.
-
diff --git a/lib/erl/src/thrift_buffered_transport.erl b/lib/erl/src/thrift_buffered_transport.erl
index e9d3fff..423e89a 100644
--- a/lib/erl/src/thrift_buffered_transport.erl
+++ b/lib/erl/src/thrift_buffered_transport.erl
@@ -28,71 +28,59 @@
 %% legacy api
 -export([new_transport_factory/1]).
 
-
 -record(t_buffered, {
-  wrapped,
-  write_buffer
+    wrapped :: thrift_transport:t_transport(),
+    write_buffer :: iodata()
 }).
 
--type state() :: #t_buffered{}.
-
-
--spec new(Transport::thrift_transport:t_transport()) ->
-  thrift_transport:t_transport().
+-spec new(Transport :: thrift_transport:t_transport()) -> {ok, thrift_transport:t_transport()}.
 
 new(Wrapped) ->
-  State = #t_buffered{
-    wrapped = Wrapped,
-    write_buffer = []
-  },
-  thrift_transport:new(?MODULE, State).
-
-
--include("thrift_transport_behaviour.hrl").
-
+    State = #t_buffered{
+        wrapped = Wrapped,
+        write_buffer = []
+    },
+    thrift_transport:new(?MODULE, State).
 
 %% reads data through from the wrapped transport
-read(State = #t_buffered{wrapped = Wrapped}, Len)
-when is_integer(Len), Len >= 0 ->
-  {NewState, Response} = thrift_transport:read(Wrapped, Len),
-  {State#t_buffered{wrapped = NewState}, Response}.
-
+read(State = #t_buffered{wrapped = Wrapped}, Len) when
+    is_integer(Len), Len >= 0
+->
+    {NewState, Response} = thrift_transport:read(Wrapped, Len),
+    {State#t_buffered{wrapped = NewState}, Response}.
 
 %% reads data through from the wrapped transport
-read_exact(State = #t_buffered{wrapped = Wrapped}, Len)
-when is_integer(Len), Len >= 0 ->
-  {NewState, Response} = thrift_transport:read_exact(Wrapped, Len),
-  {State#t_buffered{wrapped = NewState}, Response}.
-
+read_exact(State = #t_buffered{wrapped = Wrapped}, Len) when
+    is_integer(Len), Len >= 0
+->
+    {NewState, Response} = thrift_transport:read_exact(Wrapped, Len),
+    {State#t_buffered{wrapped = NewState}, Response}.
 
 write(State = #t_buffered{write_buffer = Buffer}, Data) ->
-  {State#t_buffered{write_buffer = [Buffer, Data]}, ok}.
-
+    {State#t_buffered{write_buffer = [Buffer, Data]}, ok}.
 
 flush(State = #t_buffered{wrapped = Wrapped, write_buffer = Buffer}) ->
-  case iolist_size(Buffer) of
-    %% if write buffer is empty, do nothing
-    0 -> {State, ok};
-    _ ->
-      {Written, Response} = thrift_transport:write(Wrapped, Buffer),
-      {Flushed, ok} = thrift_transport:flush(Written),
-      {State#t_buffered{wrapped = Flushed, write_buffer = []}, Response}
-  end.
-
+    case iolist_size(Buffer) of
+        %% if write buffer is empty, do nothing
+        0 ->
+            {State, ok};
+        _ ->
+            {Written, Response} = thrift_transport:write(Wrapped, Buffer),
+            {Flushed, ok} = thrift_transport:flush(Written),
+            {State#t_buffered{wrapped = Flushed, write_buffer = []}, Response}
+    end.
 
 close(State = #t_buffered{wrapped = Wrapped}) ->
-  {Closed, Result} = thrift_transport:close(Wrapped),
-  {State#t_buffered{wrapped = Closed}, Result}.
-
+    {Closed, Result} = thrift_transport:close(Wrapped),
+    {State#t_buffered{wrapped = Closed}, Result}.
 
 %%--------------------------------------------------------------------
 %%% Internal functions
 %%--------------------------------------------------------------------
 %%%% FACTORY GENERATION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 new_transport_factory(WrapFactory) ->
-  F = fun() ->
-    {ok, Wrapped} = WrapFactory(),
-    new(Wrapped)
-  end,
-  {ok, F}.
-
+    F = fun() ->
+        {ok, Wrapped} = WrapFactory(),
+        new(Wrapped)
+    end,
+    {ok, F}.
diff --git a/lib/erl/src/thrift_client.erl b/lib/erl/src/thrift_client.erl
index 1a9cb50..1c27405 100644
--- a/lib/erl/src/thrift_client.erl
+++ b/lib/erl/src/thrift_client.erl
@@ -25,78 +25,91 @@
 -include("thrift_constants.hrl").
 -include("thrift_protocol.hrl").
 
--record(tclient, {service, protocol, seqid}).
+-record(tclient, {
+    service :: module(),
+    protocol :: thrift_protocol:state(),
+    seqid :: non_neg_integer()
+}).
+-type tclient() :: #tclient{}.
 
-
-new(Protocol, Service)
-  when is_atom(Service) ->
-    {ok, #tclient{protocol = Protocol,
-                  service = Service,
-                  seqid = 0}}.
+new(Protocol, Service) when
+    is_atom(Service)
+->
+    {ok, #tclient{
+        protocol = Protocol,
+        service = Service,
+        seqid = 0
+    }}.
 
 -spec call(#tclient{}, atom(), list()) -> {#tclient{}, {ok, any()} | {error, any()}}.
-call(Client = #tclient{}, Function, Args)
-when is_atom(Function), is_list(Args) ->
-  case send_function_call(Client, Function, Args) of
-    {ok, Client1} -> receive_function_result(Client1, Function);
-    {{error, X}, Client1} -> {Client1, {error, X}};
-    Else -> Else
-  end.
-
+call(Client = #tclient{}, Function, Args) when
+    is_atom(Function), is_list(Args)
+->
+    case send_function_call(Client, Function, Args) of
+        {ok, Client1} -> receive_function_result(Client1, Function);
+        {{error, X}, Client1} -> {Client1, {error, X}}
+    end.
 
 %% Sends a function call but does not read the result. This is useful
 %% if you're trying to log non-oneway function calls to write-only
 %% transports like thrift_disk_log_transport.
 -spec send_call(#tclient{}, atom(), list()) -> {#tclient{}, ok}.
-send_call(Client = #tclient{}, Function, Args)
-  when is_atom(Function), is_list(Args) ->
+send_call(Client = #tclient{}, Function, Args) when
+    is_atom(Function), is_list(Args)
+->
     case send_function_call(Client, Function, Args) of
-      {ok, Client1} -> {Client1, ok};
-      Else -> Else
+        {ok, Client1} -> {Client1, ok};
+        Else -> Else
     end.
 
 -spec close(#tclient{}) -> ok.
-close(#tclient{protocol=Protocol}) ->
+close(#tclient{protocol = Protocol}) ->
     thrift_protocol:close_transport(Protocol).
 
-
 %%--------------------------------------------------------------------
 %%% Internal functions
 %%--------------------------------------------------------------------
 -spec send_function_call(#tclient{}, atom(), list()) -> {ok | {error, any()}, #tclient{}}.
 send_function_call(Client = #tclient{service = Service}, Function, Args) ->
-  {Params, Reply} = try
-    {Service:function_info(Function, params_type), Service:function_info(Function, reply_type)}
-  catch error:function_clause -> {no_function, 0}
-  end,
-  MsgType = case Reply of
-    oneway_void -> ?tMessageType_ONEWAY;
-    _ -> ?tMessageType_CALL
-  end,
-  case Params of
-    no_function ->
-      {{error, {no_function, Function}}, Client};
-    {struct, PList} when length(PList) =/= length(Args) ->
-      {{error, {bad_args, Function, Args}}, Client};
-    {struct, _PList} -> write_message(Client, Function, Args, Params, MsgType)
-  end.
+    {Params, Reply} =
+        try
+            {
+                Service:function_info(Function, params_type),
+                Service:function_info(Function, reply_type)
+            }
+        catch
+            error:function_clause -> {no_function, 0}
+        end,
+    MsgType =
+        case Reply of
+            oneway_void -> ?tMessageType_ONEWAY;
+            _ -> ?tMessageType_CALL
+        end,
+    case Params of
+        no_function ->
+            {{error, {no_function, Function}}, Client};
+        {struct, PList} when length(PList) =/= length(Args) ->
+            {{error, {bad_args, Function, Args}}, Client};
+        {struct, _PList} ->
+            write_message(Client, Function, Args, Params, MsgType)
+    end.
 
 -spec write_message(#tclient{}, atom(), list(), {struct, list()}, integer()) ->
-  {ok | {error, any()}, #tclient{}}.
+    {ok | {error, any()}, #tclient{}}.
 write_message(Client = #tclient{protocol = P0, seqid = Seq}, Function, Args, Params, MsgType) ->
-  try
-    {P1, ok} = thrift_protocol:write(P0, #protocol_message_begin{
-      name = atom_to_list(Function),
-      type = MsgType,
-      seqid = Seq
-    }),
-    {P2, ok} = thrift_protocol:write(P1, {Params, list_to_tuple([Function|Args])}),
-    {P3, ok} = thrift_protocol:write(P2, message_end),
-    {P4, ok} = thrift_protocol:flush_transport(P3),
-    {ok, Client#tclient{protocol = P4}}
-  catch
-    error:{badmatch, {_, {error, _} = Error}} -> {Error, Client}
-  end.
+    try
+        {P1, ok} = thrift_protocol:write(P0, #protocol_message_begin{
+            name = atom_to_list(Function),
+            type = MsgType,
+            seqid = Seq
+        }),
+        {P2, ok} = thrift_protocol:write(P1, {Params, list_to_tuple([Function | Args])}),
+        {P3, ok} = thrift_protocol:write(P2, message_end),
+        {P4, ok} = thrift_protocol:flush_transport(P3),
+        {ok, Client#tclient{protocol = P4}}
+    catch
+        error:{badmatch, {_, {error, _} = Error}} -> {Error, Client}
+    end.
 
 -spec receive_function_result(#tclient{}, atom()) -> {#tclient{}, {ok, any()} | {error, any()}}.
 receive_function_result(Client = #tclient{service = Service}, Function) ->
@@ -105,32 +118,38 @@
 
 read_result(Client, _Function, oneway_void) ->
     {Client, {ok, ok}};
-
-read_result(Client = #tclient{protocol = Proto0,
-                              seqid    = SeqId},
-            Function,
-            ReplyType) ->
+read_result(
+    Client = #tclient{
+        protocol = Proto0,
+        seqid = SeqId
+    },
+    Function,
+    ReplyType
+) ->
     case thrift_protocol:read(Proto0, message_begin) of
-         {Proto1, {error, Reason}} ->
-             NewClient = Client#tclient{protocol = Proto1},
-             {NewClient, {error, Reason}};
-         {Proto1, MessageBegin} ->
-             NewClient = Client#tclient{protocol = Proto1},
-             case MessageBegin of
-                 #protocol_message_begin{seqid = RetSeqId} when RetSeqId =/= SeqId ->
-                     {NewClient, {error, {bad_seq_id, SeqId}}};
-                 #protocol_message_begin{type = ?tMessageType_EXCEPTION} ->
-                     handle_application_exception(NewClient);
-                 #protocol_message_begin{type = ?tMessageType_REPLY} ->
-                     handle_reply(NewClient, Function, ReplyType)
-             end
+        {Proto1, {error, Reason}} ->
+            NewClient = Client#tclient{protocol = Proto1},
+            {NewClient, {error, Reason}};
+        {Proto1, MessageBegin} ->
+            NewClient = Client#tclient{protocol = Proto1},
+            case MessageBegin of
+                #protocol_message_begin{seqid = RetSeqId} when RetSeqId =/= SeqId ->
+                    {NewClient, {error, {bad_seq_id, SeqId}}};
+                #protocol_message_begin{type = ?tMessageType_EXCEPTION} ->
+                    handle_application_exception(NewClient);
+                #protocol_message_begin{type = ?tMessageType_REPLY} ->
+                    handle_reply(NewClient, Function, ReplyType)
+            end
     end.
 
-
-handle_reply(Client = #tclient{protocol = Proto0,
-                               service = Service},
-             Function,
-             ReplyType) ->
+handle_reply(
+    Client = #tclient{
+        protocol = Proto0,
+        service = Service
+    },
+    Function,
+    ReplyType
+) ->
     {struct, ExceptionFields} = Service:function_info(Function, exceptions),
     ReplyStructDef = {struct, [{0, ReplyType}] ++ ExceptionFields},
     {Proto1, {ok, Reply}} = thrift_protocol:read(Proto0, ReplyStructDef),
@@ -139,8 +158,11 @@
     ReplyList = tuple_to_list(Reply),
     true = length(ReplyList) == length(ExceptionFields) + 1,
     ExceptionVals = tl(ReplyList),
-    Thrown = [X || X <- ExceptionVals,
-                   X =/= undefined],
+    Thrown = [
+        X
+     || X <- ExceptionVals,
+        X =/= undefined
+    ],
     case Thrown of
         [] when ReplyType == {struct, []} ->
             {NewClient, {ok, ok}};
@@ -150,12 +172,14 @@
             throw({NewClient, {exception, Exception}})
     end.
 
+-spec handle_application_exception(tclient()) -> no_return().
 handle_application_exception(Client = #tclient{protocol = Proto0}) ->
     {Proto1, {ok, Exception}} =
         thrift_protocol:read(Proto0, ?TApplicationException_Structure),
     {Proto2, ok} = thrift_protocol:read(Proto1, message_end),
     XRecord = list_to_tuple(
-                ['TApplicationException' | tuple_to_list(Exception)]),
+        ['TApplicationException' | tuple_to_list(Exception)]
+    ),
     error_logger:error_msg("X: ~p~n", [XRecord]),
     true = is_record(XRecord, 'TApplicationException'),
     NewClient = Client#tclient{protocol = Proto2},
diff --git a/lib/erl/src/thrift_client_util.erl b/lib/erl/src/thrift_client_util.erl
index 1dbe51e..7c5f094 100644
--- a/lib/erl/src/thrift_client_util.erl
+++ b/lib/erl/src/thrift_client_util.erl
@@ -22,9 +22,11 @@
 -export([new/4]).
 -export([new_multiplexed/3, new_multiplexed/4]).
 
--type service_name()            :: nonempty_string().
--type service_module()          :: atom().
--type multiplexed_service_map() :: [{ServiceName::service_name(), ServiceModule::service_module()}].
+-type service_name() :: nonempty_string().
+-type service_module() :: atom().
+-type multiplexed_service_map() :: [
+    {ServiceName :: service_name(), ServiceModule :: service_module()}
+].
 
 %%
 %% Splits client options into client, protocol, and transport options
@@ -36,44 +38,47 @@
 
 split_options([], ProtoIn, TransIn) ->
     {ProtoIn, TransIn};
-
-split_options([Opt = {OptKey, _} | Rest], ProtoIn, TransIn)
-  when OptKey =:= strict_read;
-       OptKey =:= strict_write;
-       OptKey =:= protocol ->
+split_options([Opt = {OptKey, _} | Rest], ProtoIn, TransIn) when
+    OptKey =:= strict_read;
+    OptKey =:= strict_write;
+    OptKey =:= protocol
+->
     split_options(Rest, [Opt | ProtoIn], TransIn);
-
-split_options([Opt = {OptKey, _} | Rest], ProtoIn, TransIn)
-  when OptKey =:= framed;
-       OptKey =:= connect_timeout;
-       OptKey =:= recv_timeout;
-       OptKey =:= sockopts;
-       OptKey =:= ssltransport;
-       OptKey =:= ssloptions->
+split_options([Opt = {OptKey, _} | Rest], ProtoIn, TransIn) when
+    OptKey =:= framed;
+    OptKey =:= connect_timeout;
+    OptKey =:= recv_timeout;
+    OptKey =:= sockopts;
+    OptKey =:= ssltransport;
+    OptKey =:= ssloptions
+->
     split_options(Rest, ProtoIn, [Opt | TransIn]).
 
-
 %% Client constructor for the common-case of socket transports
-new(Host, Port, Service, Options)
-  when is_integer(Port), is_atom(Service), is_list(Options) ->
+new(Host, Port, Service, Options) when
+    is_integer(Port), is_atom(Service), is_list(Options)
+->
     {ProtoOpts, TransOpts0} = split_options(Options),
 
-    {TransportModule, TransOpts2} = case lists:keytake(ssltransport, 1, TransOpts0) of
-                                        {value, {_, true}, TransOpts1} -> {thrift_sslsocket_transport, TransOpts1};
-                                        false -> {thrift_socket_transport, TransOpts0}
-                                    end,
+    {TransportModule, TransOpts2} =
+        case lists:keytake(ssltransport, 1, TransOpts0) of
+            {value, {_, true}, TransOpts1} -> {thrift_sslsocket_transport, TransOpts1};
+            false -> {thrift_socket_transport, TransOpts0}
+        end,
 
-    {ProtocolModule, ProtoOpts1} = case lists:keytake(protocol, 1, ProtoOpts) of
-                                     {value, {_, compact}, Opts} -> {thrift_compact_protocol, Opts};
-                                     {value, {_, json}, Opts} -> {thrift_json_protocol, Opts};
-                                     {value, {_, binary}, Opts} -> {thrift_binary_protocol, Opts};
-                                     false -> {thrift_binary_protocol, ProtoOpts}
-                                   end,
+    {ProtocolModule, ProtoOpts1} =
+        case lists:keytake(protocol, 1, ProtoOpts) of
+            {value, {_, compact}, Opts} -> {thrift_compact_protocol, Opts};
+            {value, {_, json}, Opts} -> {thrift_json_protocol, Opts};
+            {value, {_, binary}, Opts} -> {thrift_binary_protocol, Opts};
+            false -> {thrift_binary_protocol, ProtoOpts}
+        end,
     {ok, TransportFactory} =
         TransportModule:new_transport_factory(Host, Port, TransOpts2),
 
     {ok, ProtocolFactory} = ProtocolModule:new_protocol_factory(
-                              TransportFactory, ProtoOpts1),
+        TransportFactory, ProtoOpts1
+    ),
 
     case ProtocolFactory() of
         {ok, Protocol} ->
@@ -83,30 +88,49 @@
     end.
 
 -spec new_multiplexed(Host, Port, Services, Options) -> {ok, ServiceThriftClientList} when
-    Host        :: nonempty_string(),
-    Port        :: non_neg_integer(),
-    Services    :: multiplexed_service_map(),
-    Options     :: list(),
-    ServiceThriftClientList :: [{ServiceName::list(), ThriftClient::term()}].
-new_multiplexed(Host, Port, Services, Options) when is_integer(Port),
-                                                    is_list(Services),
-                                                    is_list(Options) ->
-    new_multiplexed(thrift_socket_transport:new_transport_factory(Host, Port, Options), Services, Options).
+    Host :: nonempty_string(),
+    Port :: non_neg_integer(),
+    Services :: multiplexed_service_map(),
+    Options :: list(),
+    ServiceThriftClientList :: [{ServiceName :: list(), ThriftClient :: term()}].
+new_multiplexed(Host, Port, Services, Options) when
+    is_integer(Port),
+    is_list(Services),
+    is_list(Options)
+->
+    new_multiplexed(
+        thrift_socket_transport:new_transport_factory(Host, Port, Options), Services, Options
+    ).
 
--spec new_multiplexed(TransportFactoryTuple, Services, Options) -> {ok, ServiceThriftClientList} when
-    TransportFactoryTuple   :: {ok, TransportFactory::term()},
-    Services                :: multiplexed_service_map(),
-    Options                 :: list(),
-    ServiceThriftClientList :: [{ServiceName::service_name(), ThriftClient::term()}].
-new_multiplexed(TransportFactoryTuple, Services, Options) when is_list(Services),
-                                                               is_list(Options),
-                                                               is_tuple(TransportFactoryTuple) ->
+-spec new_multiplexed(TransportFactoryTuple, Services, Options) ->
+    {ok, ServiceThriftClientList}
+when
+    TransportFactoryTuple :: {ok, TransportFactory :: term()},
+    Services :: multiplexed_service_map(),
+    Options :: list(),
+    ServiceThriftClientList :: [{ServiceName :: service_name(), ThriftClient :: term()}].
+new_multiplexed(TransportFactoryTuple, Services, Options) when
+    is_list(Services),
+    is_list(Options),
+    is_tuple(TransportFactoryTuple)
+->
     {ProtoOpts, _} = split_options(Options),
 
     {ok, TransportFactory} = TransportFactoryTuple,
 
-    {ok, ProtocolFactory} = thrift_binary_protocol:new_protocol_factory(TransportFactory, ProtoOpts),
+    {ok, ProtocolFactory} = thrift_binary_protocol:new_protocol_factory(
+        TransportFactory, ProtoOpts
+    ),
 
     {ok, Protocol} = ProtocolFactory(),
 
-    {ok, [{ServiceName, element(2, thrift_client:new(element(2, thrift_multiplexed_protocol:new(Protocol, ServiceName)), Service))} || {ServiceName, Service} <- Services]}.
+    {ok, [
+        {ServiceName,
+            element(
+                2,
+                thrift_client:new(
+                    element(2, thrift_multiplexed_protocol:new(Protocol, ServiceName)), Service
+                )
+            )}
+     || {ServiceName, Service} <- Services
+    ]}.
diff --git a/lib/erl/src/thrift_compact_protocol.erl b/lib/erl/src/thrift_compact_protocol.erl
index 0f14221..f852fcb 100644
--- a/lib/erl/src/thrift_compact_protocol.erl
+++ b/lib/erl/src/thrift_compact_protocol.erl
@@ -24,28 +24,32 @@
 -include("thrift_constants.hrl").
 -include("thrift_protocol.hrl").
 
--export([new/1, new/2,
-         read/2,
-         write/2,
-         flush_transport/1,
-         close_transport/1,
-         new_protocol_factory/2
-        ]).
+-export([
+    new/1, new/2,
+    read/2,
+    write/2,
+    flush_transport/1,
+    close_transport/1,
+    new_protocol_factory/2
+]).
 
 -define(ID_NONE, 16#10000).
 -define(CBOOL_NONE, 0).
 -define(CBOOL_TRUE, 1).
 -define(CBOOL_FALSE, 2).
 
--record(t_compact, {transport,
-                           % state for pending boolean fields
-                           read_stack=[],
-                           read_value=?CBOOL_NONE,
-                           write_stack=[],
-                           write_id=?ID_NONE
-                          }).
--type state() :: #t_compact{}.
--include("thrift_protocol_behaviour.hrl").
+-type cbool() :: ?CBOOL_NONE | ?CBOOL_TRUE | ?CBOOL_FALSE.
+
+-record(t_compact, {
+    transport :: term(),
+    % state for pending boolean fields
+    read_stack = [] :: iodata(),
+    read_value = ?CBOOL_NONE :: cbool(),
+    write_stack = [] :: iodata(),
+    write_id = ?ID_NONE :: non_neg_integer()
+}).
+
+-type t_compact() :: #t_compact{}.
 
 -define(PROTOCOL_ID, 16#82).
 -define(VERSION_MASK, 16#1f).
@@ -67,19 +71,19 @@
 typeid_to_compact(?tType_SET) -> 16#A;
 typeid_to_compact(?tType_LIST) -> 16#9.
 
-compact_to_typeid(16#0) ->  ?tType_STOP;
-compact_to_typeid(?CBOOL_FALSE) ->  ?tType_BOOL;
-compact_to_typeid(?CBOOL_TRUE) ->  ?tType_BOOL;
-compact_to_typeid(16#7) ->  ?tType_DOUBLE;
-compact_to_typeid(16#3) ->  ?tType_I8;
-compact_to_typeid(16#4) ->  ?tType_I16;
-compact_to_typeid(16#5) ->  ?tType_I32;
-compact_to_typeid(16#6) ->  ?tType_I64;
-compact_to_typeid(16#8) ->  ?tType_STRING;
-compact_to_typeid(16#C) ->  ?tType_STRUCT;
-compact_to_typeid(16#B) ->  ?tType_MAP;
-compact_to_typeid(16#A) ->  ?tType_SET;
-compact_to_typeid(16#9) ->  ?tType_LIST.
+compact_to_typeid(16#0) -> ?tType_STOP;
+compact_to_typeid(?CBOOL_FALSE) -> ?tType_BOOL;
+compact_to_typeid(?CBOOL_TRUE) -> ?tType_BOOL;
+compact_to_typeid(16#7) -> ?tType_DOUBLE;
+compact_to_typeid(16#3) -> ?tType_I8;
+compact_to_typeid(16#4) -> ?tType_I16;
+compact_to_typeid(16#5) -> ?tType_I32;
+compact_to_typeid(16#6) -> ?tType_I64;
+compact_to_typeid(16#8) -> ?tType_STRING;
+compact_to_typeid(16#C) -> ?tType_STRUCT;
+compact_to_typeid(16#B) -> ?tType_MAP;
+compact_to_typeid(16#A) -> ?tType_SET;
+compact_to_typeid(16#9) -> ?tType_LIST.
 
 bool_to_cbool(Value) when Value -> ?CBOOL_TRUE;
 bool_to_cbool(_) -> ?CBOOL_FALSE.
@@ -88,30 +92,31 @@
 new(Transport) -> new(Transport, _Options = []).
 
 new(Transport, _Options) ->
-  State  = #t_compact{transport = Transport},
-  thrift_protocol:new(?MODULE, State).
+    State = #t_compact{transport = Transport},
+    thrift_protocol:new(?MODULE, State).
 
 flush_transport(This = #t_compact{transport = Transport}) ->
-  {NewTransport, Result} = thrift_transport:flush(Transport),
-  {This#t_compact{transport = NewTransport}, Result}.
+    {NewTransport, Result} = thrift_transport:flush(Transport),
+    {This#t_compact{transport = NewTransport}, Result}.
 
 close_transport(This = #t_compact{transport = Transport}) ->
-  {NewTransport, Result} = thrift_transport:close(Transport),
-  {This#t_compact{transport = NewTransport}, Result}.
+    {NewTransport, Result} = thrift_transport:close(Transport),
+    {This#t_compact{transport = NewTransport}, Result}.
 
 %%%
 %%% instance methods
 %%%
 
-write_field_begin(This0 = #t_compact{write_stack=[LastId|T]}, CompactType, Id) ->
-  IdDiff = Id - LastId,
-  This1 = This0#t_compact{write_stack=[Id|T]},
-  case (IdDiff > 0) and (IdDiff < 16) of
-    true -> write(This1, {byte, (IdDiff bsl 4) bor CompactType});
-    false ->
-      {This2, ok} = write(This1, {byte, CompactType}),
-      write(This2, {i16, Id})
-  end.
+write_field_begin(This0 = #t_compact{write_stack = [LastId | T]}, CompactType, Id) ->
+    IdDiff = Id - LastId,
+    This1 = This0#t_compact{write_stack = [Id | T]},
+    case (IdDiff > 0) and (IdDiff < 16) of
+        true ->
+            write(This1, {byte, (IdDiff bsl 4) bor CompactType});
+        false ->
+            {This2, ok} = write(This1, {byte, CompactType}),
+            write(This2, {i16, Id})
+    end.
 
 -spec to_zigzag(integer()) -> non_neg_integer().
 to_zigzag(Value) -> 16#FFFFFFFFFFFFFFFF band ((Value bsl 1) bxor (Value bsr 63)).
@@ -121,270 +126,270 @@
 
 -spec to_varint(non_neg_integer(), iolist()) -> iolist().
 to_varint(Value, Acc) when (Value < 16#80) -> [Acc, Value];
-to_varint(Value, Acc) ->
-  to_varint(Value bsr 7, [Acc, ((Value band 16#7F) bor 16#80)]).
+to_varint(Value, Acc) -> to_varint(Value bsr 7, [Acc, ((Value band 16#7F) bor 16#80)]).
 
--spec read_varint(#t_compact{}, non_neg_integer(), non_neg_integer()) -> non_neg_integer().
+-spec read_varint(t_compact(), non_neg_integer(), non_neg_integer()) ->
+    {t_compact(), {'ok', integer()}}.
 read_varint(This0, Acc, Count) ->
-  {This1, {ok, Byte}} = read(This0, byte),
-  case (Byte band 16#80) of
-    0 -> {This1, {ok, (Byte bsl (7 * Count)) + Acc}};
-    _ -> read_varint(This1, ((Byte band 16#7f) bsl (7 * Count)) + Acc, Count + 1)
-  end.
+    {This1, {ok, Byte}} = read(This0, byte),
+    case (Byte band 16#80) of
+        0 -> {This1, {ok, (Byte bsl (7 * Count)) + Acc}};
+        _ -> read_varint(This1, ((Byte band 16#7f) bsl (7 * Count)) + Acc, Count + 1)
+    end.
 
 write(This0, #protocol_message_begin{
-        name = Name,
-        type = Type,
-        seqid = Seqid}) ->
-  {This1, ok} = write(This0, {byte, ?PROTOCOL_ID}),
-  {This2, ok} = write(This1, {byte, (?VERSION_1 band ?VERSION_MASK) bor (Type bsl ?TYPE_SHIFT_AMOUNT)}),
-  {This3, ok} = write(This2, {ui32, Seqid}),
-  {This4, ok} = write(This3, {string, Name}),
-  {This4, ok};
-
-write(This, message_end) -> {This, ok};
-
+    name = Name,
+    type = Type,
+    seqid = Seqid
+}) ->
+    {This1, ok} = write(This0, {byte, ?PROTOCOL_ID}),
+    {This2, ok} = write(
+        This1, {byte, (?VERSION_1 band ?VERSION_MASK) bor (Type bsl ?TYPE_SHIFT_AMOUNT)}
+    ),
+    {This3, ok} = write(This2, {ui32, Seqid}),
+    {This4, ok} = write(This3, {string, Name}),
+    {This4, ok};
+write(This, message_end) ->
+    {This, ok};
 write(This0, #protocol_field_begin{
-       name = _Name,
-       type = Type,
-       id = Id})
-when (Type =:= ?tType_BOOL) -> {This0#t_compact{write_id = Id}, ok};
-
+    name = _Name,
+    type = Type,
+    id = Id
+}) when
+    (Type =:= ?tType_BOOL)
+->
+    {This0#t_compact{write_id = Id}, ok};
 write(This0, #protocol_field_begin{
-       name = _Name,
-       type = Type,
-       id = Id}) ->
-  write_field_begin(This0, typeid_to_compact(Type), Id);
-
-write(This, field_stop) -> write(This, {byte, ?tType_STOP});
-
-write(This, field_end) -> {This, ok};
-
+    name = _Name,
+    type = Type,
+    id = Id
+}) ->
+    write_field_begin(This0, typeid_to_compact(Type), Id);
+write(This, field_stop) ->
+    write(This, {byte, ?tType_STOP});
+write(This, field_end) ->
+    {This, ok};
 write(This0, #protocol_map_begin{
-      ktype = _Ktype,
-      vtype = _Vtype,
-      size = Size})
-when Size =:= 0 ->
-  write(This0, {byte, 0});
-
+    ktype = _Ktype,
+    vtype = _Vtype,
+    size = Size
+}) when
+    Size =:= 0
+->
+    write(This0, {byte, 0});
 write(This0, #protocol_map_begin{
-       ktype = Ktype,
-       vtype = Vtype,
-       size = Size}) ->
-  {This1, ok} = write(This0, {ui32, Size}),
-  write(This1, {byte, (typeid_to_compact(Ktype) bsl 4) bor typeid_to_compact(Vtype)});
-
-write(This, map_end) -> {This, ok};
-
+    ktype = Ktype,
+    vtype = Vtype,
+    size = Size
+}) ->
+    {This1, ok} = write(This0, {ui32, Size}),
+    write(This1, {byte, (typeid_to_compact(Ktype) bsl 4) bor typeid_to_compact(Vtype)});
+write(This, map_end) ->
+    {This, ok};
 write(This0, #protocol_list_begin{
-        etype = Etype,
-        size = Size})
-when Size < 16#f ->
-  write(This0, {byte, (Size bsl 4) bor typeid_to_compact(Etype)});
-
+    etype = Etype,
+    size = Size
+}) when
+    Size < 16#f
+->
+    write(This0, {byte, (Size bsl 4) bor typeid_to_compact(Etype)});
 write(This0, #protocol_list_begin{
-        etype = Etype,
-        size = Size}) ->
-  {This1, ok} = write(This0, {byte, 16#f0 bor typeid_to_compact(Etype)}),
-  write(This1, {ui32, Size});
-
-write(This, list_end) -> {This, ok};
-
+    etype = Etype,
+    size = Size
+}) ->
+    {This1, ok} = write(This0, {byte, 16#f0 bor typeid_to_compact(Etype)}),
+    write(This1, {ui32, Size});
+write(This, list_end) ->
+    {This, ok};
 write(This0, #protocol_set_begin{
-        etype = Etype,
-        size = Size}) ->
-  write(This0, #protocol_list_begin{etype = Etype, size =  Size});
-
-write(This, set_end) -> {This, ok};
-
+    etype = Etype,
+    size = Size
+}) ->
+    write(This0, #protocol_list_begin{etype = Etype, size = Size});
+write(This, set_end) ->
+    {This, ok};
 write(This = #t_compact{write_stack = Stack}, #protocol_struct_begin{}) ->
-  {This#t_compact{write_stack = [0|Stack]}, ok};
-write(This = #t_compact{write_stack = [_|T]}, struct_end) ->
-  {This#t_compact{write_stack = T}, ok};
-
+    {This#t_compact{write_stack = [0 | Stack]}, ok};
+write(This = #t_compact{write_stack = [_ | T]}, struct_end) ->
+    {This#t_compact{write_stack = T}, ok};
 write(This = #t_compact{write_id = ?ID_NONE}, {bool, Value}) ->
-  write(This, {byte, bool_to_cbool(Value)});
-
+    write(This, {byte, bool_to_cbool(Value)});
 write(This0 = #t_compact{write_id = Id}, {bool, Value}) ->
-  {This1, ok} = write_field_begin(This0, bool_to_cbool(Value), Id),
-  {This1#t_compact{write_id = ?ID_NONE}, ok};
-
+    {This1, ok} = write_field_begin(This0, bool_to_cbool(Value), Id),
+    {This1#t_compact{write_id = ?ID_NONE}, ok};
 write(This, {byte, Value}) when is_integer(Value) ->
-  write(This, <<Value:8/big-signed>>);
-
+    write(This, <<Value:8/big-signed>>);
 write(This, {i16, Value}) when is_integer(Value) -> write(This, to_varint(to_zigzag(Value), []));
 write(This, {ui32, Value}) when is_integer(Value) -> write(This, to_varint(Value, []));
 write(This, {i32, Value}) when is_integer(Value) ->
-  write(This, to_varint(to_zigzag(Value), []));
+    write(This, to_varint(to_zigzag(Value), []));
 write(This, {i64, Value}) when is_integer(Value) -> write(This, to_varint(to_zigzag(Value), []));
-
 write(This, {double, Double}) ->
-  write(This, <<Double:64/float-signed-little>>);
-
+    write(This, <<Double:64/float-signed-little>>);
 write(This0, {string, Str}) when is_list(Str) ->
-  % TODO: limit length
-  {This1, ok} = write(This0, {ui32, length(Str)}),
-  {This2, ok} = write(This1, list_to_binary(Str)),
-  {This2, ok};
-
+    % TODO: limit length
+    {This1, ok} = write(This0, {ui32, length(Str)}),
+    {This2, ok} = write(This1, list_to_binary(Str)),
+    {This2, ok};
 write(This0, {string, Bin}) when is_binary(Bin) ->
-  % TODO: limit length
-  {This1, ok} = write(This0, {ui32, size(Bin)}),
-  {This2, ok} = write(This1, Bin),
-  {This2, ok};
-
+    % TODO: limit length
+    {This1, ok} = write(This0, {ui32, size(Bin)}),
+    {This2, ok} = write(This1, Bin),
+    {This2, ok};
 %% Data :: iolist()
 write(This = #t_compact{transport = Trans}, Data) ->
-  {NewTransport, Result} = thrift_transport:write(Trans, Data),
-  {This#t_compact{transport = NewTransport}, Result}.
+    {NewTransport, Result} = thrift_transport:write(Trans, Data),
+    {This#t_compact{transport = NewTransport}, Result}.
 
 %%
 %%
 
 read(This0, message_begin) ->
-  {This1, {ok, ?PROTOCOL_ID}} = read(This0, ubyte),
-  {This2, {ok, VerAndType}} = read(This1, ubyte),
-  ?VERSION_1 = VerAndType band ?VERSION_MASK,
-  {This3, {ok, SeqId}} = read(This2, ui32),
-  {This4, {ok, Name}} = read(This3, string),
-  {This4, #protocol_message_begin{
-             name  = binary_to_list(Name),
-             type  = (VerAndType bsr ?TYPE_SHIFT_AMOUNT) band ?TYPE_BITS,
-             seqid = SeqId}};
-
-read(This, message_end) -> {This, ok};
-
+    {This1, {ok, ?PROTOCOL_ID}} = read(This0, ubyte),
+    {This2, {ok, VerAndType}} = read(This1, ubyte),
+    ?VERSION_1 = VerAndType band ?VERSION_MASK,
+    {This3, {ok, SeqId}} = read(This2, ui32),
+    {This4, {ok, Name}} = read(This3, string),
+    {This4, #protocol_message_begin{
+        name = binary_to_list(Name),
+        type = (VerAndType bsr ?TYPE_SHIFT_AMOUNT) band ?TYPE_BITS,
+        seqid = SeqId
+    }};
+read(This, message_end) ->
+    {This, ok};
 read(This = #t_compact{read_stack = Stack}, struct_begin) ->
-  {This#t_compact{read_stack = [0|Stack]}, ok};
-read(This = #t_compact{read_stack = [_H|T]}, struct_end) ->
-  {This#t_compact{read_stack = T}, ok};
-
-read(This0 = #t_compact{read_stack = [LastId|T]}, field_begin) ->
-  {This1, {ok, Byte}} = read(This0, ubyte),
-  case Byte band 16#f of
-    CompactType = ?tType_STOP ->
-      {This1, #protocol_field_begin{type = CompactType}};
-    CompactType ->
-      {This2, {ok, Id}} = case Byte bsr 4 of
-                            0 -> read(This1, i16);
-                            IdDiff ->
-                              {This1, {ok, LastId + IdDiff}}
-                          end,
-      case compact_to_typeid(CompactType) of
-        ?tType_BOOL ->
-          {This2#t_compact{read_stack = [Id|T], read_value = cbool_to_bool(CompactType)},
-           #protocol_field_begin{type = ?tType_BOOL, id = Id}};
-        Type ->
-          {This2#t_compact{read_stack = [Id|T]},
-           #protocol_field_begin{type = Type, id = Id}}
-      end
-  end;
-
-read(This, field_end) -> {This, ok};
-
+    {This#t_compact{read_stack = [0 | Stack]}, ok};
+read(This = #t_compact{read_stack = [_H | T]}, struct_end) ->
+    {This#t_compact{read_stack = T}, ok};
+read(This0 = #t_compact{read_stack = [LastId | T]}, field_begin) ->
+    {This1, {ok, Byte}} = read(This0, ubyte),
+    case Byte band 16#f of
+        CompactType = ?tType_STOP ->
+            {This1, #protocol_field_begin{type = CompactType}};
+        CompactType ->
+            {This2, {ok, Id}} =
+                case Byte bsr 4 of
+                    0 -> read(This1, i16);
+                    IdDiff -> {This1, {ok, LastId + IdDiff}}
+                end,
+            case compact_to_typeid(CompactType) of
+                ?tType_BOOL ->
+                    {
+                        This2#t_compact{
+                            read_stack = [Id | T], read_value = CompactType
+                        },
+                        #protocol_field_begin{type = ?tType_BOOL, id = Id}
+                    };
+                Type ->
+                    {This2#t_compact{read_stack = [Id | T]}, #protocol_field_begin{
+                        type = Type, id = Id
+                    }}
+            end
+    end;
+read(This, field_end) ->
+    {This, ok};
 read(This0, map_begin) ->
-  {This1, {ok, Size}}  = read(This0, ui32),
-  {This2, {ok, KV}} = case Size of
-                        0 -> {This1, {ok, 0}};
-                        _ -> read(This1, ubyte)
-                      end,
-  {This2, #protocol_map_begin{ktype = compact_to_typeid(KV bsr 4),
-                              vtype = compact_to_typeid(KV band 16#f),
-                              size = Size}};
-read(This, map_end) -> {This, ok};
-
+    {This1, {ok, Size}} = read(This0, ui32),
+    {This2, {ok, KV}} =
+        case Size of
+            0 -> {This1, {ok, 0}};
+            _ -> read(This1, ubyte)
+        end,
+    {This2, #protocol_map_begin{
+        ktype = compact_to_typeid(KV bsr 4),
+        vtype = compact_to_typeid(KV band 16#f),
+        size = Size
+    }};
+read(This, map_end) ->
+    {This, ok};
 read(This0, list_begin) ->
-  {This1, {ok, SizeAndType}} = read(This0, ubyte),
-  {This2, {ok, Size}} = case (SizeAndType bsr 4) band 16#f of
-                          16#f -> read(This1, ui32);
-                          Else -> {This1, {ok, Else}}
-                        end,
-  {This2, #protocol_list_begin{etype = compact_to_typeid(SizeAndType band 16#f),
-                               size = Size}};
-
-read(This, list_end) -> {This, ok};
-
+    {This1, {ok, SizeAndType}} = read(This0, ubyte),
+    {This2, {ok, Size}} =
+        case (SizeAndType bsr 4) band 16#f of
+            16#f -> read(This1, ui32);
+            Else -> {This1, {ok, Else}}
+        end,
+    {This2, #protocol_list_begin{
+        etype = compact_to_typeid(SizeAndType band 16#f),
+        size = Size
+    }};
+read(This, list_end) ->
+    {This, ok};
 read(This0, set_begin) ->
-  {This1, {ok, SizeAndType}} = read(This0, ubyte),
-  {This2, {ok, Size}} = case (SizeAndType bsr 4) band 16#f of
-                          16#f -> read(This1, ui32);
-                          Else -> {This1, {ok, Else}}
-                        end,
-  {This2, #protocol_set_begin{etype = compact_to_typeid(SizeAndType band 16#f),
-                               size = Size}};
-
-read(This, set_end) -> {This, ok};
-
+    {This1, {ok, SizeAndType}} = read(This0, ubyte),
+    {This2, {ok, Size}} =
+        case (SizeAndType bsr 4) band 16#f of
+            16#f -> read(This1, ui32);
+            Else -> {This1, {ok, Else}}
+        end,
+    {This2, #protocol_set_begin{
+        etype = compact_to_typeid(SizeAndType band 16#f),
+        size = Size
+    }};
+read(This, set_end) ->
+    {This, ok};
 read(This0, field_stop) ->
-  {This1, {ok, ?tType_STOP}} = read(This0, ubyte),
-  {This1, ok};
-
+    {This1, {ok, ?tType_STOP}} = read(This0, ubyte),
+    {This1, ok};
 %%
 
 read(This0 = #t_compact{read_value = ?CBOOL_NONE}, bool) ->
-  {This1, {ok, Byte}} = read(This0, ubyte),
-  {This1, {ok, cbool_to_bool(Byte)}};
-
+    {This1, {ok, Byte}} = read(This0, ubyte),
+    {This1, {ok, cbool_to_bool(Byte)}};
 read(This0 = #t_compact{read_value = Bool}, bool) ->
-  {This0#t_compact{read_value = ?CBOOL_NONE}, {ok, Bool}};
-
+    {This0#t_compact{read_value = ?CBOOL_NONE}, {ok, cbool_to_bool(Bool)}};
 read(This0, ubyte) ->
-  {This1, {ok, <<Val:8/integer-unsigned-big, _/binary>>}} = read_data(This0, 1),
-  {This1, {ok, Val}};
-
+    {This1, {ok, <<Val:8/integer-unsigned-big, _/binary>>}} = read_data(This0, 1),
+    {This1, {ok, Val}};
 read(This0, byte) ->
-  {This1, Bytes} = read_data(This0, 1),
-  case Bytes of
-    {ok, <<Val:8/integer-signed-big, _/binary>>} -> {This1, {ok, Val}};
-    Else -> {This1, Else}
-  end;
-
+    {This1, Bytes} = read_data(This0, 1),
+    case Bytes of
+        {ok, <<Val:8/integer-signed-big, _/binary>>} -> {This1, {ok, Val}};
+        Else -> {This1, Else}
+    end;
 read(This0, i16) ->
-  {This1, {ok, Zigzag}} = read_varint(This0, 0, 0),
-  {This1, {ok, from_zigzag(Zigzag)}};
-
-read(This0, ui32) -> read_varint(This0, 0, 0);
-
+    {This1, {ok, Zigzag}} = read_varint(This0, 0, 0),
+    {This1, {ok, from_zigzag(Zigzag)}};
+read(This0, ui32) ->
+    read_varint(This0, 0, 0);
 read(This0, i32) ->
-  {This1, {ok, Zigzag}} = read_varint(This0, 0, 0),
-  {This1, {ok, from_zigzag(Zigzag)}};
-
+    {This1, {ok, Zigzag}} = read_varint(This0, 0, 0),
+    {This1, {ok, from_zigzag(Zigzag)}};
 read(This0, i64) ->
-  {This1, {ok, Zigzag}} = read_varint(This0, 0, 0),
-  {This1, {ok, from_zigzag(Zigzag)}};
-
+    {This1, {ok, Zigzag}} = read_varint(This0, 0, 0),
+    {This1, {ok, from_zigzag(Zigzag)}};
 read(This0, double) ->
-  {This1, Bytes} = read_data(This0, 8),
-  case Bytes of
-    {ok, <<Val:64/float-signed-little, _/binary>>} -> {This1, {ok, Val}};
-    Else -> {This1, Else}
-  end;
-
+    {This1, Bytes} = read_data(This0, 8),
+    case Bytes of
+        {ok, <<Val:64/float-signed-little, _/binary>>} -> {This1, {ok, Val}};
+        Else -> {This1, Else}
+    end;
 % returns a binary directly, call binary_to_list if necessary
 read(This0, string) ->
-  {This1, {ok, Sz}}  = read(This0, ui32),
-  read_data(This1, Sz).
+    {This1, {ok, Sz}} = read(This0, ui32),
+    read_data(This1, Sz).
 
 -spec read_data(#t_compact{}, non_neg_integer()) ->
     {#t_compact{}, {ok, binary()} | {error, _Reason}}.
-read_data(This, 0) -> {This, {ok, <<>>}};
+read_data(This, 0) ->
+    {This, {ok, <<>>}};
 read_data(This = #t_compact{transport = Trans}, Len) when is_integer(Len) andalso Len > 0 ->
     {NewTransport, Result} = thrift_transport:read(Trans, Len),
     {This#t_compact{transport = NewTransport}, Result}.
 
-
 %%%% FACTORY GENERATION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 %% returns a (fun() -> thrift_protocol())
 new_protocol_factory(TransportFactory, _Options) ->
-  F = fun() ->
-          case TransportFactory() of
+    F = fun() ->
+        case TransportFactory() of
             {ok, Transport} ->
-              thrift_compact_protocol:new(
-                Transport,
-                []);
+                thrift_compact_protocol:new(
+                    Transport,
+                    []
+                );
             {error, Error} ->
-              {error, Error}
-          end
-      end,
-  {ok, F}.
+                {error, Error}
+        end
+    end,
+    {ok, F}.
diff --git a/lib/erl/src/thrift_disk_log_transport.erl b/lib/erl/src/thrift_disk_log_transport.erl
index de8ee41..733d88f 100644
--- a/lib/erl/src/thrift_disk_log_transport.erl
+++ b/lib/erl/src/thrift_disk_log_transport.erl
@@ -31,13 +31,13 @@
 -export([read/2, write/2, force_flush/1, flush/1, close/1]).
 
 %% state
--record(dl_transport, {log,
-                       close_on_close = false,
-                       sync_every = infinity,
-                       sync_tref}).
--type state() :: #dl_transport{}.
--include("thrift_transport_behaviour.hrl").
-
+-record(dl_transport, {
+    %% Keep in sync with disk_log:log/0 type
+    log :: term(),
+    close_on_close = false :: boolean(),
+    sync_every = infinity :: undefined | timeout(),
+    sync_tref :: undefined | timer:tref()
+}).
 
 %% Create a transport attached to an already open log.
 %% If you'd like this transport to close the disk_log using disk_log:lclose()
@@ -51,12 +51,12 @@
             N when is_integer(N), N > 0 ->
                 {ok, TRef} = timer:apply_interval(N, ?MODULE, force_flush, [State]),
                 State#dl_transport{sync_tref = TRef};
-            _ -> State
+            _ ->
+                State
         end,
 
     thrift_transport:new(?MODULE, State2).
 
-
 parse_opts([], State) ->
     State;
 parse_opts([{close_on_close, Bool} | Rest], State) when is_boolean(Bool) ->
@@ -64,7 +64,6 @@
 parse_opts([{sync_every, Int} | Rest], State) when is_integer(Int), Int > 0 ->
     parse_opts(Rest, State#dl_transport{sync_every = Int}).
 
-
 %%%% TRANSPORT IMPLENTATION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 %% disk_log_transport is write-only
@@ -80,38 +79,40 @@
 
 flush(This = #dl_transport{log = Log, sync_every = SE}) ->
     case SE of
-        undefined -> % no time-based sync
-            disk_log:sync(Log);
-        _Else ->     % sync will happen automagically
+        % no time-based sync
+        undefined ->
+            ok = disk_log:sync(Log);
+        % sync will happen automagically
+        _Else ->
             ok
     end,
     {This, ok}.
 
-
-
-
 %% On close, close the underlying log if we're configured to do so.
 close(This = #dl_transport{close_on_close = false}) ->
     {This, ok};
 close(This = #dl_transport{log = Log}) ->
-    {This, disk_log:lclose(Log)}.
-
+    {This, disk_log:close(Log)}.
 
 %%%% FACTORY GENERATION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
 new_transport_factory(Name, ExtraLogOpts) ->
-    new_transport_factory(Name, ExtraLogOpts, [{close_on_close, true},
-                                               {sync_every, 500}]).
+    new_transport_factory(Name, ExtraLogOpts, [
+        {close_on_close, true},
+        {sync_every, 500}
+    ]).
 
 new_transport_factory(Name, ExtraLogOpts, TransportOpts) ->
     F = fun() -> factory_impl(Name, ExtraLogOpts, TransportOpts) end,
     {ok, F}.
 
 factory_impl(Name, ExtraLogOpts, TransportOpts) ->
-    LogOpts = [{name, Name},
-               {format, external},
-               {type, wrap} |
-               ExtraLogOpts],
+    LogOpts = [
+        {name, Name},
+        {format, external},
+        {type, wrap}
+        | ExtraLogOpts
+    ],
     Log =
         case disk_log:open(LogOpts) of
             {ok, LogS} ->
diff --git a/lib/erl/src/thrift_file_transport.erl b/lib/erl/src/thrift_file_transport.erl
index 071152b..b0bf383 100644
--- a/lib/erl/src/thrift_file_transport.erl
+++ b/lib/erl/src/thrift_file_transport.erl
@@ -28,88 +28,76 @@
 %% legacy api
 -export([new_reader/1]).
 
-
 -record(t_file, {
-  device,
-  should_close = true,
-  mode = write
+    device :: file:io_device(),
+    should_close = true :: boolean(),
+    mode = write :: file:mode()
 }).
 
--type state() :: #t_file{}.
-
-
--spec new(Device::file:io_device()) ->
-  thrift_transport:t_transport().
+-spec new(Device :: file:io_device()) -> {ok, thrift_transport:t_transport()}.
 
 new(Device) -> new(Device, []).
 
--spec new(Device::file:io_device(), Opts::list()) ->
-  thrift_transport:t_transport().
+-spec new(Device :: file:io_device(), Opts :: list()) -> {ok, thrift_transport:t_transport()}.
 
 %% Device should be opened in raw and binary mode.
 new(Device, Opts) when is_list(Opts) ->
-  State = parse_opts(Opts, #t_file{device = Device}),
-  thrift_transport:new(?MODULE, State).
+    State = parse_opts(Opts, #t_file{device = Device}),
+    thrift_transport:new(?MODULE, State).
 
-
-parse_opts([{should_close, Bool}|Rest], State)
-when is_boolean(Bool) ->
-  parse_opts(Rest, State#t_file{should_close = Bool});
-parse_opts([{mode, Mode}|Rest], State)
-when Mode =:= write; Mode =:= read ->
-  parse_opts(Rest, State#t_file{mode = Mode});
+parse_opts([{should_close, Bool} | Rest], State) when
+    is_boolean(Bool)
+->
+    parse_opts(Rest, State#t_file{should_close = Bool});
+parse_opts([{mode, Mode} | Rest], State) when
+    Mode =:= write; Mode =:= read
+->
+    parse_opts(Rest, State#t_file{mode = Mode});
 parse_opts([], State) ->
-  State.
+    State.
 
-
--include("thrift_transport_behaviour.hrl").
-
-
-read(State = #t_file{device = Device, mode = read}, Len)
-when is_integer(Len), Len >= 0 ->
-  case file:read(Device, Len) of
-    eof -> {State, {error, eof}};
-    {ok, Result} -> {State, {ok, iolist_to_binary(Result)}}
-  end;
+read(State = #t_file{device = Device, mode = read}, Len) when
+    is_integer(Len), Len >= 0
+->
+    case file:read(Device, Len) of
+        eof -> {State, {error, eof}};
+        {ok, Result} -> {State, {ok, iolist_to_binary(Result)}}
+    end;
 read(State, _) ->
-  {State, {error, write_mode}}.
+    {State, {error, write_mode}}.
 
-
-read_exact(State = #t_file{device = Device, mode = read}, Len)
-when is_integer(Len), Len >= 0 ->
-  case file:read(Device, Len) of
-    eof -> {State, {error, eof}};
-    {ok, Result} ->
-      case iolist_size(Result) of
-        X when X < Len -> {State, {error, eof}};
-        _ -> {State, {ok, iolist_to_binary(Result)}}
-      end
-  end;
+read_exact(State = #t_file{device = Device, mode = read}, Len) when
+    is_integer(Len), Len >= 0
+->
+    case file:read(Device, Len) of
+        eof ->
+            {State, {error, eof}};
+        {ok, Result} ->
+            case iolist_size(Result) of
+                X when X < Len -> {State, {error, eof}};
+                _ -> {State, {ok, iolist_to_binary(Result)}}
+            end
+    end;
 read_exact(State, _) ->
-  {State, {error, write_mode}}.
-
+    {State, {error, write_mode}}.
 
 write(State = #t_file{device = Device, mode = write}, Data) ->
-  {State, file:write(Device, Data)};
+    {State, file:write(Device, Data)};
 write(State, _) ->
-  {State, {error, read_mode}}.
-
+    {State, {error, read_mode}}.
 
 flush(State = #t_file{device = Device, mode = write}) ->
-  {State, file:sync(Device)}.
-
+    {State, file:sync(Device)}.
 
 close(State = #t_file{device = Device, should_close = SC}) ->
-  case SC of
-    true -> {State, file:close(Device)};
-    false -> {State, ok}
-  end.
-
+    case SC of
+        true -> {State, file:close(Device)};
+        false -> {State, ok}
+    end.
 
 %% legacy api. left for compatibility
 new_reader(Filename) ->
-  case file:open(Filename, [read, binary, {read_ahead, 1024*1024}]) of
-    {ok, IODevice} -> new(IODevice, [{should_close, true}, {mode, read}]);
-    Error -> Error
-  end.
-
+    case file:open(Filename, [read, binary, {read_ahead, 1024 * 1024}]) of
+        {ok, IODevice} -> new(IODevice, [{should_close, true}, {mode, read}]);
+        Error -> Error
+    end.
diff --git a/lib/erl/src/thrift_framed_transport.erl b/lib/erl/src/thrift_framed_transport.erl
index 9a5d6af..0d93baa 100644
--- a/lib/erl/src/thrift_framed_transport.erl
+++ b/lib/erl/src/thrift_framed_transport.erl
@@ -26,101 +26,92 @@
 %% protocol callbacks
 -export([read/2, read_exact/2, write/2, flush/1, close/1]).
 
-
 -record(t_framed, {
-  wrapped,
-  read_buffer,
-  write_buffer
+    wrapped :: thrift_transport:t_transport(),
+    read_buffer :: iodata(),
+    write_buffer :: iodata()
 }).
 
--type state() :: #t_framed{}.
-
-
--spec new(Transport::thrift_transport:t_transport()) ->
-  thrift_transport:t_transport().
+-spec new(Transport :: thrift_transport:t_transport()) -> {ok, thrift_transport:t_transport()}.
 
 new(Wrapped) ->
-  State = #t_framed{
-    wrapped = Wrapped,
-    read_buffer = [],
-    write_buffer = []
-  },
-  thrift_transport:new(?MODULE, State).
+    State = #t_framed{
+        wrapped = Wrapped,
+        read_buffer = [],
+        write_buffer = []
+    },
+    thrift_transport:new(?MODULE, State).
 
+read(State = #t_framed{wrapped = Wrapped, read_buffer = Buffer}, Len) when
+    is_integer(Len), Len >= 0
+->
+    Binary = iolist_to_binary(Buffer),
+    case Binary of
+        <<>> when Len > 0 ->
+            case next_frame(Wrapped) of
+                {NewState, {ok, Frame}} ->
+                    NewBinary = iolist_to_binary([Binary, Frame]),
+                    Give = min(iolist_size(NewBinary), Len),
+                    {Result, Remaining} = split_binary(NewBinary, Give),
+                    {State#t_framed{wrapped = NewState, read_buffer = Remaining}, {ok, Result}};
+                {NewState, Error} ->
+                    {State#t_framed{wrapped = NewState}, Error}
+            end;
+        %% read of zero bytes
+        <<>> ->
+            {State, {ok, <<>>}};
+        %% read buffer is nonempty
+        _ ->
+            Give = min(iolist_size(Binary), Len),
+            {Result, Remaining} = split_binary(Binary, Give),
+            {State#t_framed{read_buffer = Remaining}, {ok, Result}}
+    end.
 
--include("thrift_transport_behaviour.hrl").
-
-
-read(State = #t_framed{wrapped = Wrapped, read_buffer = Buffer}, Len)
-when is_integer(Len), Len >= 0 ->
-  Binary = iolist_to_binary(Buffer),
-  case Binary of
-    <<>> when Len > 0 ->
-      case next_frame(Wrapped) of
-        {NewState, {ok, Frame}} ->
-          NewBinary = iolist_to_binary([Binary, Frame]),
-          Give = min(iolist_size(NewBinary), Len),
-          {Result, Remaining} = split_binary(NewBinary, Give),
-          {State#t_framed{wrapped = NewState, read_buffer = Remaining}, {ok, Result}};
-        {NewState, Error} ->
-          {State#t_framed{wrapped = NewState}, Error}
-      end;
-    %% read of zero bytes
-    <<>> -> {State, {ok, <<>>}};
-    %% read buffer is nonempty
-    _ ->
-      Give = min(iolist_size(Binary), Len),
-      {Result, Remaining} = split_binary(Binary, Give),
-      {State#t_framed{read_buffer = Remaining}, {ok, Result}}
-  end.
-
-
-read_exact(State = #t_framed{wrapped = Wrapped, read_buffer = Buffer}, Len)
-when is_integer(Len), Len >= 0 ->
-  Binary = iolist_to_binary(Buffer),
-  case iolist_size(Binary) of
-    %% read buffer is larger than requested read size
-    X when X >= Len ->
-      {Result, Remaining} = split_binary(Binary, Len),
-      {State#t_framed{read_buffer = Remaining}, {ok, Result}};
-    %% read buffer is insufficient for requested read size
-    _ ->
-      case next_frame(Wrapped) of
-        {NewState, {ok, Frame}} ->
-          read_exact(
-            State#t_framed{wrapped = NewState, read_buffer = [Buffer, Frame]},
-            Len
-          );
-        {NewState, Error} ->
-          {State#t_framed{wrapped = NewState}, Error}
-      end
-  end.
+read_exact(State = #t_framed{wrapped = Wrapped, read_buffer = Buffer}, Len) when
+    is_integer(Len), Len >= 0
+->
+    Binary = iolist_to_binary(Buffer),
+    case iolist_size(Binary) of
+        %% read buffer is larger than requested read size
+        X when X >= Len ->
+            {Result, Remaining} = split_binary(Binary, Len),
+            {State#t_framed{read_buffer = Remaining}, {ok, Result}};
+        %% read buffer is insufficient for requested read size
+        _ ->
+            case next_frame(Wrapped) of
+                {NewState, {ok, Frame}} ->
+                    read_exact(
+                        State#t_framed{wrapped = NewState, read_buffer = [Buffer, Frame]},
+                        Len
+                    );
+                {NewState, Error} ->
+                    {State#t_framed{wrapped = NewState}, Error}
+            end
+    end.
 
 next_frame(Transport) ->
-  case thrift_transport:read_exact(Transport, 4) of
-    {NewState, {ok, <<FrameLength:32/integer-signed-big>>}} ->
-      thrift_transport:read_exact(NewState, FrameLength);
-    Error -> Error
-  end.
-
+    case thrift_transport:read_exact(Transport, 4) of
+        {NewState, {ok, <<FrameLength:32/integer-signed-big>>}} ->
+            thrift_transport:read_exact(NewState, FrameLength);
+        Error ->
+            Error
+    end.
 
 write(State = #t_framed{write_buffer = Buffer}, Data) ->
-  {State#t_framed{write_buffer = [Buffer, Data]}, ok}.
-
+    {State#t_framed{write_buffer = [Buffer, Data]}, ok}.
 
 flush(State = #t_framed{write_buffer = Buffer, wrapped = Wrapped}) ->
-  case iolist_size(Buffer) of
-    %% if write buffer is empty, do nothing
-    0 -> {State, ok};
-    FrameLen ->
-      Data = [<<FrameLen:32/integer-signed-big>>, Buffer],
-      {Written, Response} = thrift_transport:write(Wrapped, Data),
-      {Flushed, ok} = thrift_transport:flush(Written),
-      {State#t_framed{wrapped = Flushed, write_buffer = []}, Response}
-  end.
-
+    case iolist_size(Buffer) of
+        %% if write buffer is empty, do nothing
+        0 ->
+            {State, ok};
+        FrameLen ->
+            Data = [<<FrameLen:32/integer-signed-big>>, Buffer],
+            {Written, Response} = thrift_transport:write(Wrapped, Data),
+            {Flushed, ok} = thrift_transport:flush(Written),
+            {State#t_framed{wrapped = Flushed, write_buffer = []}, Response}
+    end.
 
 close(State = #t_framed{wrapped = Wrapped}) ->
-  {Closed, Result} = thrift_transport:close(Wrapped),
-  {State#t_framed{wrapped = Closed}, Result}.
-
+    {Closed, Result} = thrift_transport:close(Wrapped),
+    {State#t_framed{wrapped = Closed}, Result}.
diff --git a/lib/erl/src/thrift_http_transport.erl b/lib/erl/src/thrift_http_transport.erl
index 46bcede..b422b3f 100644
--- a/lib/erl/src/thrift_http_transport.erl
+++ b/lib/erl/src/thrift_http_transport.erl
@@ -27,15 +27,16 @@
 %% thrift_transport callbacks
 -export([write/2, read/2, flush/1, close/1]).
 
--record(http_transport, {host, % string()
-                         path, % string()
-                         read_buffer, % iolist()
-                         write_buffer, % iolist()
-                         http_options, % see http(3)
-                         extra_headers % [{str(), str()}, ...]
-                        }).
--type state() :: #http_transport{}.
--include("thrift_transport_behaviour.hrl").
+% string()
+-record(http_transport, {
+    host :: string(),
+    path :: string(),
+    read_buffer :: iodata(),
+    write_buffer :: iodata(),
+    % see httpc(3)
+    http_options :: [{atom(), term()}],
+    extra_headers :: [{string(), string()}]
+}).
 
 new(Host, Path) ->
     new(Host, Path, _Options = []).
@@ -46,12 +47,14 @@
 %%   {extra_headers, ExtraHeaders}  = List of extra HTTP headers
 %%--------------------------------------------------------------------
 new(Host, Path, Options) ->
-    State1 = #http_transport{host = Host,
-                             path = Path,
-                             read_buffer = [],
-                             write_buffer = [],
-                             http_options = [],
-                             extra_headers = []},
+    State1 = #http_transport{
+        host = Host,
+        path = Path,
+        read_buffer = [],
+        write_buffer = [],
+        http_options = [],
+        extra_headers = []
+    },
     ApplyOption =
         fun
             ({http_options, HttpOpts}, State = #http_transport{}) ->
@@ -75,28 +78,38 @@
     {State#http_transport{write_buffer = [WBuf, Data]}, ok}.
 
 %% Flushes the buffer, making a request
-flush(State = #http_transport{host = Host,
-                                 path = Path,
-                                 read_buffer = Rbuf,
-                                 write_buffer = Wbuf,
-                                 http_options = HttpOptions,
-                                 extra_headers = ExtraHeaders}) ->
+flush(
+    State = #http_transport{
+        host = Host,
+        path = Path,
+        read_buffer = Rbuf,
+        write_buffer = Wbuf,
+        http_options = HttpOptions,
+        extra_headers = ExtraHeaders
+    }
+) ->
     case iolist_to_binary(Wbuf) of
         <<>> ->
             %% Don't bother flushing empty buffers.
             {State, ok};
         WBinary ->
             {ok, {{_Version, 200, _ReasonPhrase}, _Headers, Body}} =
-              httpc:request(post,
-                           {"http://" ++ Host ++ Path,
-                            [{"User-Agent", "Erlang/thrift_http_transport"} | ExtraHeaders],
-                            "application/x-thrift",
-                            WBinary},
-                           HttpOptions,
-                           [{body_format, binary}]),
+                httpc:request(
+                    post,
+                    {
+                        "http://" ++ Host ++ Path,
+                        [{"User-Agent", "Erlang/thrift_http_transport"} | ExtraHeaders],
+                        "application/x-thrift",
+                        WBinary
+                    },
+                    HttpOptions,
+                    [{body_format, binary}]
+                ),
 
-            State1 = State#http_transport{read_buffer = [Rbuf, Body],
-                                          write_buffer = []},
+            State1 = State#http_transport{
+                read_buffer = [Rbuf, Body],
+                write_buffer = []
+            },
             {State1, ok}
     end.
 
@@ -109,7 +122,7 @@
     case iolist_to_binary(RBuf) of
         <<Data:Give/binary, RBuf1/binary>> ->
             Response = {ok, Data},
-            State1 = State#http_transport{read_buffer=RBuf1},
+            State1 = State#http_transport{read_buffer = RBuf1},
             {State1, Response};
         _ ->
             {State, {error, 'EOF'}}
diff --git a/lib/erl/src/thrift_json_parser.erl b/lib/erl/src/thrift_json_parser.erl
index 4e47f10..18e0c03 100644
--- a/lib/erl/src/thrift_json_parser.erl
+++ b/lib/erl/src/thrift_json_parser.erl
@@ -22,19 +22,15 @@
 -module(thrift_json_parser).
 -export([parser/0, handle_event/2]).
 
-
 -record(config, {strict_utf8 = false :: boolean()}).
 
-
 parser() -> fun(JSON) -> start(JSON, {?MODULE, []}, [], #config{}) end.
 
-
 handle_event(Event, {Handler, State}, _Config) -> {Handler, Handler:handle_event(Event, State)}.
 
 handle_event(end_json, State) -> lists:reverse([end_json] ++ State);
 handle_event(Event, State) -> [Event] ++ State.
 
-
 %% whitespace
 -define(space, 16#20).
 -define(tab, 16#09).
@@ -68,12 +64,11 @@
 %% comments
 -define(star, 16#2A).
 
-
 %% some useful guards
 -define(is_hex(Symbol),
     (Symbol >= $a andalso Symbol =< $f) orelse
-    (Symbol >= $A andalso Symbol =< $F) orelse
-    (Symbol >= $0 andalso Symbol =< $9)
+        (Symbol >= $A andalso Symbol =< $F) orelse
+        (Symbol >= $0 andalso Symbol =< $9)
 ).
 
 -define(is_nonzero(Symbol),
@@ -84,7 +79,6 @@
     Symbol =:= ?space; Symbol =:= ?tab; Symbol =:= ?cr; Symbol =:= ?newline
 ).
 
-
 %% lists are benchmarked to be faster (tho higher in memory usage) than binaries
 new_seq() -> [].
 new_seq(C) -> [C].
@@ -96,13 +90,11 @@
 
 end_seq(Seq, _) -> end_seq(Seq).
 
-
 start(<<16#ef, 16#bb, 16#bf, Rest/binary>>, Handler, Stack, Config) ->
     value(Rest, Handler, Stack, Config);
 start(Bin, Handler, Stack, Config) ->
     value(Bin, Handler, Stack, Config).
 
-
 value(<<?doublequote, Rest/binary>>, Handler, Stack, Config) ->
     string(Rest, Handler, new_seq(), Stack, Config);
 value(<<$t, Rest/binary>>, Handler, Stack, Config) ->
@@ -118,41 +110,37 @@
 value(<<S, Rest/binary>>, Handler, Stack, Config) when ?is_nonzero(S) ->
     integer(Rest, Handler, new_seq(S), Stack, Config);
 value(<<?start_object, Rest/binary>>, Handler, Stack, Config) ->
-    object(Rest, handle_event(start_object, Handler, Config), [key|Stack], Config);
+    object(Rest, handle_event(start_object, Handler, Config), [key | Stack], Config);
 value(<<?start_array, Rest/binary>>, Handler, Stack, Config) ->
-    array(Rest, handle_event(start_array, Handler, Config), [array|Stack], Config);
+    array(Rest, handle_event(start_array, Handler, Config), [array | Stack], Config);
 value(<<S, Rest/binary>>, Handler, Stack, Config) when ?is_whitespace(S) ->
     value(Rest, Handler, Stack, Config);
 value(_Bin, _Handler, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 object(<<?doublequote, Rest/binary>>, Handler, Stack, Config) ->
     string(Rest, Handler, new_seq(), Stack, Config);
-object(<<?end_object, Rest/binary>>, Handler, [key|Stack], Config) ->
+object(<<?end_object, Rest/binary>>, Handler, [key | Stack], Config) ->
     maybe_done(Rest, handle_event(end_object, Handler, Config), Stack, Config);
 object(<<S, Rest/binary>>, Handler, Stack, Config) when ?is_whitespace(S) ->
     object(Rest, Handler, Stack, Config);
 object(_Bin, _Handler, _Stack, _Config) ->
     erlang:error(badarg).
 
-
-array(<<?end_array, Rest/binary>>, Handler, [array|Stack], Config) ->
+array(<<?end_array, Rest/binary>>, Handler, [array | Stack], Config) ->
     maybe_done(Rest, handle_event(end_array, Handler, Config), Stack, Config);
 array(<<S, Rest/binary>>, Handler, Stack, Config) when ?is_whitespace(S) ->
     array(Rest, Handler, Stack, Config);
 array(Bin, Handler, Stack, Config) ->
     value(Bin, Handler, Stack, Config).
 
-
-colon(<<?colon, Rest/binary>>, Handler, [key|Stack], Config) ->
-    value(Rest, Handler, [object|Stack], Config);
+colon(<<?colon, Rest/binary>>, Handler, [key | Stack], Config) ->
+    value(Rest, Handler, [object | Stack], Config);
 colon(<<S, Rest/binary>>, Handler, Stack, Config) when ?is_whitespace(S) ->
     colon(Rest, Handler, Stack, Config);
 colon(_Bin, _Handler, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 key(<<?doublequote, Rest/binary>>, Handler, Stack, Config) ->
     string(Rest, Handler, new_seq(), Stack, Config);
 key(<<S, Rest/binary>>, Handler, Stack, Config) when ?is_whitespace(S) ->
@@ -160,7 +148,6 @@
 key(_Bin, _Handler, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 %% note that if you encounter an error from string and you can't find the clause that
 %%  caused it here, it might be in unescape below
 string(<<?doublequote, Rest/binary>>, Handler, Acc, Stack, Config) ->
@@ -212,42 +199,47 @@
 string(<<X/utf8, Rest/binary>>, Handler, Acc, Stack, Config) when X >= 16#100000, X < 16#10fffe ->
     string(Rest, Handler, acc_seq(Acc, X), Stack, Config);
 %% surrogates
-string(<<237, X, _, Rest/binary>>, Handler, Acc, Stack, Config=#config{strict_utf8=false})
-        when X >= 160 ->
+string(<<237, X, _, Rest/binary>>, Handler, Acc, Stack, Config = #config{strict_utf8 = false}) when
+    X >= 160
+->
     string(Rest, Handler, acc_seq(Acc, 16#fffd), Stack, Config);
 %% u+xfffe, u+xffff, control codes and other noncharacters
-string(<<_/utf8, Rest/binary>>, Handler, Acc, Stack, Config=#config{strict_utf8=false}) ->
+string(<<_/utf8, Rest/binary>>, Handler, Acc, Stack, Config = #config{strict_utf8 = false}) ->
     string(Rest, Handler, acc_seq(Acc, 16#fffd), Stack, Config);
 %% u+fffe and u+ffff for R14BXX (subsequent runtimes will happily match the
 %%  preceding clause
-string(<<239, 191, X, Rest/binary>>, Handler, Acc, Stack, Config=#config{strict_utf8=false})
-        when X == 190; X == 191 ->
+string(
+    <<239, 191, X, Rest/binary>>, Handler, Acc, Stack, Config = #config{strict_utf8 = false}
+) when
+    X == 190; X == 191
+->
     string(Rest, Handler, acc_seq(Acc, 16#fffd), Stack, Config);
 %% overlong encodings and missing continuations of a 2 byte sequence
-string(<<X, Rest/binary>>, Handler, Acc, Stack, Config=#config{strict_utf8=false})
-        when X >= 192, X =< 223 ->
+string(<<X, Rest/binary>>, Handler, Acc, Stack, Config = #config{strict_utf8 = false}) when
+    X >= 192, X =< 223
+->
     strip_continuations(Rest, Handler, Acc, Stack, Config, 1);
 %% overlong encodings and missing continuations of a 3 byte sequence
-string(<<X, Rest/binary>>, Handler, Acc, Stack, Config=#config{strict_utf8=false})
-        when X >= 224, X =< 239 ->
+string(<<X, Rest/binary>>, Handler, Acc, Stack, Config = #config{strict_utf8 = false}) when
+    X >= 224, X =< 239
+->
     strip_continuations(Rest, Handler, Acc, Stack, Config, 2);
 %% overlong encodings and missing continuations of a 4 byte sequence
-string(<<X, Rest/binary>>, Handler, Acc, Stack, Config=#config{strict_utf8=false})
-        when X >= 240, X =< 247 ->
+string(<<X, Rest/binary>>, Handler, Acc, Stack, Config = #config{strict_utf8 = false}) when
+    X >= 240, X =< 247
+->
     strip_continuations(Rest, Handler, Acc, Stack, Config, 3);
 %% incompletes and unexpected bytes, including orphan continuations
-string(<<_, Rest/binary>>, Handler, Acc, Stack, Config=#config{strict_utf8=false}) ->
+string(<<_, Rest/binary>>, Handler, Acc, Stack, Config = #config{strict_utf8 = false}) ->
     string(Rest, Handler, acc_seq(Acc, 16#fffd), Stack, Config);
 string(_Bin, _Handler, _Acc, _Stack, _Config) ->
-  erlang:error(badarg).
+    erlang:error(badarg).
 
-
-doublequote(Rest, Handler, Acc, [key|_] = Stack, Config) ->
+doublequote(Rest, Handler, Acc, [key | _] = Stack, Config) ->
     colon(Rest, handle_event({key, end_seq(Acc, Config)}, Handler, Config), Stack, Config);
 doublequote(Rest, Handler, Acc, Stack, Config) ->
     maybe_done(Rest, handle_event({string, end_seq(Acc, Config)}, Handler, Config), Stack, Config).
 
-
 %% strips continuation bytes after bad utf bytes, guards against both too short
 %%  and overlong sequences. N is the maximum number of bytes to strip
 strip_continuations(<<Rest/binary>>, Handler, Acc, Stack, Config, 0) ->
@@ -259,7 +251,6 @@
 strip_continuations(<<Rest/binary>>, Handler, Acc, Stack, Config, _) ->
     string(Rest, Handler, acc_seq(Acc, 16#fffd), Stack, Config).
 
-
 %% this all gets really gross and should probably eventually be folded into
 %%  but for now it fakes being part of string on incompletes and errors
 unescape(<<$b, Rest/binary>>, Handler, Acc, Stack, Config) ->
@@ -278,22 +269,35 @@
     string(Rest, Handler, acc_seq(Acc, $\\), Stack, Config);
 unescape(<<?solidus, Rest/binary>>, Handler, Acc, Stack, Config) ->
     string(Rest, Handler, acc_seq(Acc, $/), Stack, Config);
-unescape(<<$u, $d, A, B, C, ?rsolidus, $u, $d, X, Y, Z, Rest/binary>>, Handler, Acc, Stack, Config)
-        when (A == $8 orelse A == $9 orelse A == $a orelse A == $b),
-             (X == $c orelse X == $d orelse X == $e orelse X == $f),
-             ?is_hex(B), ?is_hex(C), ?is_hex(Y), ?is_hex(Z)
-        ->
+unescape(
+    <<$u, $d, A, B, C, ?rsolidus, $u, $d, X, Y, Z, Rest/binary>>, Handler, Acc, Stack, Config
+) when
+    (A == $8 orelse A == $9 orelse A == $a orelse A == $b),
+    (X == $c orelse X == $d orelse X == $e orelse X == $f),
+    ?is_hex(B),
+    ?is_hex(C),
+    ?is_hex(Y),
+    ?is_hex(Z)
+->
     High = erlang:list_to_integer([$d, A, B, C], 16),
     Low = erlang:list_to_integer([$d, X, Y, Z], 16),
     Codepoint = (High - 16#d800) * 16#400 + (Low - 16#dc00) + 16#10000,
     string(Rest, Handler, acc_seq(Acc, Codepoint), Stack, Config);
-unescape(<<$u, $d, A, B, C, ?rsolidus, $u, W, X, Y, Z, Rest/binary>>, Handler, Acc, Stack, Config)
-        when (A == $8 orelse A == $9 orelse A == $a orelse A == $b),
-             ?is_hex(B), ?is_hex(C), ?is_hex(W), ?is_hex(X), ?is_hex(Y), ?is_hex(Z)
-        ->
+unescape(
+    <<$u, $d, A, B, C, ?rsolidus, $u, W, X, Y, Z, Rest/binary>>, Handler, Acc, Stack, Config
+) when
+    (A == $8 orelse A == $9 orelse A == $a orelse A == $b),
+    ?is_hex(B),
+    ?is_hex(C),
+    ?is_hex(W),
+    ?is_hex(X),
+    ?is_hex(Y),
+    ?is_hex(Z)
+->
     string(Rest, Handler, acc_seq(Acc, [16#fffd, 16#fffd]), Stack, Config);
-unescape(<<$u, A, B, C, D, Rest/binary>>, Handler, Acc, Stack, Config)
-        when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) ->
+unescape(<<$u, A, B, C, D, Rest/binary>>, Handler, Acc, Stack, Config) when
+    ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D)
+->
     case erlang:list_to_integer([A, B, C, D], 16) of
         Codepoint when Codepoint < 16#d800; Codepoint > 16#dfff ->
             string(Rest, Handler, acc_seq(Acc, Codepoint), Stack, Config);
@@ -303,7 +307,6 @@
 unescape(_Bin, _Handler, _Acc, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 %% like in strings, there's some pseudo states in here that will never
 %%  show up in errors or incompletes. some show up in value, some show
 %%  up in integer, decimal or exp
@@ -314,7 +317,6 @@
 negative(_Bin, _Handler, _Acc, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 zero(<<?decimalpoint, Rest/binary>>, Handler, Acc, Stack, Config) ->
     decimal(Rest, Handler, acc_seq(Acc, ?decimalpoint), Stack, Config);
 zero(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= $e; S =:= $E ->
@@ -322,7 +324,6 @@
 zero(Bin, Handler, Acc, Stack, Config) ->
     finish_number(Bin, Handler, {zero, Acc}, Stack, Config).
 
-
 integer(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) ->
     integer(Rest, Handler, acc_seq(Acc, S), Stack, Config);
 integer(<<?decimalpoint, Rest/binary>>, Handler, Acc, Stack, Config) ->
@@ -332,13 +333,11 @@
 integer(Bin, Handler, Acc, Stack, Config) ->
     finish_number(Bin, Handler, {integer, Acc}, Stack, Config).
 
-
 initialdecimal(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) ->
     decimal(Rest, Handler, acc_seq(Acc, S), Stack, Config);
 initialdecimal(_Bin, _Handler, _Acc, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 decimal(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) ->
     decimal(Rest, Handler, acc_seq(Acc, S), Stack, Config);
 decimal(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= $e; S =:= $E ->
@@ -346,7 +345,6 @@
 decimal(Bin, Handler, Acc, Stack, Config) ->
     finish_number(Bin, Handler, {decimal, Acc}, Stack, Config).
 
-
 e(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) ->
     exp(Rest, Handler, acc_seq(Acc, S), Stack, Config);
 e(<<Sign, Rest/binary>>, Handler, Acc, Stack, Config) when Sign =:= ?positive; Sign =:= ?negative ->
@@ -354,66 +352,59 @@
 e(_Bin, _Handler, _Acc, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 ex(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) ->
     exp(Rest, Handler, acc_seq(Acc, S), Stack, Config);
 ex(_Bin, _Handler, _Acc, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 exp(<<S, Rest/binary>>, Handler, Acc, Stack, Config) when S =:= ?zero; ?is_nonzero(S) ->
     exp(Rest, Handler, acc_seq(Acc, S), Stack, Config);
 exp(Bin, Handler, Acc, Stack, Config) ->
     finish_number(Bin, Handler, {exp, Acc}, Stack, Config).
 
-
 finish_number(Rest, Handler, Acc, [], Config) ->
     maybe_done(Rest, handle_event(format_number(Acc), Handler, Config), [], Config);
 finish_number(Rest, Handler, Acc, Stack, Config) ->
     maybe_done(Rest, handle_event(format_number(Acc), Handler, Config), Stack, Config).
 
-
 format_number({zero, Acc}) -> {integer, list_to_integer(lists:reverse(Acc))};
 format_number({integer, Acc}) -> {integer, list_to_integer(lists:reverse(Acc))};
 format_number({decimal, Acc}) -> {float, list_to_float(lists:reverse(Acc))};
 format_number({exp, Acc}) -> {float, list_to_float(lists:reverse(Acc))}.
 
-
 true(<<$r, $u, $e, Rest/binary>>, Handler, Stack, Config) ->
     maybe_done(Rest, handle_event({literal, true}, Handler, Config), Stack, Config);
 true(_Bin, _Handler, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 false(<<$a, $l, $s, $e, Rest/binary>>, Handler, Stack, Config) ->
     maybe_done(Rest, handle_event({literal, false}, Handler, Config), Stack, Config);
 false(_Bin, _Handler, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 null(<<$u, $l, $l, Rest/binary>>, Handler, Stack, Config) ->
     maybe_done(Rest, handle_event({literal, null}, Handler, Config), Stack, Config);
 null(_Bin, _Handler, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 maybe_done(<<Rest/binary>>, Handler, [], Config) ->
     done(Rest, handle_event(end_json, Handler, Config), [], Config);
-maybe_done(<<?end_object, Rest/binary>>, Handler, [object|Stack], Config) ->
+maybe_done(<<?end_object, Rest/binary>>, Handler, [object | Stack], Config) ->
     maybe_done(Rest, handle_event(end_object, Handler, Config), Stack, Config);
-maybe_done(<<?end_array, Rest/binary>>, Handler, [array|Stack], Config) ->
+maybe_done(<<?end_array, Rest/binary>>, Handler, [array | Stack], Config) ->
     maybe_done(Rest, handle_event(end_array, Handler, Config), Stack, Config);
-maybe_done(<<?comma, Rest/binary>>, Handler, [object|Stack], Config) ->
-    key(Rest, Handler, [key|Stack], Config);
-maybe_done(<<?comma, Rest/binary>>, Handler, [array|_] = Stack, Config) ->
+maybe_done(<<?comma, Rest/binary>>, Handler, [object | Stack], Config) ->
+    key(Rest, Handler, [key | Stack], Config);
+maybe_done(<<?comma, Rest/binary>>, Handler, [array | _] = Stack, Config) ->
     value(Rest, Handler, Stack, Config);
 maybe_done(<<S, Rest/binary>>, Handler, Stack, Config) when ?is_whitespace(S) ->
     maybe_done(Rest, Handler, Stack, Config);
 maybe_done(_Bin, _Handler, _Stack, _Config) ->
     erlang:error(badarg).
 
-
 done(<<S, Rest/binary>>, Handler, [], Config) when ?is_whitespace(S) ->
     done(Rest, Handler, [], Config);
-done(<<>>, {_Handler, State}, [], _Config) -> State;
-done(_Bin, _Handler, _Stack, _Config) -> erlang:error(badarg).
+done(<<>>, {_Handler, State}, [], _Config) ->
+    State;
+done(_Bin, _Handler, _Stack, _Config) ->
+    erlang:error(badarg).
diff --git a/lib/erl/src/thrift_json_protocol.erl b/lib/erl/src/thrift_json_protocol.erl
index c5f3da8..b0a3918 100644
--- a/lib/erl/src/thrift_json_protocol.erl
+++ b/lib/erl/src/thrift_json_protocol.erl
@@ -27,35 +27,38 @@
 -include("thrift_constants.hrl").
 -include("thrift_protocol.hrl").
 
--export([new/1, new/2,
-         read/2,
-         write/2,
-         flush_transport/1,
-         close_transport/1,
-         new_protocol_factory/2
-        ]).
+-export([
+    new/1, new/2,
+    read/2,
+    write/2,
+    flush_transport/1,
+    close_transport/1,
+    new_protocol_factory/2
+]).
 
 -record(json_context, {
     % the type of json_context: array or object
-    type,
+    type :: undefined | array | object,
     % fields read or written
-    fields_processed = 0
+    fields_processed = 0 :: non_neg_integer()
 }).
 
+-type json_context() :: #json_context{}.
+-type jsx_type() :: atom() | {atom(), atom() | string()}.
+-type jsx() :: {event, jsx_type(), [jsx_type()]}.
+
 -record(json_protocol, {
-    transport,
-    context_stack = [],
-    jsx
+    transport :: term(),
+    context_stack = [] :: [json_context()],
+    jsx :: undefined | jsx()
 }).
--type state() :: #json_protocol{}.
--include("thrift_protocol_behaviour.hrl").
 
 -define(VERSION_1, 1).
 -define(JSON_DOUBLE_PRECISION, 16).
 
 typeid_to_json(?tType_BOOL) -> "tf";
-typeid_to_json(?tType_BYTE) -> "i8";
 typeid_to_json(?tType_DOUBLE) -> "dbl";
+% NOTE: ?tType_BYTE also match here
 typeid_to_json(?tType_I8) -> "i8";
 typeid_to_json(?tType_I16) -> "i16";
 typeid_to_json(?tType_I32) -> "i32";
@@ -84,28 +87,33 @@
 end_context(object) -> "}";
 end_context(array) -> "]".
 
-
 new(Transport) ->
     new(Transport, _Options = []).
 
 new(Transport, _Options) ->
-    State  = #json_protocol{transport = Transport},
+    State = #json_protocol{transport = Transport},
     thrift_protocol:new(?MODULE, State).
 
 flush_transport(This = #json_protocol{transport = Transport}) ->
     {NewTransport, Result} = thrift_transport:flush(Transport),
-    {This#json_protocol{
+    {
+        This#json_protocol{
             transport = NewTransport,
             context_stack = []
-        }, Result}.
+        },
+        Result
+    }.
 
 close_transport(This = #json_protocol{transport = Transport}) ->
     {NewTransport, Result} = thrift_transport:close(Transport),
-    {This#json_protocol{
+    {
+        This#json_protocol{
             transport = NewTransport,
             context_stack = [],
             jsx = undefined
-        }, Result}.
+        },
+        Result
+    }.
 
 %%%
 %%% instance methods
@@ -113,63 +121,82 @@
 % places a new context on the stack:
 write(#json_protocol{context_stack = Stack} = State0, {enter_context, Type}) ->
     {State1, ok} = write_values(State0, [{context_pre_item, false}]),
-    State2 = State1#json_protocol{context_stack = [
-        #json_context{type=Type}|Stack]},
-    write_values(State2,  [list_to_binary(start_context(Type))]);
-
-% removes the topmost context from stack    
-write(#json_protocol{context_stack = [CurrCtxt|Stack]} = State0, {exit_context}) ->
+    State2 = State1#json_protocol{
+        context_stack = [
+            #json_context{type = Type} | Stack
+        ]
+    },
+    write_values(State2, [list_to_binary(start_context(Type))]);
+% removes the topmost context from stack
+write(#json_protocol{context_stack = [CurrCtxt | Stack]} = State0, {exit_context}) ->
     Type = CurrCtxt#json_context.type,
     State1 = State0#json_protocol{context_stack = Stack},
     write_values(State1, [
-            list_to_binary(end_context(Type)),
-            {context_post_item, false}
-        ]);
-
-% writes necessary prelude to field or container depending on current context   
-write(#json_protocol{context_stack = []} = This0,
-    {context_pre_item, _}) -> {This0, ok};
-write(#json_protocol{context_stack = [Context|_CtxtTail]} = This0,
-    {context_pre_item, MayNeedQuotes}) ->
+        list_to_binary(end_context(Type)),
+        {context_post_item, false}
+    ]);
+% writes necessary prelude to field or container depending on current context
+write(
+    #json_protocol{context_stack = []} = This0,
+    {context_pre_item, _}
+) ->
+    {This0, ok};
+write(
+    #json_protocol{context_stack = [Context | _CtxtTail]} = This0,
+    {context_pre_item, MayNeedQuotes}
+) ->
     FieldNo = Context#json_context.fields_processed,
     CtxtType = Context#json_context.type,
     Rem = FieldNo rem 2,
     case {CtxtType, FieldNo, Rem, MayNeedQuotes} of
-        {array, N, _, _} when N > 0 ->  % array element (not first)
+        % array element (not first)
+        {array, N, _, _} when N > 0 ->
             write(This0, <<",">>);
-        {object, 0, _, true} -> % non-string object key (first)
+        % non-string object key (first)
+        {object, 0, _, true} ->
             write(This0, <<"\"">>);
-        {object, N, 0, true} when N > 0 -> % non-string object key (not first)
+        % non-string object key (not first)
+        {object, N, 0, true} when N > 0 ->
             write(This0, <<",\"">>);
-        {object, N, 0, false} when N > 0-> % string object key (not first)
+        % string object key (not first)
+        {object, N, 0, false} when N > 0 ->
             write(This0, <<",">>);
-        _ -> % no pre-field necessary
+        % no pre-field necessary
+        _ ->
             {This0, ok}
     end;
-
-% writes necessary postlude to field or container depending on current context   
-write(#json_protocol{context_stack = []} = This0,
-    {context_post_item, _}) -> {This0, ok};
-write(#json_protocol{context_stack = [Context|CtxtTail]} = This0,
-    {context_post_item, MayNeedQuotes}) ->
+% writes necessary postlude to field or container depending on current context
+write(
+    #json_protocol{context_stack = []} = This0,
+    {context_post_item, _}
+) ->
+    {This0, ok};
+write(
+    #json_protocol{context_stack = [Context | CtxtTail]} = This0,
+    {context_post_item, MayNeedQuotes}
+) ->
     FieldNo = Context#json_context.fields_processed,
     CtxtType = Context#json_context.type,
     Rem = FieldNo rem 2,
-    {This1, ok} = case {CtxtType, Rem, MayNeedQuotes} of
-        {object, 0, true} -> % non-string object key 
-            write(This0, <<"\":">>);
-        {object, 0, false} -> % string object key 
-            write(This0, <<":">>);
-        _ -> % no pre-field necessary
-            {This0, ok}
-    end,
+    {This1, ok} =
+        case {CtxtType, Rem, MayNeedQuotes} of
+            % non-string object key
+            {object, 0, true} ->
+                write(This0, <<"\":">>);
+            % string object key
+            {object, 0, false} ->
+                write(This0, <<":">>);
+            % no pre-field necessary
+            _ ->
+                {This0, ok}
+        end,
     NewContext = Context#json_context{fields_processed = FieldNo + 1},
-    {This1#json_protocol{context_stack=[NewContext|CtxtTail]}, ok};
-
+    {This1#json_protocol{context_stack = [NewContext | CtxtTail]}, ok};
 write(This0, #protocol_message_begin{
     name = Name,
     type = Type,
-    seqid = Seqid}) ->
+    seqid = Seqid
+}) ->
     write_values(This0, [
         {enter_context, array},
         {i32, ?VERSION_1},
@@ -177,15 +204,14 @@
         {i32, Type},
         {i32, Seqid}
     ]);
-
-write(This, message_end) ->  
+write(This, message_end) ->
     write_values(This, [{exit_context}]);
-
 % Example field expression: "1":{"dbl":3.14}
 write(This0, #protocol_field_begin{
-       name = _Name,
-       type = Type,
-       id = Id}) ->
+    name = _Name,
+    type = Type,
+    id = Id
+}) ->
     write_values(This0, [
         % entering 'outer' object
         {i16, Id},
@@ -193,18 +219,16 @@
         {enter_context, object},
         {string, typeid_to_json(Type)}
     ]);
-
-write(This, field_stop) -> 
+write(This, field_stop) ->
     {This, ok};
-
-write(This, field_end) -> 
-    write_values(This,[{exit_context}]);
-
+write(This, field_end) ->
+    write_values(This, [{exit_context}]);
 % Example message with map: [1,"testMap",1,0,{"1":{"map":["i32","i32",3,{"7":77,"8":88,"9":99}]}}]
 write(This0, #protocol_map_begin{
-       ktype = Ktype,
-       vtype = Vtype,
-       size = Size}) ->
+    ktype = Ktype,
+    vtype = Vtype,
+    size = Size
+}) ->
     write_values(This0, [
         {enter_context, array},
         {string, typeid_to_json(Ktype)},
@@ -212,86 +236,79 @@
         {i32, Size},
         {enter_context, object}
     ]);
-
-write(This, map_end) -> 
-    write_values(This,[
+write(This, map_end) ->
+    write_values(This, [
         {exit_context},
         {exit_context}
     ]);
-
 write(This0, #protocol_list_begin{
-        etype = Etype,
-        size = Size}) ->
+    etype = Etype,
+    size = Size
+}) ->
     write_values(This0, [
         {enter_context, array},
         {string, typeid_to_json(Etype)},
         {i32, Size}
     ]);
-
-write(This, list_end) -> 
-    write_values(This,[
+write(This, list_end) ->
+    write_values(This, [
         {exit_context}
     ]);
-
 % example message with set: [1,"testSet",1,0,{"1":{"set":["i32",3,1,2,3]}}]
 write(This0, #protocol_set_begin{
-        etype = Etype,
-        size = Size}) ->
+    etype = Etype,
+    size = Size
+}) ->
     write_values(This0, [
         {enter_context, array},
         {string, typeid_to_json(Etype)},
         {i32, Size}
     ]);
-
-write(This, set_end) -> 
-    write_values(This,[
+write(This, set_end) ->
+    write_values(This, [
         {exit_context}
     ]);
 % example message with struct: [1,"testStruct",1,0,{"1":{"rec":{"1":{"str":"worked"},"4":{"i8":1},"9":{"i32":1073741824},"11":{"i64":1152921504606847000}}}}]
-write(This, #protocol_struct_begin{}) -> 
+write(This, #protocol_struct_begin{}) ->
     write_values(This, [
         {enter_context, object}
     ]);
-
-write(This, struct_end) -> 
-    write_values(This,[
+write(This, struct_end) ->
+    write_values(This, [
         {exit_context}
     ]);
-
-write(This, {bool, true})  -> write_values(This, [
+write(This, {bool, true}) ->
+    write_values(This, [
         {context_pre_item, true},
         <<"true">>,
         {context_post_item, true}
     ]);
-
-write(This, {bool, false}) -> write_values(This, [
+write(This, {bool, false}) ->
+    write_values(This, [
         {context_pre_item, true},
         <<"false">>,
         {context_post_item, true}
     ]);
-
-write(This, {byte, Byte}) -> write_values(This, [
+write(This, {byte, Byte}) ->
+    write_values(This, [
         {context_pre_item, true},
         list_to_binary(integer_to_list(Byte)),
         {context_post_item, true}
     ]);
-
 write(This, {i16, I16}) ->
     write(This, {byte, I16});
-
 write(This, {i32, I32}) ->
     write(This, {byte, I32});
-
 write(This, {i64, I64}) ->
     write(This, {byte, I64});
-
-write(This, {double, Double}) -> write_values(This, [
+write(This, {double, Double}) ->
+    write_values(This, [
         {context_pre_item, true},
-        list_to_binary(io_lib:format("~.*f", [?JSON_DOUBLE_PRECISION,Double])),
+        list_to_binary(io_lib:format("~.*f", [?JSON_DOUBLE_PRECISION, Double])),
         {context_post_item, true}
     ]);
-
-write(This0, {string, Str}) -> write_values(This0, [
+write(This0, {string, Str}) ->
+    write_values(This0, [
         {context_pre_item, false},
         case is_binary(Str) of
             true -> Str;
@@ -299,7 +316,6 @@
         end,
         {context_post_item, false}
     ]);
-
 %% TODO: binary fields should be base64 encoded?
 
 %% Data :: iolist()
@@ -315,10 +331,11 @@
             ThisOut
         end,
         This0,
-        ValueList),
+        ValueList
+    ),
     {FinalState, ok}.
 
-%% I wish the erlang version of the transport interface included a 
+%% I wish the erlang version of the transport interface included a
 %% read_all function (like eg. the java implementation). Since it doesn't,
 %% here's my version (even though it probably shouldn't be in this file).
 %%
@@ -327,7 +344,7 @@
 read_all(#json_protocol{transport = Transport0} = State) ->
     {Transport1, Bin} = read_all_1(Transport0, []),
     P = thrift_json_parser:parser(),
-    [First|Rest] = P(Bin),
+    [First | Rest] = P(Bin),
     State#json_protocol{
         transport = Transport1,
         jsx = {event, First, Rest}
@@ -336,11 +353,14 @@
 read_all_1(Transport0, IoList) ->
     {Transport1, Result} = thrift_transport:read(Transport0, 1),
     case Result of
-        {ok, <<>>} -> % nothing read: assume we're done
+        % nothing read: assume we're done
+        {ok, <<>>} ->
             {Transport1, iolist_to_binary(lists:reverse(IoList))};
-        {ok, Data} -> % character successfully read; read more
-            read_all_1(Transport1, [Data|IoList]);
-        {error, 'EOF'} -> % we're done
+        % character successfully read; read more
+        {ok, Data} ->
+            read_all_1(Transport1, [Data | IoList]);
+        % we're done
+        {error, 'EOF'} ->
             {Transport1, iolist_to_binary(lists:reverse(IoList))}
     end.
 
@@ -348,17 +368,16 @@
 % type as input. Comparing the read event from the one is was passed, it
 % returns an error if something other than the expected value is encountered.
 % Expect also maintains the context stack in #json_protocol.
-expect(#json_protocol{jsx={event, {Type, Data}=Ev, [Next|Rest]}}=State, ExpectedType) ->
-    NextState = State#json_protocol{jsx={event, Next, Rest}},
+expect(#json_protocol{jsx = {event, {Type, Data} = Ev, [Next | Rest]}} = State, ExpectedType) ->
+    NextState = State#json_protocol{jsx = {event, Next, Rest}},
     case Type == ExpectedType of
-        true -> 
+        true ->
             {NextState, {ok, convert_data(Type, Data)}};
         false ->
             {NextState, {error, {unexpected_json_event, Ev}}}
     end;
-
-expect(#json_protocol{jsx={event, Event, Next}}=State, ExpectedEvent) ->
-     expect(State#json_protocol{jsx={event, {Event, none}, Next}}, ExpectedEvent).
+expect(#json_protocol{jsx = {event, Event, Next}} = State, ExpectedEvent) ->
+    expect(State#json_protocol{jsx = {event, {Event, none}, Next}}, ExpectedEvent).
 
 convert_data(integer, I) -> list_to_integer(I);
 convert_data(float, F) -> list_to_float(F);
@@ -369,9 +388,9 @@
 
 expect_many_1(State, [], ResultList, Status) ->
     {State, {Status, lists:reverse(ResultList)}};
-expect_many_1(State, [Expected|ExpTail], ResultList, _PrevStatus) ->
+expect_many_1(State, [Expected | ExpTail], ResultList, _PrevStatus) ->
     {State1, {Status, Data}} = expect(State, Expected),
-    NewResultList = [Data|ResultList],
+    NewResultList = [Data | ResultList],
     case Status of
         % in case of error, end prematurely
         error -> expect_many_1(State1, [], NewResultList, Status);
@@ -381,178 +400,202 @@
 % wrapper around expect to make life easier for container opening/closing functions
 expect_nodata(This, ExpectedList) ->
     case expect_many(This, ExpectedList) of
-        {State, {ok, _}} -> 
+        {State, {ok, _}} ->
             {State, ok};
-        Error -> 
+        Error ->
             Error
     end.
 
-read_field(#json_protocol{jsx={event, Field, [Next|Rest]}} = State) ->
-    NewState = State#json_protocol{jsx={event, Next, Rest}},
+read_field(#json_protocol{jsx = {event, Field, [Next | Rest]}} = State) ->
+    NewState = State#json_protocol{jsx = {event, Next, Rest}},
     {NewState, Field}.
 
 read(This0, message_begin) ->
     % call read_all to get the contents of the transport buffer into JSX.
     This1 = read_all(This0),
-    case expect_many(This1, 
-            [start_array, integer, string, integer, integer]) of
+    case
+        expect_many(
+            This1,
+            [start_array, integer, string, integer, integer]
+        )
+    of
         {This2, {ok, [_, Version, Name, Type, SeqId]}} ->
             case Version =:= ?VERSION_1 of
                 true ->
-                    {This2, #protocol_message_begin{name  = Name,
-                                                    type  = Type,
-                                                    seqid = SeqId}};
+                    {This2, #protocol_message_begin{
+                        name = Name,
+                        type = Type,
+                        seqid = SeqId
+                    }};
                 false ->
                     {This2, {error, no_json_protocol_version}}
             end;
-        Other -> Other
+        Other ->
+            Other
     end;
-
-read(This, message_end) -> 
+read(This, message_end) ->
     expect_nodata(This, [end_array]);
-
-read(This, struct_begin) -> 
+read(This, struct_begin) ->
     expect_nodata(This, [start_object]);
-
-read(This, struct_end) -> 
+read(This, struct_end) ->
     expect_nodata(This, [end_object]);
-
 read(This0, field_begin) ->
-    {This1, Read} = expect_many(This0, 
-            [%field id
-             key, 
-             % {} surrounding field
-             start_object, 
-             % type of field
-             key]),
+    {This1, Read} = expect_many(
+        This0,
+        %field id
+        [
+            key,
+            % {} surrounding field
+            start_object,
+            % type of field
+            key
+        ]
+    ),
     case Read of
         {ok, [FieldIdStr, _, FieldType]} ->
             {This1, #protocol_field_begin{
-                type = json_to_typeid(FieldType), 
-                id = list_to_integer(FieldIdStr)}}; % TODO: do we need to wrap this in a try/catch?
-        {error,[{unexpected_json_event, {end_object,none}}]} ->
+                type = json_to_typeid(FieldType),
+                % TODO: do we need to wrap this in a try/catch?
+                id = list_to_integer(FieldIdStr)
+            }};
+        {error, [{unexpected_json_event, {end_object, none}}]} ->
             {This1, #protocol_field_begin{type = ?tType_STOP}};
-        Other -> 
+        Other ->
             io:format("**** OTHER branch selected ****"),
             {This1, Other}
     end;
-
-read(This, field_end) -> 
+read(This, field_end) ->
     expect_nodata(This, [end_object]);
-
 % Example message with map: [1,"testMap",1,0,{"1":{"map":["i32","i32",3,{"7":77,"8":88,"9":99}]}}]
 read(This0, map_begin) ->
-    case expect_many(This0, 
-            [start_array,
-             % key type
-             string, 
-             % value type
-             string, 
-             % size
-             integer,
-             % the following object contains the map
-             start_object]) of
+    case
+        expect_many(
+            This0,
+            [
+                start_array,
+                % key type
+                string,
+                % value type
+                string,
+                % size
+                integer,
+                % the following object contains the map
+                start_object
+            ]
+        )
+    of
         {This1, {ok, [_, Ktype, Vtype, Size, _]}} ->
-            {This1, #protocol_map_begin{ktype = Ktype,
-                                vtype = Vtype,
-                                size = Size}};
-        Other -> Other
+            {This1, #protocol_map_begin{
+                ktype = Ktype,
+                vtype = Vtype,
+                size = Size
+            }};
+        Other ->
+            Other
     end;
-
-read(This, map_end) -> 
+read(This, map_end) ->
     expect_nodata(This, [end_object, end_array]);
-
 read(This0, list_begin) ->
-    case expect_many(This0, 
-            [start_array,
-             % element type
-             string, 
-             % size
-             integer]) of
+    case
+        expect_many(
+            This0,
+            [
+                start_array,
+                % element type
+                string,
+                % size
+                integer
+            ]
+        )
+    of
         {This1, {ok, [_, Etype, Size]}} ->
             {This1, #protocol_list_begin{
                 etype = Etype,
-                size = Size}};
-        Other -> Other
+                size = Size
+            }};
+        Other ->
+            Other
     end;
-
-read(This, list_end) -> 
+read(This, list_end) ->
     expect_nodata(This, [end_array]);
-
 % example message with set: [1,"testSet",1,0,{"1":{"set":["i32",3,1,2,3]}}]
 read(This0, set_begin) ->
-    case expect_many(This0, 
-            [start_array,
-             % element type
-             string, 
-             % size
-             integer]) of
+    case
+        expect_many(
+            This0,
+            [
+                start_array,
+                % element type
+                string,
+                % size
+                integer
+            ]
+        )
+    of
         {This1, {ok, [_, Etype, Size]}} ->
             {This1, #protocol_set_begin{
                 etype = Etype,
-                size = Size}};
-        Other -> Other
+                size = Size
+            }};
+        Other ->
+            Other
     end;
-
-read(This, set_end) -> 
+read(This, set_end) ->
     expect_nodata(This, [end_array]);
-
 read(This0, field_stop) ->
     {This0, ok};
 %%
 
 read(This0, bool) ->
     {This1, Field} = read_field(This0),
-    Value = case Field of
-        {literal, I} -> 
-            {ok, I}; 
-        _Other ->
-            {error, unexpected_event_for_boolean}
-    end,
+    Value =
+        case Field of
+            {literal, I} ->
+                {ok, I};
+            _Other ->
+                {error, unexpected_event_for_boolean}
+        end,
     {This1, Value};
-
 read(This0, byte) ->
     {This1, Field} = read_field(This0),
-    Value = case Field of
-        {key, K} ->
-            {ok, list_to_integer(K)};
-        {integer, I} -> 
-            {ok, list_to_integer(I)}; 
-        _Other ->
-            {error, unexpected_event_for_integer}
-    end,
+    Value =
+        case Field of
+            {key, K} ->
+                {ok, list_to_integer(K)};
+            {integer, I} ->
+                {ok, list_to_integer(I)};
+            _Other ->
+                {error, unexpected_event_for_integer}
+        end,
     {This1, Value};
-
 read(This0, i16) ->
     read(This0, byte);
-
 read(This0, i32) ->
     read(This0, byte);
-
 read(This0, i64) ->
     read(This0, byte);
-
 read(This0, double) ->
     {This1, Field} = read_field(This0),
-    Value = case Field of
-        {float, I} -> 
-            {ok, list_to_float(I)}; 
-        _Other ->
-            {error, unexpected_event_for_double}
-    end,
+    Value =
+        case Field of
+            {float, I} ->
+                {ok, list_to_float(I)};
+            _Other ->
+                {error, unexpected_event_for_double}
+        end,
     {This1, Value};
-
 % returns a binary directly, call binary_to_list if necessary
 read(This0, string) ->
     {This1, Field} = read_field(This0),
-    Value = case Field of
-        {string, I} -> 
-            {ok, I}; 
-        {key, J} -> 
-            {ok, J}; 
-        _Other ->
-            {error, unexpected_event_for_string}
-    end,
+    Value =
+        case Field of
+            {string, I} ->
+                {ok, I};
+            {key, J} ->
+                {ok, J};
+            _Other ->
+                {error, unexpected_event_for_string}
+        end,
     {This1, Value}.
 
 %%%% FACTORY GENERATION %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -561,7 +604,7 @@
 new_protocol_factory(TransportFactory, _Options) ->
     % Only strice read/write are implemented
     F = fun() ->
-                {ok, Transport} = TransportFactory(),
-                thrift_json_protocol:new(Transport, [])
-        end,
+        {ok, Transport} = TransportFactory(),
+        thrift_json_protocol:new(Transport, [])
+    end,
     {ok, F}.
diff --git a/lib/erl/src/thrift_membuffer_transport.erl b/lib/erl/src/thrift_membuffer_transport.erl
index be9acb2..df23b03 100644
--- a/lib/erl/src/thrift_membuffer_transport.erl
+++ b/lib/erl/src/thrift_membuffer_transport.erl
@@ -22,62 +22,55 @@
 -behaviour(thrift_transport).
 
 %% constructors
--export([new/0, new/1]).
+-export([new/0, new/1, new/2]).
 %% protocol callbacks
 -export([read/2, read_exact/2, write/2, flush/1, close/1]).
 
-
 -record(t_membuffer, {
-  buffer = []
+    buffer = [] :: iodata()
 }).
 
--type state() :: #t_membuffer{}.
-
-
--spec new() -> thrift_transport:t_transport().
+-spec new() -> {ok, thrift_transport:t_transport()}.
 
 new() -> new([]).
 
--spec new(Buf::iodata()) -> thrift_transport:t_transport().
+-spec new(Buf :: iodata()) -> {ok, thrift_transport:t_transport()}.
 
-new(Buf) when is_list(Buf) ->
-  State = #t_membuffer{buffer = Buf},
-  thrift_transport:new(?MODULE, State);
-new(Buf) when is_binary(Buf) ->
-  State = #t_membuffer{buffer = [Buf]},
-  thrift_transport:new(?MODULE, State).
+new(Buf) ->
+    new(Buf, []).
 
+new(Buf, _Opts) when is_list(Buf) ->
+    State = #t_membuffer{buffer = Buf},
+    thrift_transport:new(?MODULE, State);
+new(Buf, _Opts) when is_binary(Buf) ->
+    State = #t_membuffer{buffer = [Buf]},
+    thrift_transport:new(?MODULE, State).
 
--include("thrift_transport_behaviour.hrl").
+read(State = #t_membuffer{buffer = Buf}, Len) when
+    is_integer(Len), Len >= 0
+->
+    Binary = iolist_to_binary(Buf),
+    Give = min(iolist_size(Binary), Len),
+    {Result, Remaining} = split_binary(Binary, Give),
+    {State#t_membuffer{buffer = Remaining}, {ok, Result}}.
 
+read_exact(State = #t_membuffer{buffer = Buf}, Len) when
+    is_integer(Len), Len >= 0
+->
+    Binary = iolist_to_binary(Buf),
+    case iolist_size(Binary) of
+        X when X >= Len ->
+            {Result, Remaining} = split_binary(Binary, Len),
+            {State#t_membuffer{buffer = Remaining}, {ok, Result}};
+        _ ->
+            {State, {error, eof}}
+    end.
 
-read(State = #t_membuffer{buffer = Buf}, Len)
-when is_integer(Len), Len >= 0 ->
-  Binary = iolist_to_binary(Buf),
-  Give = min(iolist_size(Binary), Len),
-  {Result, Remaining} = split_binary(Binary, Give),
-  {State#t_membuffer{buffer = Remaining}, {ok, Result}}.
-
-
-read_exact(State = #t_membuffer{buffer = Buf}, Len)
-when is_integer(Len), Len >= 0 ->
-  Binary = iolist_to_binary(Buf),
-  case iolist_size(Binary) of
-    X when X >= Len ->
-      {Result, Remaining} = split_binary(Binary, Len),
-      {State#t_membuffer{buffer = Remaining}, {ok, Result}};
-    _ ->
-      {State, {error, eof}}
-  end.
-
-
-write(State = #t_membuffer{buffer = Buf}, Data)
-when is_list(Data); is_binary(Data) ->
-  {State#t_membuffer{buffer = [Buf, Data]}, ok}.
-
+write(State = #t_membuffer{buffer = Buf}, Data) when
+    is_list(Data); is_binary(Data)
+->
+    {State#t_membuffer{buffer = [Buf, Data]}, ok}.
 
 flush(State) -> {State, ok}.
 
-
 close(State) -> {State, ok}.
-
diff --git a/lib/erl/src/thrift_memory_buffer.erl b/lib/erl/src/thrift_memory_buffer.erl
index 6a59ea5..3007f73 100644
--- a/lib/erl/src/thrift_memory_buffer.erl
+++ b/lib/erl/src/thrift_memory_buffer.erl
@@ -28,7 +28,6 @@
 %% legacy api
 -export([new_transport_factory/0]).
 
-
 %% wrapper around thrift_membuffer_transport for legacy reasons
 
 new() -> thrift_membuffer_transport:new().
@@ -44,4 +43,3 @@
 flush(State) -> thrift_membuffer_transport:flush(State).
 
 close(State) -> thrift_membuffer_transport:close(State).
-
diff --git a/lib/erl/src/thrift_multiplexed_map_wrapper.erl b/lib/erl/src/thrift_multiplexed_map_wrapper.erl
index 34c5e95..706aaf7 100644
--- a/lib/erl/src/thrift_multiplexed_map_wrapper.erl
+++ b/lib/erl/src/thrift_multiplexed_map_wrapper.erl
@@ -20,15 +20,15 @@
 -module(thrift_multiplexed_map_wrapper).
 
 -export([
-          new/0
-         ,store/3
-         ,find/2
-         ,fetch/2
-        ]).
+    new/0,
+    store/3,
+    find/2,
+    fetch/2
+]).
 
--type service_handler()     :: nonempty_string().
--type module_()             :: atom().
--type service_handler_map() :: [{ServiceHandler::service_handler(), Module::module_()}].
+-type service_handler() :: nonempty_string().
+-type service_handler_map() :: orddict:orddict(service_handler(), [module()]).
+-export_type([service_handler_map/0]).
 
 -spec new() -> service_handler_map().
 new() ->
@@ -36,22 +36,22 @@
 
 -spec store(ServiceHandler, Module, Map) -> NewMap when
     ServiceHandler :: service_handler(),
-    Module         :: module_(),
-    Map            :: service_handler_map(),
-    NewMap         :: service_handler_map().
+    Module :: module(),
+    Map :: service_handler_map(),
+    NewMap :: service_handler_map().
 store(ServiceHandler, Module, Map) ->
     orddict:store(ServiceHandler, Module, Map).
 
 -spec find(ServiceHandler, Map) -> {ok, Module} | error when
     ServiceHandler :: service_handler(),
-    Module         :: module_(),
-    Map            :: service_handler_map().
+    Module :: module(),
+    Map :: service_handler_map().
 find(ServiceHandler, Map) ->
     orddict:find(ServiceHandler, Map).
 
 -spec fetch(ServiceHandler, Map) -> Module when
     ServiceHandler :: service_handler(),
-    Module         :: module_(),
-    Map            :: service_handler_map().
+    Module :: module(),
+    Map :: service_handler_map().
 fetch(ServiceHandler, Map) ->
     orddict:fetch(ServiceHandler, Map).
diff --git a/lib/erl/src/thrift_multiplexed_protocol.erl b/lib/erl/src/thrift_multiplexed_protocol.erl
index 5f7b70c..ddc9475 100644
--- a/lib/erl/src/thrift_multiplexed_protocol.erl
+++ b/lib/erl/src/thrift_multiplexed_protocol.erl
@@ -24,60 +24,91 @@
 -include("thrift_constants.hrl").
 -include("thrift_protocol.hrl").
 
--include("thrift_protocol_behaviour.hrl").
+-export([
+    new/2,
+    read/2,
+    write/2,
+    flush_transport/1,
+    close_transport/1
+]).
 
--export([new/2,
-         read/2,
-         write/2,
-         flush_transport/1,
-         close_transport/1
-        ]).
-
--record(protocol, {module, data}).
+-record(protocol, {
+    module :: module(),
+    data :: term()
+}).
 -type protocol() :: #protocol{}.
 
--record (multiplexed_protocol, {protocol_module_to_decorate::atom(),
-								protocol_data_to_decorate::term(),
-								service_name::nonempty_string()}).
+-record(multiplexed_protocol, {
+    protocol_module_to_decorate :: atom(),
+    protocol_data_to_decorate :: term(),
+    service_name :: nonempty_string()
+}).
 
--type state() :: #multiplexed_protocol{}.
-
--spec new(ProtocolToDecorate::protocol(), ServiceName::nonempty_string()) -> {ok, Protocol::protocol()}.
-new(ProtocolToDecorate, ServiceName) when is_record(ProtocolToDecorate, protocol),
-                                          is_list(ServiceName) ->
-    State = #multiplexed_protocol{protocol_module_to_decorate = ProtocolToDecorate#protocol.module,
-                                    protocol_data_to_decorate = ProtocolToDecorate#protocol.data,
-                                                 service_name = ServiceName},
+-spec new(ProtocolToDecorate :: protocol(), ServiceName :: nonempty_string()) ->
+    {ok, Protocol :: protocol()}.
+new(ProtocolToDecorate, ServiceName) when
+    is_record(ProtocolToDecorate, protocol),
+    is_list(ServiceName)
+->
+    State = #multiplexed_protocol{
+        protocol_module_to_decorate = ProtocolToDecorate#protocol.module,
+        protocol_data_to_decorate = ProtocolToDecorate#protocol.data,
+        service_name = ServiceName
+    },
     thrift_protocol:new(?MODULE, State).
 
-flush_transport(State = #multiplexed_protocol{protocol_module_to_decorate = ProtocolModuleToDecorate,
-                                                protocol_data_to_decorate = State0}) ->
+flush_transport(
+    State = #multiplexed_protocol{
+        protocol_module_to_decorate = ProtocolModuleToDecorate,
+        protocol_data_to_decorate = State0
+    }
+) ->
     {State1, ok} = ProtocolModuleToDecorate:flush_transport(State0),
     {State#multiplexed_protocol{protocol_data_to_decorate = State1}, ok}.
 
-close_transport(State = #multiplexed_protocol{protocol_module_to_decorate = ProtocolModuleToDecorate,
-                                                protocol_data_to_decorate = State0}) ->
+close_transport(
+    State = #multiplexed_protocol{
+        protocol_module_to_decorate = ProtocolModuleToDecorate,
+        protocol_data_to_decorate = State0
+    }
+) ->
     {State1, ok} = ProtocolModuleToDecorate:close_transport(State0),
     {State#multiplexed_protocol{protocol_data_to_decorate = State1}, ok}.
 
-write(State = #multiplexed_protocol{protocol_module_to_decorate = ProtocolModuleToDecorate,
-                                      protocol_data_to_decorate = State0,
-                                                   service_name = ServiceName},
-      Message = #protocol_message_begin{name = Name}) ->
-    {State1, ok} = ProtocolModuleToDecorate:write(State0,
-                                                  Message#protocol_message_begin{name=ServiceName ++
-                                                                                      ?MULTIPLEXED_SERVICE_SEPARATOR ++
-                                                                                      Name}),
+write(
+    State = #multiplexed_protocol{
+        protocol_module_to_decorate = ProtocolModuleToDecorate,
+        protocol_data_to_decorate = State0,
+        service_name = ServiceName
+    },
+    Message = #protocol_message_begin{name = Name}
+) ->
+    {State1, ok} = ProtocolModuleToDecorate:write(
+        State0,
+        Message#protocol_message_begin{
+            name =
+                ServiceName ++
+                    ?MULTIPLEXED_SERVICE_SEPARATOR ++
+                    Name
+        }
+    ),
     {State#multiplexed_protocol{protocol_data_to_decorate = State1}, ok};
-
-write(State = #multiplexed_protocol{protocol_module_to_decorate = ProtocolModuleToDecorate,
-                                      protocol_data_to_decorate = State0},
-      Message) ->
+write(
+    State = #multiplexed_protocol{
+        protocol_module_to_decorate = ProtocolModuleToDecorate,
+        protocol_data_to_decorate = State0
+    },
+    Message
+) ->
     {State1, ok} = ProtocolModuleToDecorate:write(State0, Message),
     {State#multiplexed_protocol{protocol_data_to_decorate = State1}, ok}.
 
-read(State = #multiplexed_protocol{protocol_module_to_decorate = ProtocolModuleToDecorate,
-                                     protocol_data_to_decorate = State0},
-     Message) ->
+read(
+    State = #multiplexed_protocol{
+        protocol_module_to_decorate = ProtocolModuleToDecorate,
+        protocol_data_to_decorate = State0
+    },
+    Message
+) ->
     {State1, Result} = ProtocolModuleToDecorate:read(State0, Message),
     {State#multiplexed_protocol{protocol_data_to_decorate = State1}, Result}.
diff --git a/lib/erl/src/thrift_processor.erl b/lib/erl/src/thrift_processor.erl
index 5c9f26f..e17eadb 100644
--- a/lib/erl/src/thrift_processor.erl
+++ b/lib/erl/src/thrift_processor.erl
@@ -24,71 +24,101 @@
 -include("thrift_constants.hrl").
 -include("thrift_protocol.hrl").
 
--record(thrift_processor, {handler, protocol, service}).
+-record(thrift_processor, {
+    handler :: module(),
+    protocol :: term(),
+    service :: atom()
+}).
 
 init({_Server, ProtoGen, Service, Handler}) when is_function(ProtoGen, 0) ->
     {ok, Proto} = ProtoGen(),
-    loop(#thrift_processor{protocol = Proto,
-                           service = Service,
-                           handler = Handler}).
+    loop(#thrift_processor{
+        protocol = Proto,
+        service = Service,
+        handler = Handler
+    }).
 
-loop(State0 = #thrift_processor{protocol  = Proto0,
-                                handler = Handler,
-                                service = Service}) ->
-
+loop(
+    State0 = #thrift_processor{
+        protocol = Proto0,
+        handler = Handler,
+        service = Service
+    }
+) ->
     {Proto1, MessageBegin} = thrift_protocol:read(Proto0, message_begin),
     State1 = State0#thrift_processor{protocol = Proto1},
 
     ErrorHandler = fun
-        (HandlerModules) when is_list(HandlerModules) -> thrift_multiplexed_map_wrapper:fetch(?MULTIPLEXED_ERROR_HANDLER_KEY, HandlerModules);
-        (HandlerModule) -> HandlerModule
+        (HandlerModules) when is_list(HandlerModules) ->
+            thrift_multiplexed_map_wrapper:fetch(?MULTIPLEXED_ERROR_HANDLER_KEY, HandlerModules);
+        (HandlerModule) ->
+            HandlerModule
     end,
 
     case MessageBegin of
-
-        #protocol_message_begin{name = Function,
-                                type = Type,
-                                seqid = Seqid} when Type =:= ?tMessageType_CALL; Type =:= ?tMessageType_ONEWAY ->
+        #protocol_message_begin{
+            name = Function,
+            type = Type,
+            seqid = Seqid
+        } when Type =:= ?tMessageType_CALL; Type =:= ?tMessageType_ONEWAY ->
             case string:tokens(Function, ?MULTIPLEXED_SERVICE_SEPARATOR) of
                 [ServiceName, FunctionName] ->
-                    ServiceModule  = thrift_multiplexed_map_wrapper:fetch(ServiceName, Service),
+                    ServiceModule = thrift_multiplexed_map_wrapper:fetch(ServiceName, Service),
                     ServiceHandler = thrift_multiplexed_map_wrapper:fetch(ServiceName, Handler),
-                    case handle_function(State1#thrift_processor{service=ServiceModule, handler=ServiceHandler}, list_to_atom(FunctionName), Seqid) of
-                        {State2, ok} -> loop(State2#thrift_processor{service=Service, handler=Handler});
+                    case
+                        handle_function(
+                            State1#thrift_processor{
+                                service = ServiceModule, handler = ServiceHandler
+                            },
+                            list_to_existing_atom(FunctionName),
+                            Seqid
+                        )
+                    of
+                        {State2, ok} ->
+                            loop(State2#thrift_processor{service = Service, handler = Handler});
                         {_State2, {error, Reason}} ->
-							apply(ErrorHandler(Handler), handle_error, [list_to_atom(Function), Reason]),
+                            apply(ErrorHandler(Handler), handle_error, [
+                                list_to_existing_atom(Function), Reason
+                            ]),
                             thrift_protocol:close_transport(Proto1),
                             ok
                     end;
                 _ ->
-                    case handle_function(State1, list_to_atom(Function), Seqid) of
-                        {State2, ok} -> loop(State2);
+                    case handle_function(State1, list_to_existing_atom(Function), Seqid) of
+                        {State2, ok} ->
+                            loop(State2);
                         {_State2, {error, Reason}} ->
-							apply(ErrorHandler(Handler), handle_error, [list_to_atom(Function), Reason]),
+                            apply(ErrorHandler(Handler), handle_error, [
+                                list_to_existing_atom(Function), Reason
+                            ]),
                             thrift_protocol:close_transport(Proto1),
                             ok
                     end
             end;
         {error, timeout = Reason} ->
-			apply(ErrorHandler(Handler), handle_error, [undefined, Reason]),
+            apply(ErrorHandler(Handler), handle_error, [undefined, Reason]),
             thrift_protocol:close_transport(Proto1),
             ok;
         {error, closed = Reason} ->
             %% error_logger:info_msg("Client disconnected~n"),
-			apply(ErrorHandler(Handler), handle_error, [undefined, Reason]),
+            apply(ErrorHandler(Handler), handle_error, [undefined, Reason]),
             thrift_protocol:close_transport(Proto1),
             exit(shutdown);
         {error, Reason} ->
-			apply(ErrorHandler(Handler), handle_error, [undefined, Reason]),
+            apply(ErrorHandler(Handler), handle_error, [undefined, Reason]),
             thrift_protocol:close_transport(Proto1),
             exit(shutdown)
     end.
 
-handle_function(State0=#thrift_processor{protocol = Proto0,
-                                         handler = Handler,
-                                         service = Service},
-                Function,
-                Seqid) ->
+handle_function(
+    State0 = #thrift_processor{
+        protocol = Proto0,
+        handler = Handler,
+        service = Service
+    },
+    Function,
+    Seqid
+) ->
     InParams = Service:function_info(Function, params_type),
 
     {Proto1, {ok, Params}} = thrift_protocol:read(Proto0, InParams),
@@ -101,55 +131,63 @@
         %%                       [Function, Params, Micro/1000.0]),
         handle_success(State1, Function, Result, Seqid)
     catch
-        Type:Data when Type =:= throw orelse Type =:= error ->
-            handle_function_catch(State1, Function, Type, Data, Seqid)
+        Type:Data:Stack when Type =:= throw orelse Type =:= error ->
+            handle_function_catch(State1, Function, Type, Data, Seqid, Stack)
     end.
 
-handle_function_catch(State = #thrift_processor{service = Service},
-                      Function, ErrType, ErrData, Seqid) ->
+handle_function_catch(
+    State = #thrift_processor{service = Service},
+    Function,
+    ErrType,
+    ErrData,
+    Seqid,
+    Stack
+) ->
     IsOneway = Service:function_info(Function, reply_type) =:= oneway_void,
 
     case {ErrType, ErrData} of
         _ when IsOneway ->
-            Stack = erlang:get_stacktrace(),
             error_logger:warning_msg(
-              "oneway void ~p threw error which must be ignored: ~p",
-              [Function, {ErrType, ErrData, Stack}]),
+                "oneway void ~p threw error which must be ignored: ~p",
+                [Function, {ErrType, ErrData, Stack}]
+            ),
             {State, ok};
-
         {throw, Exception} when is_tuple(Exception), size(Exception) > 0 ->
             %error_logger:warning_msg("~p threw exception: ~p~n", [Function, Exception]),
-            handle_exception(State, Function, Exception, Seqid);
-            % we still want to accept more requests from this client
+            handle_exception(State, Function, Exception, Seqid, Stack);
+        % we still want to accept more requests from this client
 
         {error, Error} ->
-            handle_error(State, Function, Error, Seqid)
+            handle_error(State, Function, Error, Seqid, Stack)
     end.
 
-handle_success(State = #thrift_processor{service = Service},
-               Function,
-               Result,
-               Seqid) ->
-    ReplyType  = Service:function_info(Function, reply_type),
+handle_success(
+    State = #thrift_processor{service = Service},
+    Function,
+    Result,
+    Seqid
+) ->
+    ReplyType = Service:function_info(Function, reply_type),
     StructName = atom_to_list(Function) ++ "_result",
 
     case Result of
         {reply, ReplyData} ->
             Reply = {{struct, [{0, ReplyType}]}, {StructName, ReplyData}},
             send_reply(State, Function, ?tMessageType_REPLY, Reply, Seqid);
-
         ok when ReplyType == {struct, []} ->
             send_reply(State, Function, ?tMessageType_REPLY, {ReplyType, {StructName}}, Seqid);
-
         ok when ReplyType == oneway_void ->
             %% no reply for oneway void
             {State, ok}
     end.
 
-handle_exception(State = #thrift_processor{service = Service},
-                 Function,
-                 Exception,
-                 Seqid) ->
+handle_exception(
+    State = #thrift_processor{service = Service},
+    Function,
+    Exception,
+    Seqid,
+    Stack
+) ->
     ExceptionType = element(1, Exception),
     %% Fetch a structure like {struct, [{-2, {struct, {Module, Type}}},
     %%                                  {-3, {struct, {Module, Type}}}]}
@@ -161,18 +199,20 @@
 
     %% Assuming we had a type1 exception, we'd get: [undefined, Exception, undefined]
     %% e.g.: [{-1, type0}, {-2, type1}, {-3, type2}]
-    ExceptionList = [case Type of
-                         ExceptionType -> Exception;
-                         _ -> undefined
-                     end
-                     || {_Fid, {struct, {_Module, Type}}} <- XInfo],
+    ExceptionList = [
+        case Type of
+            ExceptionType -> Exception;
+            _ -> undefined
+        end
+     || {_Fid, {struct, {_Module, Type}}} <- XInfo
+    ],
 
     ExceptionTuple = list_to_tuple([Function | ExceptionList]),
 
-                                                % Make sure we got at least one defined
+    % Make sure we got at least one defined
     case lists:all(fun(X) -> X =:= undefined end, ExceptionList) of
         true ->
-            handle_unknown_exception(State, Function, Exception, Seqid);
+            handle_unknown_exception(State, Function, Exception, Seqid, Stack);
         false ->
             send_reply(State, Function, ?tMessageType_REPLY, {ReplySpec, ExceptionTuple}, Seqid)
     end.
@@ -181,34 +221,38 @@
 %% Called when an exception has been explicitly thrown by the service, but it was
 %% not one of the exceptions that was defined for the function.
 %%
-handle_unknown_exception(State, Function, Exception, Seqid) ->
-    handle_error(State, Function, {exception_not_declared_as_thrown,
-                                   Exception}, Seqid).
+handle_unknown_exception(State, Function, Exception, Seqid, Stack) ->
+    handle_error(State, Function, {exception_not_declared_as_thrown, Exception}, Seqid, Stack).
 
-handle_error(State, Function, Error, Seqid) ->
-    Stack = erlang:get_stacktrace(),
+handle_error(State, Function, Error, Seqid, Stack) ->
     error_logger:error_msg("~p had an error: ~p~n", [Function, {Error, Stack}]),
 
     Message =
         case application:get_env(thrift, exceptions_include_traces) of
             {ok, true} ->
-                lists:flatten(io_lib:format("An error occurred: ~p~n",
-                                            [{Error, Stack}]));
+                lists:flatten(
+                    io_lib:format(
+                        "An error occurred: ~p~n",
+                        [{Error, Stack}]
+                    )
+                );
             _ ->
                 "An unknown handler error occurred."
         end,
-    Reply = {?TApplicationException_Structure,
-             #'TApplicationException'{
-                message = Message,
-                type = ?TApplicationException_UNKNOWN}},
+    Reply =
+        {?TApplicationException_Structure, #'TApplicationException'{
+            message = Message,
+            type = ?TApplicationException_UNKNOWN
+        }},
     send_reply(State, Function, ?tMessageType_EXCEPTION, Reply, Seqid).
 
 send_reply(State = #thrift_processor{protocol = Proto0}, Function, ReplyMessageType, Reply, Seqid) ->
     try
         {Proto1, ok} = thrift_protocol:write(Proto0, #protocol_message_begin{
-                                               name = atom_to_list(Function),
-                                               type = ReplyMessageType,
-                                               seqid = Seqid}),
+            name = atom_to_list(Function),
+            type = ReplyMessageType,
+            seqid = Seqid
+        }),
         {Proto2, ok} = thrift_protocol:write(Proto1, Reply),
         {Proto3, ok} = thrift_protocol:write(Proto2, message_end),
         {Proto4, ok} = thrift_protocol:flush_transport(Proto3),
diff --git a/lib/erl/src/thrift_protocol.erl b/lib/erl/src/thrift_protocol.erl
index 2fe10d6..c75712a 100644
--- a/lib/erl/src/thrift_protocol.erl
+++ b/lib/erl/src/thrift_protocol.erl
@@ -19,45 +19,67 @@
 
 -module(thrift_protocol).
 
--export([new/2,
-         write/2,
-         read/2,
-         read/3,
-         skip/2,
-         flush_transport/1,
-         close_transport/1,
-         typeid_to_atom/1
-        ]).
-
--export([behaviour_info/1]).
+-export([
+    new/2,
+    write/2,
+    read/2,
+    read/3,
+    skip/2,
+    flush_transport/1,
+    close_transport/1,
+    typeid_to_atom/1
+]).
 
 -include("thrift_constants.hrl").
 -include("thrift_protocol.hrl").
 
--record(protocol, {module, data}).
+-record(protocol, {
+    module :: module(),
+    data :: term()
+}).
 
-behaviour_info(callbacks) ->
-    [
-     {read, 2},
-     {write, 2},
-     {flush_transport, 1},
-     {close_transport, 1}
-    ];
-behaviour_info(_Else) -> undefined.
+%%%=========================================================================
+%%%  API
+%%%=========================================================================
+-type state() :: term().
+-export_type([state/0]).
+-type reason() :: term().
+-export_type([reason/0]).
+
+%% NOTE: keep this in sync with read/2 spec
+-callback read
+    (state(), {struct, _Info}) -> {state(), {ok, tuple()} | {error, reason()}};
+    (state(), tprot_cont_tag()) -> {state(), {ok, any()} | {error, reason()}};
+    (state(), tprot_empty_tag()) -> {state(), ok | {error, reason()}};
+    (state(), tprot_header_tag()) -> {state(), tprot_header_val() | {error, reason()}};
+    (state(), tprot_data_tag()) -> {state(), {ok, any()} | {error, reason()}}.
+
+-callback write(state(), any()) -> {state(), ok | {error, reason()}}.
+
+-callback flush_transport(state()) -> {state(), ok | {error, reason()}}.
+-callback close_transport(state()) -> {state(), ok | {error, reason()}}.
 
 new(Module, Data) when is_atom(Module) ->
-    {ok, #protocol{module = Module,
-                   data = Data}}.
+    {ok, #protocol{
+        module = Module,
+        data = Data
+    }}.
 
 -spec flush_transport(#protocol{}) -> {#protocol{}, ok}.
-flush_transport(Proto = #protocol{module = Module,
-                                  data = Data}) ->
+flush_transport(
+    Proto = #protocol{
+        module = Module,
+        data = Data
+    }
+) ->
     {NewData, Result} = Module:flush_transport(Data),
     {Proto#protocol{data = NewData}, Result}.
 
 -spec close_transport(#protocol{}) -> ok.
-close_transport(#protocol{module = Module,
-                          data = Data}) ->
+close_transport(#protocol{
+    module = Module,
+    data = Data
+}) ->
     Module:close_transport(Data).
 
 typeid_to_atom(?tType_STOP) -> field_stop;
@@ -91,103 +113,123 @@
 %% Structure is like:
 %%    [{Fid, Type}, ...]
 -spec read(#protocol{}, {struct, _StructDef}, atom()) -> {#protocol{}, {ok, tuple()}}.
-read(IProto0, {struct, Structure}, Tag)
-  when is_list(Structure), is_atom(Tag) ->
-
+read(IProto0, {struct, Structure}, Tag) when
+    is_list(Structure), is_atom(Tag)
+->
     % If we want a tagged tuple, we need to offset all the tuple indices
     % by 1 to avoid overwriting the tag.
-    Offset = if Tag =/= undefined -> 1; true -> 0 end,
-    IndexList = case length(Structure) of
-                    N when N > 0 -> lists:seq(1 + Offset, N + Offset);
-                    _ -> []
-                end,
+    Offset =
+        if
+            Tag =/= undefined -> 1;
+            true -> 0
+        end,
+    IndexList =
+        case length(Structure) of
+            N when N > 0 -> lists:seq(1 + Offset, N + Offset);
+            _ -> []
+        end,
 
-    SWithIndices = [{Fid, {Type, Index}} ||
-                       {{Fid, Type}, Index} <-
-                           lists:zip(Structure, IndexList)],
+    SWithIndices = [
+        {Fid, {Type, Index}}
+     || {{Fid, Type}, Index} <-
+            lists:zip(Structure, IndexList)
+    ],
     % Fid -> {Type, Index}
     SDict = dict:from_list(SWithIndices),
 
     {IProto1, ok} = read(IProto0, struct_begin),
     RTuple0 = erlang:make_tuple(length(Structure) + Offset, undefined),
-    RTuple1 = if Tag =/= undefined -> setelement(1, RTuple0, Tag);
-                 true              -> RTuple0
-              end,
+    RTuple1 =
+        if
+            Tag =/= undefined -> setelement(1, RTuple0, Tag);
+            true -> RTuple0
+        end,
 
     {IProto2, RTuple2} = read_struct_loop(IProto1, SDict, RTuple1),
     {IProto2, {ok, RTuple2}}.
 
-
-%% NOTE: Keep this in sync with thrift_protocol_behaviour:read
+%% NOTE: Keep this in sync with read callback
 -spec read
-        (#protocol{}, {struct, _Info}) ->    {#protocol{}, {ok, tuple()}      | {error, _Reason}};
-        (#protocol{}, tprot_cont_tag()) ->   {#protocol{}, {ok, any()}        | {error, _Reason}};
-        (#protocol{}, tprot_empty_tag()) ->  {#protocol{},  ok                | {error, _Reason}};
-        (#protocol{}, tprot_header_tag()) -> {#protocol{}, tprot_header_val() | {error, _Reason}};
-        (#protocol{}, tprot_data_tag()) ->   {#protocol{}, {ok, any()}        | {error, _Reason}}.
+    (#protocol{}, {struct, _Info}) -> {#protocol{}, {ok, tuple()} | {error, _Reason}};
+    (#protocol{}, tprot_cont_tag()) -> {#protocol{}, {ok, any()} | {error, _Reason}};
+    (#protocol{}, tprot_empty_tag()) -> {#protocol{}, ok | {error, _Reason}};
+    (#protocol{}, tprot_header_tag()) -> {#protocol{}, tprot_header_val() | {error, _Reason}};
+    (#protocol{}, tprot_data_tag()) -> {#protocol{}, {ok, any()} | {error, _Reason}}.
 
-read(IProto, {struct, {Module, StructureName}}) when is_atom(Module),
-                                                     is_atom(StructureName) ->
+read(IProto, {struct, {Module, StructureName}}) when
+    is_atom(Module),
+    is_atom(StructureName)
+->
     read(IProto, Module:struct_info(StructureName), StructureName);
-
-read(IProto, S={struct, Structure}) when is_list(Structure) ->
+read(IProto, S = {struct, Structure}) when is_list(Structure) ->
     read(IProto, S, undefined);
-
 read(IProto0, {list, Type}) ->
     {IProto1, #protocol_list_begin{etype = EType, size = Size}} =
         read(IProto0, list_begin),
     {EType, EType} = {term_to_typeid(Type), EType},
-    {List, IProto2} = lists:mapfoldl(fun(_, ProtoS0) ->
-                                             {ProtoS1, {ok, Item}} = read(ProtoS0, Type),
-                                             {Item, ProtoS1}
-                                     end,
-                                     IProto1,
-                                     lists:duplicate(Size, 0)),
+    {List, IProto2} = lists:mapfoldl(
+        fun(_, ProtoS0) ->
+            {ProtoS1, {ok, Item}} = read(ProtoS0, Type),
+            {Item, ProtoS1}
+        end,
+        IProto1,
+        lists:duplicate(Size, 0)
+    ),
     {IProto3, ok} = read(IProto2, list_end),
     {IProto3, {ok, List}};
-
 read(IProto0, {map, KeyType, ValType}) ->
     {IProto1, #protocol_map_begin{size = Size, ktype = KType, vtype = VType}} =
         read(IProto0, map_begin),
-    _ = case Size of
-      0 -> 0;
-      _ ->
-        {KType, KType} = {term_to_typeid(KeyType), KType},
-        {VType, VType} = {term_to_typeid(ValType), VType}
-    end,
-    {List, IProto2} = lists:mapfoldl(fun(_, ProtoS0) ->
-                                             {ProtoS1, {ok, Key}} = read(ProtoS0, KeyType),
-                                             {ProtoS2, {ok, Val}} = read(ProtoS1, ValType),
-                                             {{Key, Val}, ProtoS2}
-                                     end,
-                                     IProto1,
-                                     lists:duplicate(Size, 0)),
+    _ =
+        case Size of
+            0 ->
+                0;
+            _ ->
+                {KType, KType} = {term_to_typeid(KeyType), KType},
+                {VType, VType} = {term_to_typeid(ValType), VType}
+        end,
+    {List, IProto2} = lists:mapfoldl(
+        fun(_, ProtoS0) ->
+            {ProtoS1, {ok, Key}} = read(ProtoS0, KeyType),
+            {ProtoS2, {ok, Val}} = read(ProtoS1, ValType),
+            {{Key, Val}, ProtoS2}
+        end,
+        IProto1,
+        lists:duplicate(Size, 0)
+    ),
     {IProto3, ok} = read(IProto2, map_end),
     {IProto3, {ok, dict:from_list(List)}};
-
 read(IProto0, {set, Type}) ->
     {IProto1, #protocol_set_begin{etype = EType, size = Size}} =
         read(IProto0, set_begin),
     {EType, EType} = {term_to_typeid(Type), EType},
-    {List, IProto2} = lists:mapfoldl(fun(_, ProtoS0) ->
-                                             {ProtoS1, {ok, Item}} = read(ProtoS0, Type),
-                                             {Item, ProtoS1}
-                                     end,
-                                     IProto1,
-                                     lists:duplicate(Size, 0)),
+    {List, IProto2} = lists:mapfoldl(
+        fun(_, ProtoS0) ->
+            {ProtoS1, {ok, Item}} = read(ProtoS0, Type),
+            {Item, ProtoS1}
+        end,
+        IProto1,
+        lists:duplicate(Size, 0)
+    ),
     {IProto3, ok} = read(IProto2, set_end),
     {IProto3, {ok, sets:from_list(List)}};
-
 read(Protocol, ProtocolType) ->
     read_specific(Protocol, ProtocolType).
 
-%% NOTE: Keep this in sync with thrift_protocol_behaviour:read
+%% NOTE: Keep this in sync with read/2 spec
 -spec read_specific
-        (#protocol{}, tprot_empty_tag()) ->  {#protocol{},  ok                | {error, _Reason}};
-        (#protocol{}, tprot_header_tag()) -> {#protocol{}, tprot_header_val() | {error, _Reason}};
-        (#protocol{}, tprot_data_tag()) ->   {#protocol{}, {ok, any()}        | {error, _Reason}}.
-read_specific(Proto = #protocol{module = Module,
-                                data = ModuleData}, ProtocolType) ->
+    (#protocol{}, {struct, _Info}) -> {#protocol{}, {ok, tuple()} | {error, _Reason}};
+    (#protocol{}, tprot_cont_tag()) -> {#protocol{}, {ok, any()} | {error, _Reason}};
+    (#protocol{}, tprot_empty_tag()) -> {#protocol{}, ok | {error, _Reason}};
+    (#protocol{}, tprot_header_tag()) -> {#protocol{}, tprot_header_val() | {error, _Reason}};
+    (#protocol{}, tprot_data_tag()) -> {#protocol{}, {ok, any()} | {error, _Reason}}.
+read_specific(
+    Proto = #protocol{
+        module = Module,
+        data = ModuleData
+    },
+    ProtocolType
+) ->
     {NewData, Result} = Module:read(ModuleData, ProtocolType),
     {Proto#protocol{data = NewData}, Result}.
 
@@ -209,8 +251,9 @@
                             read_struct_loop(IProto3, SDict, NewRTuple);
                         Expected ->
                             error_logger:info_msg(
-                              "Skipping field ~p with wrong type (~p != ~p)~n",
-                              [Fid, FType, Expected]),
+                                "Skipping field ~p with wrong type (~p != ~p)~n",
+                                [Fid, FType, Expected]
+                            ),
                             skip_field(FType, IProto1, SDict, RTuple)
                     end;
                 _Else2 ->
@@ -230,30 +273,25 @@
     {Proto2, ok} = skip_struct_loop(Proto1),
     {Proto3, ok} = read(Proto2, struct_end),
     {Proto3, ok};
-
 skip(Proto0, map) ->
     {Proto1, Map} = read(Proto0, map_begin),
     {Proto2, ok} = skip_map_loop(Proto1, Map),
     {Proto3, ok} = read(Proto2, map_end),
     {Proto3, ok};
-
 skip(Proto0, set) ->
     {Proto1, Set} = read(Proto0, set_begin),
     {Proto2, ok} = skip_set_loop(Proto1, Set),
     {Proto3, ok} = read(Proto2, set_end),
     {Proto3, ok};
-
 skip(Proto0, list) ->
     {Proto1, List} = read(Proto0, list_begin),
     {Proto2, ok} = skip_list_loop(Proto1, List),
     {Proto3, ok} = read(Proto2, list_end),
     {Proto3, ok};
-
 skip(Proto0, Type) when is_atom(Type) ->
     {Proto1, _Ignore} = read(Proto0, Type),
     {Proto1, ok}.
 
-
 skip_struct_loop(Proto0) ->
     {Proto1, #protocol_field_begin{type = Type}} = read(Proto0, field_begin),
     case Type of
@@ -265,39 +303,62 @@
             skip_struct_loop(Proto3)
     end.
 
-skip_map_loop(Proto0, Map = #protocol_map_begin{ktype = Ktype,
-                                                vtype = Vtype,
-                                                size = Size}) ->
+skip_map_loop(
+    Proto0,
+    Map = #protocol_map_begin{
+        ktype = Ktype,
+        vtype = Vtype,
+        size = Size
+    }
+) ->
     case Size of
         N when N > 0 ->
             {Proto1, ok} = skip(Proto0, typeid_to_atom(Ktype)),
             {Proto2, ok} = skip(Proto1, typeid_to_atom(Vtype)),
-            skip_map_loop(Proto2,
-                          Map#protocol_map_begin{size = Size - 1});
-        0 -> {Proto0, ok}
+            skip_map_loop(
+                Proto2,
+                Map#protocol_map_begin{size = Size - 1}
+            );
+        0 ->
+            {Proto0, ok}
     end.
 
-skip_set_loop(Proto0, Map = #protocol_set_begin{etype = Etype,
-                                                size = Size}) ->
+skip_set_loop(
+    Proto0,
+    Map = #protocol_set_begin{
+        etype = Etype,
+        size = Size
+    }
+) ->
     case Size of
         N when N > 0 ->
             {Proto1, ok} = skip(Proto0, typeid_to_atom(Etype)),
-            skip_set_loop(Proto1,
-                          Map#protocol_set_begin{size = Size - 1});
-        0 -> {Proto0, ok}
+            skip_set_loop(
+                Proto1,
+                Map#protocol_set_begin{size = Size - 1}
+            );
+        0 ->
+            {Proto0, ok}
     end.
 
-skip_list_loop(Proto0, Map = #protocol_list_begin{etype = Etype,
-                                                  size = Size}) ->
+skip_list_loop(
+    Proto0,
+    Map = #protocol_list_begin{
+        etype = Etype,
+        size = Size
+    }
+) ->
     case Size of
         N when N > 0 ->
             {Proto1, ok} = skip(Proto0, typeid_to_atom(Etype)),
-            skip_list_loop(Proto1,
-                           Map#protocol_list_begin{size = Size - 1});
-        0 -> {Proto0, ok}
+            skip_list_loop(
+                Proto1,
+                Map#protocol_list_begin{size = Size - 1}
+            );
+        0 ->
+            {Proto0, ok}
     end.
 
-
 %%--------------------------------------------------------------------
 %% Function: write(OProto, {Type, Data}) -> ok
 %%
@@ -318,95 +379,112 @@
 %%--------------------------------------------------------------------
 -spec write(#protocol{}, any()) -> {#protocol{}, ok | {error, _Reason}}.
 
-write(Proto0, {{struct, StructDef}, Data})
-  when is_list(StructDef), is_tuple(Data), length(StructDef) == size(Data) - 1 ->
-
+write(Proto0, {{struct, StructDef}, Data}) when
+    is_list(StructDef), is_tuple(Data), length(StructDef) == size(Data) - 1
+->
     [StructName | Elems] = tuple_to_list(Data),
     {Proto1, ok} = write(Proto0, #protocol_struct_begin{name = StructName}),
     {Proto2, ok} = struct_write_loop(Proto1, StructDef, Elems),
     {Proto3, ok} = write(Proto2, struct_end),
     {Proto3, ok};
-
-write(Proto, {{struct, {Module, StructureName}}, Data})
-  when is_atom(Module),
-       is_atom(StructureName),
-       element(1, Data) =:= StructureName ->
+write(Proto, {{struct, {Module, StructureName}}, Data}) when
+    is_atom(Module),
+    is_atom(StructureName),
+    element(1, Data) =:= StructureName
+->
     write(Proto, {Module:struct_info(StructureName), Data});
-
-write(_, {{struct, {Module, StructureName}}, Data})
-  when is_atom(Module),
-       is_atom(StructureName) ->
-    erlang:error(struct_unmatched, {{provided, element(1, Data)},
-                             {expected, StructureName}});
-
-write(Proto0, {{list, Type}, Data})
-  when is_list(Data) ->
-    {Proto1, ok} = write(Proto0,
-               #protocol_list_begin{
-                 etype = term_to_typeid(Type),
-                 size = length(Data)
-                }),
-    Proto2 = lists:foldl(fun(Elem, ProtoIn) ->
-                                 {ProtoOut, ok} = write(ProtoIn, {Type, Elem}),
-                                 ProtoOut
-                         end,
-                         Proto1,
-                         Data),
+write(_, {{struct, {Module, StructureName}}, Data}) when
+    is_atom(Module),
+    is_atom(StructureName)
+->
+    erlang:error(struct_unmatched, {{provided, element(1, Data)}, {expected, StructureName}});
+write(Proto0, {{list, Type}, Data}) when
+    is_list(Data)
+->
+    {Proto1, ok} = write(
+        Proto0,
+        #protocol_list_begin{
+            etype = term_to_typeid(Type),
+            size = length(Data)
+        }
+    ),
+    Proto2 = lists:foldl(
+        fun(Elem, ProtoIn) ->
+            {ProtoOut, ok} = write(ProtoIn, {Type, Elem}),
+            ProtoOut
+        end,
+        Proto1,
+        Data
+    ),
     {Proto3, ok} = write(Proto2, list_end),
     {Proto3, ok};
-
 write(Proto0, {{map, KeyType, ValType}, Data}) ->
-    {Proto1, ok} = write(Proto0,
-                         #protocol_map_begin{
-                           ktype = term_to_typeid(KeyType),
-                           vtype = term_to_typeid(ValType),
-                           size  = dict:size(Data)
-                          }),
-    Proto2 = dict:fold(fun(KeyData, ValData, ProtoS0) ->
-                               {ProtoS1, ok} = write(ProtoS0, {KeyType, KeyData}),
-                               {ProtoS2, ok} = write(ProtoS1, {ValType, ValData}),
-                               ProtoS2
-                       end,
-                       Proto1,
-                       Data),
+    {Proto1, ok} = write(
+        Proto0,
+        #protocol_map_begin{
+            ktype = term_to_typeid(KeyType),
+            vtype = term_to_typeid(ValType),
+            size = dict:size(Data)
+        }
+    ),
+    Proto2 = dict:fold(
+        fun(KeyData, ValData, ProtoS0) ->
+            {ProtoS1, ok} = write(ProtoS0, {KeyType, KeyData}),
+            {ProtoS2, ok} = write(ProtoS1, {ValType, ValData}),
+            ProtoS2
+        end,
+        Proto1,
+        Data
+    ),
     {Proto3, ok} = write(Proto2, map_end),
     {Proto3, ok};
-
 write(Proto0, {{set, Type}, Data}) ->
     true = sets:is_set(Data),
-    {Proto1, ok} = write(Proto0,
-                         #protocol_set_begin{
-                           etype = term_to_typeid(Type),
-                           size  = sets:size(Data)
-                          }),
-    Proto2 = sets:fold(fun(Elem, ProtoIn) ->
-                               {ProtoOut, ok} = write(ProtoIn, {Type, Elem}),
-                               ProtoOut
-                       end,
-                       Proto1,
-                       Data),
+    {Proto1, ok} = write(
+        Proto0,
+        #protocol_set_begin{
+            etype = term_to_typeid(Type),
+            size = sets:size(Data)
+        }
+    ),
+    Proto2 = sets:fold(
+        fun(Elem, ProtoIn) ->
+            {ProtoOut, ok} = write(ProtoIn, {Type, Elem}),
+            ProtoOut
+        end,
+        Proto1,
+        Data
+    ),
     {Proto3, ok} = write(Proto2, set_end),
     {Proto3, ok};
-
-write(Proto = #protocol{module = Module,
-                        data = ModuleData}, Data) ->
+write(
+    Proto = #protocol{
+        module = Module,
+        data = ModuleData
+    },
+    Data
+) ->
     {NewData, Result} = Module:write(ModuleData, Data),
     {Proto#protocol{data = NewData}, Result}.
 
 struct_write_loop(Proto0, [{Fid, Type} | RestStructDef], [Data | RestData]) ->
-    NewProto = case Data of
-                   undefined ->
-                       Proto0; % null fields are skipped in response
-                   _ ->
-                       {Proto1, ok} = write(Proto0,
-                                           #protocol_field_begin{
-                                             type = term_to_typeid(Type),
-                                             id = Fid
-                                            }),
-                       {Proto2, ok} = write(Proto1, {Type, Data}),
-                       {Proto3, ok} = write(Proto2, field_end),
-                       Proto3
-               end,
+    NewProto =
+        case Data of
+            undefined ->
+                % null fields are skipped in response
+                Proto0;
+            _ ->
+                {Proto1, ok} = write(
+                    Proto0,
+                    #protocol_field_begin{
+                        type = term_to_typeid(Type),
+                        id = Fid
+                    }
+                ),
+                {Proto2, ok} = write(Proto1, {Type, Data}),
+                {Proto3, ok} = write(Proto2, field_end),
+                Proto3
+        end,
     struct_write_loop(NewProto, RestStructDef, RestData);
 struct_write_loop(Proto, [], []) ->
     write(Proto, field_stop).
diff --git a/lib/erl/src/thrift_reconnecting_client.erl b/lib/erl/src/thrift_reconnecting_client.erl
index 538fd3a..c9fe2aa 100644
--- a/lib/erl/src/thrift_reconnecting_client.erl
+++ b/lib/erl/src/thrift_reconnecting_client.erl
@@ -22,30 +22,36 @@
 -behaviour(gen_server).
 
 %% API
--export([ call/3,
-          get_stats/1,
-          get_and_reset_stats/1 ]).
+-export([
+    call/3,
+    get_stats/1,
+    get_and_reset_stats/1
+]).
 
--export([ start_link/6 ]).
+-export([start_link/6]).
 
 %% gen_server callbacks
--export([ init/1,
-          handle_call/3,
-          handle_cast/2,
-          handle_info/2,
-          terminate/2,
-          code_change/3 ]).
+-export([
+    init/1,
+    handle_call/3,
+    handle_cast/2,
+    handle_info/2,
+    terminate/2,
+    code_change/3
+]).
 
--record( state, { client = nil,
-                  host,
-                  port,
-                  thrift_svc,
-                  thrift_opts,
-                  reconn_min,
-                  reconn_max,
-                  reconn_time = 0,
-                  op_cnt_dict,
-                  op_time_dict } ).
+-record(state, {
+    client = nil,
+    host,
+    port,
+    thrift_svc,
+    thrift_opts,
+    reconn_min,
+    reconn_max,
+    reconn_time = 0,
+    op_cnt_dict,
+    op_time_dict
+}).
 
 %%====================================================================
 %% API
@@ -54,23 +60,35 @@
 %% Function: start_link() -> {ok,Pid} | ignore | {error,Error}
 %% Description: Starts the server
 %%--------------------------------------------------------------------
-start_link( Host, Port,
-            ThriftSvc, ThriftOpts,
-            ReconnMin, ReconnMax ) ->
-  gen_server:start_link( ?MODULE,
-                         [ Host, Port,
-                           ThriftSvc, ThriftOpts,
-                           ReconnMin, ReconnMax ],
-                         [] ).
+start_link(
+    Host,
+    Port,
+    ThriftSvc,
+    ThriftOpts,
+    ReconnMin,
+    ReconnMax
+) ->
+    gen_server:start_link(
+        ?MODULE,
+        [
+            Host,
+            Port,
+            ThriftSvc,
+            ThriftOpts,
+            ReconnMin,
+            ReconnMax
+        ],
+        []
+    ).
 
-call( Pid, Op, Args ) ->
-  gen_server:call( Pid, { call, Op, Args } ).
+call(Pid, Op, Args) ->
+    gen_server:call(Pid, {call, Op, Args}).
 
-get_stats( Pid ) ->
-  gen_server:call( Pid, get_stats ).
+get_stats(Pid) ->
+    gen_server:call(Pid, get_stats).
 
-get_and_reset_stats( Pid ) ->
-  gen_server:call( Pid, get_and_reset_stats ).
+get_and_reset_stats(Pid) ->
+    gen_server:call(Pid, get_and_reset_stats).
 
 %%====================================================================
 %% gen_server callbacks
@@ -83,19 +101,21 @@
 %%                         {stop, Reason}
 %% Description: Start the server.
 %%--------------------------------------------------------------------
-init( [ Host, Port, TSvc, TOpts, ReconnMin, ReconnMax ] ) ->
-  process_flag( trap_exit, true ),
+init([Host, Port, TSvc, TOpts, ReconnMin, ReconnMax]) ->
+    process_flag(trap_exit, true),
 
-  State = #state{ host         = Host,
-                  port         = Port,
-                  thrift_svc   = TSvc,
-                  thrift_opts  = TOpts,
-                  reconn_min   = ReconnMin,
-                  reconn_max   = ReconnMax,
-                  op_cnt_dict  = dict:new(),
-                  op_time_dict = dict:new() },
+    State = #state{
+        host = Host,
+        port = Port,
+        thrift_svc = TSvc,
+        thrift_opts = TOpts,
+        reconn_min = ReconnMin,
+        reconn_max = ReconnMax,
+        op_cnt_dict = dict:new(),
+        op_time_dict = dict:new()
+    },
 
-  { ok, try_connect( State ) }.
+    {ok, try_connect(State)}.
 
 %%--------------------------------------------------------------------
 %% Function: %% handle_call(Request, From, State) -> {reply, Reply, State} |
@@ -106,40 +126,44 @@
 %%                                                   {stop, Reason, State}
 %% Description: Handling call messages
 %%--------------------------------------------------------------------
-handle_call( { call, Op, _ },
-             _From,
-             State = #state{ client = nil } ) ->
-  { reply, { error, noconn }, incr_stats( Op, "failfast", 1, State ) };
+handle_call(
+    {call, Op, _},
+    _From,
+    State = #state{client = nil}
+) ->
+    {reply, {error, noconn}, incr_stats(Op, "failfast", 1, State)};
+handle_call(
+    {call, Op, Args},
+    _From,
+    State = #state{client = Client}
+) ->
+    Timer = timer_fun(),
+    Result = (catch thrift_client:call(Client, Op, Args)),
+    Time = Timer(),
 
-handle_call( { call, Op, Args },
-             _From,
-             State=#state{ client = Client } ) ->
-
-  Timer = timer_fun(),
-  Result = ( catch thrift_client:call( Client, Op, Args) ),
-  Time = Timer(),
-
-  case Result of
-    { C, { ok, Reply } } ->
-      S = incr_stats( Op, "success", Time, State#state{ client = C } ),
-      { reply, {ok, Reply }, S };
-    { _, { E, Msg } } when E == error; E == exception ->
-      S = incr_stats( Op, "error", Time, try_connect( State ) ),
-      { reply, { E, Msg }, S };
-    Other ->
-      S = incr_stats( Op, "error", Time, try_connect( State ) ),
-      { reply, Other, S }
-  end;
-
-handle_call( get_stats,
-             _From,
-             State = #state{} ) ->
-  { reply, stats( State ), State };
-
-handle_call( get_and_reset_stats,
-             _From,
-             State = #state{} ) ->
-  { reply, stats( State ), reset_stats( State ) }.
+    case Result of
+        {C, {ok, Reply}} ->
+            S = incr_stats(Op, "success", Time, State#state{client = C}),
+            {reply, {ok, Reply}, S};
+        {_, {E, Msg}} when E == error; E == exception ->
+            S = incr_stats(Op, "error", Time, try_connect(State)),
+            {reply, {E, Msg}, S};
+        Other ->
+            S = incr_stats(Op, "error", Time, try_connect(State)),
+            {reply, Other, S}
+    end;
+handle_call(
+    get_stats,
+    _From,
+    State = #state{}
+) ->
+    {reply, stats(State), State};
+handle_call(
+    get_and_reset_stats,
+    _From,
+    State = #state{}
+) ->
+    {reply, stats(State), reset_stats(State)}.
 
 %%--------------------------------------------------------------------
 %% Function: handle_cast(Msg, State) -> {noreply, State} |
@@ -147,8 +171,8 @@
 %%                                      {stop, Reason, State}
 %% Description: Handling cast messages
 %%--------------------------------------------------------------------
-handle_cast( _Msg, State ) ->
-  { noreply, State }.
+handle_cast(_Msg, State) ->
+    {noreply, State}.
 
 %%--------------------------------------------------------------------
 %% Function: handle_info(Info, State) -> {noreply, State} |
@@ -156,11 +180,10 @@
 %%                                       {stop, Reason, State}
 %% Description: Handling all non call/cast messages
 %%--------------------------------------------------------------------
-handle_info( try_connect, State ) ->
-  { noreply, try_connect( State ) };
-
-handle_info( _Info, State ) ->
-  { noreply, State }.
+handle_info(try_connect, State) ->
+    {noreply, try_connect(State)};
+handle_info(_Info, State) ->
+    {noreply, State}.
 
 %%--------------------------------------------------------------------
 %% Function: terminate(Reason, State) -> void()
@@ -169,90 +192,103 @@
 %% cleaning up. When it returns, the gen_server terminates with Reason.
 %% The return value is ignored.
 %%--------------------------------------------------------------------
-terminate( _Reason, #state{ client = Client } ) ->
-  thrift_client:close( Client ),
-  ok.
+terminate(_Reason, #state{client = Client}) ->
+    thrift_client:close(Client),
+    ok.
 
 %%--------------------------------------------------------------------
 %% Func: code_change(OldVsn, State, Extra) -> {ok, NewState}
 %% Description: Convert process state when code is changed
 %%--------------------------------------------------------------------
-code_change( _OldVsn, State, _Extra ) ->
-  { ok, State }.
+code_change(_OldVsn, State, _Extra) ->
+    {ok, State}.
 
 %%--------------------------------------------------------------------
 %%% Internal functions
 %%--------------------------------------------------------------------
-try_connect( State = #state{ client      = OldClient,
-                             host        = Host,
-                             port        = Port,
-                             thrift_svc  = TSvc,
-                             thrift_opts = TOpts } ) ->
+try_connect(
+    State = #state{
+        client = OldClient,
+        host = Host,
+        port = Port,
+        thrift_svc = TSvc,
+        thrift_opts = TOpts
+    }
+) ->
+    case OldClient of
+        nil -> ok;
+        _ -> (catch thrift_client:close(OldClient))
+    end,
 
-  case OldClient of
-    nil -> ok;
-    _   -> ( catch thrift_client:close( OldClient ) )
-  end,
+    case catch thrift_client_util:new(Host, Port, TSvc, TOpts) of
+        {ok, Client} ->
+            State#state{client = Client, reconn_time = 0};
+        {E, Msg} when E == error; E == exception ->
+            ReconnTime = reconn_time(State),
+            error_logger:error_msg(
+                "[~w] ~w connect failed (~w), trying again in ~w ms~n",
+                [self(), TSvc, Msg, ReconnTime]
+            ),
+            erlang:send_after(ReconnTime, self(), try_connect),
+            State#state{client = nil, reconn_time = ReconnTime}
+    end.
 
-  case catch thrift_client_util:new( Host, Port, TSvc, TOpts ) of
-    { ok, Client } ->
-      State#state{ client = Client, reconn_time = 0 };
-    { E, Msg } when E == error; E == exception ->
-      ReconnTime = reconn_time( State ),
-      error_logger:error_msg( "[~w] ~w connect failed (~w), trying again in ~w ms~n",
-                              [ self(), TSvc, Msg, ReconnTime ] ),
-      erlang:send_after( ReconnTime, self(), try_connect ),
-      State#state{ client = nil, reconn_time = ReconnTime }
-  end.
-
-
-reconn_time( #state{ reconn_min = ReconnMin, reconn_time = 0 } ) ->
-  ReconnMin;
-reconn_time( #state{ reconn_max = ReconnMax, reconn_time = ReconnMax } ) ->
-  ReconnMax;
-reconn_time( #state{ reconn_max = ReconnMax, reconn_time = R } ) ->
-  Backoff = 2 * R,
-  case Backoff > ReconnMax of
-    true  -> ReconnMax;
-    false -> Backoff
-  end.
+reconn_time(#state{reconn_min = ReconnMin, reconn_time = 0}) ->
+    ReconnMin;
+reconn_time(#state{reconn_max = ReconnMax, reconn_time = ReconnMax}) ->
+    ReconnMax;
+reconn_time(#state{reconn_max = ReconnMax, reconn_time = R}) ->
+    Backoff = 2 * R,
+    case Backoff > ReconnMax of
+        true -> ReconnMax;
+        false -> Backoff
+    end.
 
 -ifdef(time_correction).
 timer_fun() ->
-  T1 = erlang:monotonic_time(),
-  fun() ->
-    T2 = erlang:monotonic_time(),
-    erlang:convert_time_unit(T2 - T1, native, micro_seconds)
-  end.
+    T1 = erlang:monotonic_time(),
+    fun() ->
+        T2 = erlang:monotonic_time(),
+        erlang:convert_time_unit(T2 - T1, native, micro_seconds)
+    end.
 -else.
 timer_fun() ->
-  T1 = erlang:timestamp(),
-  fun() ->
-    T2 = erlang:timestamp(),
-    timer:now_diff(T2, T1)
-  end.
+    T1 = erlang:timestamp(),
+    fun() ->
+        T2 = erlang:timestamp(),
+        timer:now_diff(T2, T1)
+    end.
 -endif.
 
-incr_stats( Op, Result, Time,
-            State = #state{ op_cnt_dict  = OpCntDict,
-                            op_time_dict = OpTimeDict } ) ->
-  Key = lists:flatten( [ atom_to_list( Op ), [ "_" | Result ] ] ),
-  State#state{ op_cnt_dict  = dict:update_counter( Key, 1, OpCntDict ),
-               op_time_dict = dict:update_counter( Key, Time, OpTimeDict ) }.
+incr_stats(
+    Op,
+    Result,
+    Time,
+    State = #state{
+        op_cnt_dict = OpCntDict,
+        op_time_dict = OpTimeDict
+    }
+) ->
+    Key = lists:flatten([atom_to_list(Op), ["_" | Result]]),
+    State#state{
+        op_cnt_dict = dict:update_counter(Key, 1, OpCntDict),
+        op_time_dict = dict:update_counter(Key, Time, OpTimeDict)
+    }.
 
+stats(#state{
+    thrift_svc = TSvc,
+    op_cnt_dict = OpCntDict,
+    op_time_dict = OpTimeDict
+}) ->
+    Svc = atom_to_list(TSvc),
 
-stats( #state{ thrift_svc   = TSvc,
-               op_cnt_dict  = OpCntDict,
-               op_time_dict = OpTimeDict } ) ->
-  Svc = atom_to_list(TSvc),
+    F = fun(Key, Count, Stats) ->
+        Name = lists:flatten([Svc, ["_" | Key]]),
+        Micros = dict:fetch(Key, OpTimeDict),
+        [{Name, Count, Micros} | Stats]
+    end,
 
-  F = fun( Key, Count, Stats ) ->
-        Name = lists:flatten( [ Svc, [ "_" | Key ] ] ),
-        Micros = dict:fetch( Key, OpTimeDict ),
-        [ { Name, Count, Micros } | Stats ]
-      end,
+    dict:fold(F, [], OpCntDict).
 
-  dict:fold( F, [], OpCntDict ).
-
-reset_stats( State = #state{} ) ->
-  State#state{ op_cnt_dict = dict:new(), op_time_dict = dict:new() }.
+reset_stats(State = #state{}) ->
+    State#state{op_cnt_dict = dict:new(), op_time_dict = dict:new()}.
diff --git a/lib/erl/src/thrift_server.erl b/lib/erl/src/thrift_server.erl
index 5012e16..e97acff 100644
--- a/lib/erl/src/thrift_server.erl
+++ b/lib/erl/src/thrift_server.erl
@@ -25,12 +25,23 @@
 -export([start_link/3, stop/1, take_socket/2]).
 
 %% gen_server callbacks
--export([init/1, handle_call/3, handle_cast/2, handle_info/2,
-         terminate/2, code_change/3]).
+-export([
+    init/1,
+    handle_call/3,
+    handle_cast/2,
+    handle_info/2,
+    terminate/2,
+    code_change/3
+]).
 
 -define(SERVER, ?MODULE).
 
--record(state, {listen_socket, acceptor_ref, service, handler}).
+-record(state, {
+    listen_socket :: gen_tcp:socket(),
+    acceptor_ref :: term(),
+    service :: module(),
+    handler :: module()
+}).
 
 %%====================================================================
 %% API
@@ -49,11 +60,9 @@
 stop(Pid) when is_pid(Pid) ->
     gen_server:call(Pid, stop).
 
-
 take_socket(Server, Socket) ->
     gen_server:call(Server, {take_socket, Socket}).
 
-
 %%====================================================================
 %% gen_server callbacks
 %%====================================================================
@@ -66,17 +75,23 @@
 %% Description: Initiates the server
 %%--------------------------------------------------------------------
 init({Port, Service, Handler}) ->
-    {ok, Socket} = gen_tcp:listen(Port,
-                                  [binary,
-                                   {packet, 0},
-                                   {active, false},
-                                   {nodelay, true},
-                                   {reuseaddr, true}]),
+    {ok, Socket} = gen_tcp:listen(
+        Port,
+        [
+            binary,
+            {packet, 0},
+            {active, false},
+            {nodelay, true},
+            {reuseaddr, true}
+        ]
+    ),
     {ok, Ref} = prim_inet:async_accept(Socket, -1),
-    {ok, #state{listen_socket = Socket,
-                acceptor_ref = Ref,
-                service = Service,
-                handler = Handler}}.
+    {ok, #state{
+        listen_socket = Socket,
+        acceptor_ref = Ref,
+        service = Service,
+        handler = Handler
+    }}.
 
 %%--------------------------------------------------------------------
 %% Function: %% handle_call(Request, From, State) -> {reply, Reply, State} |
@@ -89,7 +104,6 @@
 %%--------------------------------------------------------------------
 handle_call(stop, _From, State) ->
     {stop, stopped, ok, State};
-
 handle_call({take_socket, Socket}, {FromPid, _Tag}, State) ->
     Result = gen_tcp:controlling_process(Socket, FromPid),
     {reply, Result, State}.
@@ -109,11 +123,15 @@
 %%                                       {stop, Reason, State}
 %% Description: Handling all non call/cast messages
 %%--------------------------------------------------------------------
-handle_info({inet_async, ListenSocket, Ref, {ok, ClientSocket}},
-            State = #state{listen_socket = ListenSocket,
-                           acceptor_ref = Ref,
-                           service = Service,
-                           handler = Handler}) ->
+handle_info(
+    {inet_async, ListenSocket, Ref, {ok, ClientSocket}},
+    State = #state{
+        listen_socket = ListenSocket,
+        acceptor_ref = Ref,
+        service = Service,
+        handler = Handler
+    }
+) ->
     case set_sockopt(ListenSocket, ClientSocket) of
         ok ->
             %% New client connected - start processor
@@ -121,15 +139,15 @@
             {ok, NewRef} = prim_inet:async_accept(ListenSocket, -1),
             {noreply, State#state{acceptor_ref = NewRef}};
         {error, Reason} ->
-            error_logger:error_msg("Couldn't set socket opts: ~p~n",
-                                   [Reason]),
+            error_logger:error_msg(
+                "Couldn't set socket opts: ~p~n",
+                [Reason]
+            ),
             {stop, Reason, State}
     end;
-
 handle_info({inet_async, _ListenSocket, _Ref, Error}, State) ->
     error_logger:error_msg("Error in acceptor: ~p~n", [Error]),
     {stop, Error, State};
-
 handle_info(_Info, State) ->
     {noreply, State}.
 
@@ -155,13 +173,19 @@
 %%--------------------------------------------------------------------
 set_sockopt(ListenSocket, ClientSocket) ->
     true = inet_db:register_socket(ClientSocket, inet_tcp),
-    case prim_inet:getopts(ListenSocket,
-                           [active, nodelay, keepalive, delay_send, priority, tos]) of
+    case
+        prim_inet:getopts(
+            ListenSocket,
+            [active, nodelay, keepalive, delay_send, priority, tos]
+        )
+    of
         {ok, Opts} ->
             case prim_inet:setopts(ClientSocket, Opts) of
-                ok    -> ok;
-                Error -> gen_tcp:close(ClientSocket),
-                         Error
+                ok ->
+                    ok;
+                Error ->
+                    gen_tcp:close(ClientSocket),
+                    Error
             end;
         Error ->
             gen_tcp:close(ClientSocket),
@@ -172,12 +196,12 @@
     Server = self(),
 
     ProtoGen = fun() ->
-                       % Become the controlling process
-                       ok = take_socket(Server, Socket),
-                       {ok, SocketTransport} = thrift_socket_transport:new(Socket),
-                       {ok, BufferedTransport} = thrift_buffered_transport:new(SocketTransport),
-                       {ok, Protocol} = thrift_binary_protocol:new(BufferedTransport),
-                       {ok, Protocol}
-               end,
+        % Become the controlling process
+        ok = take_socket(Server, Socket),
+        {ok, SocketTransport} = thrift_socket_transport:new(Socket),
+        {ok, BufferedTransport} = thrift_buffered_transport:new(SocketTransport),
+        {ok, Protocol} = thrift_binary_protocol:new(BufferedTransport),
+        {ok, Protocol}
+    end,
 
     spawn(thrift_processor, init, [{Server, ProtoGen, Service, Handler}]).
diff --git a/lib/erl/src/thrift_service.erl b/lib/erl/src/thrift_service.erl
index 2ed7b57..5024102 100644
--- a/lib/erl/src/thrift_service.erl
+++ b/lib/erl/src/thrift_service.erl
@@ -19,7 +19,9 @@
 
 -module(thrift_service).
 
--export([behaviour_info/1]).
+%%%=========================================================================
+%%%  API
+%%%=========================================================================
 
-behaviour_info(callbacks) ->
-    [{function_info, 2}].
+%% TODO Replace response with type
+-callback function_info(atom(), atom()) -> {struct, term()}.
diff --git a/lib/erl/src/thrift_socket_server.erl b/lib/erl/src/thrift_socket_server.erl
index 432e65b..abeee81 100644
--- a/lib/erl/src/thrift_socket_server.erl
+++ b/lib/erl/src/thrift_socket_server.erl
@@ -21,40 +21,51 @@
 
 -behaviour(gen_server).
 
--include ("thrift_constants.hrl").
+-include("thrift_constants.hrl").
+
+-export([start/1, stop/1]).
+-export([
+    init/1,
+    handle_call/3,
+    handle_cast/2,
+    terminate/2,
+    code_change/3,
+    handle_info/2
+]).
+-export([acceptor_loop/1]).
 
 -ifdef(TEST).
-    -compile(export_all).
-    -export_records([thrift_socket_server]).
--else.
-    -export([start/1, stop/1]).
-
-    -export([init/1, handle_call/3, handle_cast/2, terminate/2, code_change/3,
-             handle_info/2]).
-
-    -export([acceptor_loop/1]).
+-export([parse_options/1]).
 -endif.
 
--record(thrift_socket_server,
-        {port,
-         service,
-         handler,
-         name,
-         max=2048,
-         ip=any,
-         listen=null,
-         acceptor=null,
-         socket_opts=[{recv_timeout, 500}],
-         protocol=binary,
-         framed=false,
-         ssltransport=false,
-         ssloptions=[]
-        }).
+-type protocol() ::
+    compact
+    | {compact, term()}
+    | json
+    | {json, term()}
+    | binary
+    | {binary | term()}
+    | {custom, module(), term()}.
 
-start(State=#thrift_socket_server{}) ->
-    start_server(State);
+-type socket_opts() :: [inet:inet_backend() | gen_tcp:listen_option()].
+-type ssl_opts() :: [ssl:tls_server_option()].
+
+-record(thrift_socket_server, {
+    port :: inet:port_number(),
+    service :: thrift_multiplexed_map_wrapper:service_handler_map(),
+    handler :: thrift_multiplexed_map_wrapper:service_handler_map(),
+    acceptors_left :: non_neg_integer(),
+    listen :: gen_tcp:socket(),
+    acceptor :: undefined | pid(),
+    socket_opts :: socket_opts(),
+    protocol :: protocol(),
+    framed :: boolean(),
+    ssltransport :: boolean(),
+    ssloptions :: ssl_opts()
+}).
+
 start(Options) ->
-    start(parse_options(Options)).
+    start_server(parse_options(Options)).
 
 stop(Name) when is_atom(Name) ->
     gen_server:cast(Name, stop);
@@ -65,259 +76,300 @@
 stop({global, Name}) ->
     stop(Name);
 stop(Options) ->
-    State = parse_options(Options),
-    stop(State#thrift_socket_server.name).
+    #{name := Name} = parse_options(Options),
+    stop(Name).
 
 %% Internal API
 
 parse_options(Options) ->
-    parse_options(Options, #thrift_socket_server{}).
+    parse_options(Options, #{}).
 
 parse_options([], State) ->
     State;
 parse_options([{name, L} | Rest], State) when is_list(L) ->
     Name = {local, list_to_atom(L)},
-    parse_options(Rest, State#thrift_socket_server{name=Name});
+    parse_options(Rest, State#{name => Name});
 parse_options([{name, A} | Rest], State) when is_atom(A) ->
     Name = {local, A},
-    parse_options(Rest, State#thrift_socket_server{name=Name});
+    parse_options(Rest, State#{name => Name});
 parse_options([{name, Name} | Rest], State) ->
-    parse_options(Rest, State#thrift_socket_server{name=Name});
+    parse_options(Rest, State#{name => Name});
 parse_options([{port, L} | Rest], State) when is_list(L) ->
     Port = list_to_integer(L),
-    parse_options(Rest, State#thrift_socket_server{port=Port});
-parse_options([{port, Port} | Rest], State) ->
-    parse_options(Rest, State#thrift_socket_server{port=Port});
+    parse_options(Rest, State#{port => Port});
+parse_options([{port, Port} | Rest], State) when is_integer(Port), Port >= 0, Port =< 65535 ->
+    parse_options(Rest, State#{port => Port});
 parse_options([{ip, Ip} | Rest], State) ->
-    ParsedIp = case Ip of
-                   any ->
-                       any;
-                   Ip when is_tuple(Ip) ->
-                       Ip;
-                   Ip when is_list(Ip) ->
-                       {ok, IpTuple} = inet_parse:address(Ip),
-                       IpTuple
-               end,
-    parse_options(Rest, State#thrift_socket_server{ip=ParsedIp});
+    case Ip of
+        any ->
+            parse_options(Rest, State);
+        Ip when is_tuple(Ip) ->
+            parse_options(Rest, State#{ip => Ip});
+        Ip when is_list(Ip) ->
+            {ok, IpTuple} = inet_parse:address(Ip),
+            parse_options(Rest, State#{ip => IpTuple})
+    end;
 parse_options([{socket_opts, L} | Rest], State) when is_list(L), length(L) > 0 ->
-    parse_options(Rest, State#thrift_socket_server{socket_opts=L});
-
+    parse_options(Rest, State#{socket_opts => L});
 parse_options([{handler, []} | _Rest], _State) ->
     throw("At least an error handler must be defined.");
-parse_options([{handler, ServiceHandlerPropertyList} | Rest], State) when is_list(ServiceHandlerPropertyList) ->
+parse_options([{handler, ServiceHandlerPropertyList} | Rest], State) when
+    is_list(ServiceHandlerPropertyList)
+->
     ServiceHandlerMap =
-    case State#thrift_socket_server.handler of
-        undefined ->
-            lists:foldl(
-                fun ({ServiceName, ServiceHandler}, Acc) when is_list(ServiceName), is_atom(ServiceHandler) ->
-                        thrift_multiplexed_map_wrapper:store(ServiceName, ServiceHandler, Acc);
-                    (_, _Acc) ->
-                        throw("The handler option is not properly configured for multiplexed services. It should be a kind of [{\"error_handler\", Module::atom()}, {SericeName::list(), Module::atom()}, ...]")
-                end, thrift_multiplexed_map_wrapper:new(), ServiceHandlerPropertyList);
-        _ -> throw("Error while parsing the handler option.")
-    end,
+        case maps:get(handler, State, undefined) of
+            undefined ->
+                lists:foldl(
+                    fun
+                        ({ServiceName, ServiceHandler}, Acc) when
+                            is_list(ServiceName), is_atom(ServiceHandler)
+                        ->
+                            thrift_multiplexed_map_wrapper:store(ServiceName, ServiceHandler, Acc);
+                        (_, _Acc) ->
+                            throw(
+                                "The handler option is not properly configured for multiplexed services. It should be a kind of [{\"error_handler\", Module::atom()}, {SericeName::list(), Module::atom()}, ...]"
+                            )
+                    end,
+                    thrift_multiplexed_map_wrapper:new(),
+                    ServiceHandlerPropertyList
+                );
+            _ ->
+                throw("Error while parsing the handler option.")
+        end,
     case thrift_multiplexed_map_wrapper:find(?MULTIPLEXED_ERROR_HANDLER_KEY, ServiceHandlerMap) of
-        {ok, _ErrorHandler} -> parse_options(Rest, State#thrift_socket_server{handler=ServiceHandlerMap});
-        error -> throw("The handler option is not properly configured for multiplexed services. It should be a kind of [{\"error_handler\", Module::atom()}, {SericeName::list(), Module::atom()}, ...]")
+        {ok, _ErrorHandler} ->
+            parse_options(Rest, State#{handler => ServiceHandlerMap});
+        error ->
+            throw(
+                "The handler option is not properly configured for multiplexed services. It should be a kind of [{\"error_handler\", Module::atom()}, {SericeName::list(), Module::atom()}, ...]"
+            )
     end;
-parse_options([{handler, Handler} | Rest], State) when State#thrift_socket_server.handler == undefined, is_atom(Handler) ->
-    parse_options(Rest, State#thrift_socket_server{handler=Handler});
-
+parse_options([{handler, Handler} | Rest], State) when
+    not is_map_key(handler, State), is_atom(Handler)
+->
+    parse_options(Rest, State#{handler => Handler});
 parse_options([{service, []} | _Rest], _State) ->
     throw("At least one service module must be defined.");
-parse_options([{service, ServiceModulePropertyList} | Rest], State) when is_list(ServiceModulePropertyList) ->
+parse_options([{service, ServiceModulePropertyList} | Rest], State) when
+    is_list(ServiceModulePropertyList)
+->
     ServiceModuleMap =
-    case State#thrift_socket_server.service of
-        undefined ->
-            lists:foldl(
-                fun ({ServiceName, ServiceModule}, Acc) when is_list(ServiceName), is_atom(ServiceModule) ->
-                        thrift_multiplexed_map_wrapper:store(ServiceName, ServiceModule, Acc);
-                    (_, _Acc) ->
-                        throw("The service option is not properly configured for multiplexed services. It should be a kind of [{SericeName::list(), ServiceModule::atom()}, ...]")
-                end, thrift_multiplexed_map_wrapper:new(), ServiceModulePropertyList);
-        _ -> throw("Error while parsing the service option.")
-    end,
-    parse_options(Rest, State#thrift_socket_server{service=ServiceModuleMap});
-parse_options([{service, Service} | Rest], State) when State#thrift_socket_server.service == undefined, is_atom(Service) ->
-    parse_options(Rest, State#thrift_socket_server{service=Service});
-
-parse_options([{max, Max} | Rest], State) ->
-    MaxInt = case Max of
-                 Max when is_list(Max) ->
-                     list_to_integer(Max);
-                 Max when is_integer(Max) ->
-                     Max
-             end,
-    parse_options(Rest, State#thrift_socket_server{max=MaxInt});
-
+        case maps:get(service, State, undefined) of
+            undefined ->
+                lists:foldl(
+                    fun
+                        ({ServiceName, ServiceModule}, Acc) when
+                            is_list(ServiceName), is_atom(ServiceModule)
+                        ->
+                            thrift_multiplexed_map_wrapper:store(ServiceName, ServiceModule, Acc);
+                        (_, _Acc) ->
+                            throw(
+                                "The service option is not properly configured for multiplexed services. It should be a kind of [{SericeName::list(), ServiceModule::atom()}, ...]"
+                            )
+                    end,
+                    thrift_multiplexed_map_wrapper:new(),
+                    ServiceModulePropertyList
+                );
+            _ ->
+                throw("Error while parsing the service option.")
+        end,
+    parse_options(Rest, State#{service => ServiceModuleMap});
+parse_options([{service, Service} | Rest], State) when
+    not is_map_key(service, State), is_atom(Service)
+->
+    parse_options(Rest, State#{service => Service});
+parse_options([{max, Max} | Rest], State) when is_integer(Max), Max > 0 ->
+    parse_options(Rest, State#{max => Max});
 parse_options([{protocol, Proto} | Rest], State) when is_atom(Proto) ->
-    parse_options(Rest, State#thrift_socket_server{protocol=Proto});
-
+    parse_options(Rest, State#{protocol => Proto});
 parse_options([{framed, Framed} | Rest], State) when is_boolean(Framed) ->
-    parse_options(Rest, State#thrift_socket_server{framed=Framed});
-
+    parse_options(Rest, State#{framed => Framed});
 parse_options([{ssltransport, SSLTransport} | Rest], State) when is_boolean(SSLTransport) ->
-    parse_options(Rest, State#thrift_socket_server{ssltransport=SSLTransport});
+    parse_options(Rest, State#{ssltransport => SSLTransport});
 parse_options([{ssloptions, SSLOptions} | Rest], State) when is_list(SSLOptions) ->
-    parse_options(Rest, State#thrift_socket_server{ssloptions=SSLOptions}).
+    parse_options(Rest, State#{ssloptions => SSLOptions}).
 
-start_server(State=#thrift_socket_server{name=Name}) ->
+start_server(Options = #{name := Name}) ->
     case Name of
         undefined ->
-            gen_server:start_link(?MODULE, State, []);
+            gen_server:start_link(?MODULE, Options, []);
         _ ->
-            gen_server:start_link(Name, ?MODULE, State, [])
+            gen_server:start_link(Name, ?MODULE, Options, [])
     end.
 
-init(State=#thrift_socket_server{ip=Ip, port=Port}) ->
+init(State = #{port := Port}) ->
     process_flag(trap_exit, true),
-    BaseOpts = [binary,
-                {reuseaddr, true},
-                {packet, 0},
-                {backlog, 4096},
-                {recbuf, 8192},
-                {active, false}],
-    Opts = case Ip of
-               any ->
-                   BaseOpts;
-               Ip ->
-                   [{ip, Ip} | BaseOpts]
-           end,
-    case gen_tcp_listen(Port, Opts, State) of
-        {stop, eacces} ->
-            %% fdsrv module allows another shot to bind
-            %% ports which require root access
-            case Port < 1024 of
-                true ->
-                    case fdsrv:start() of
-                        {ok, _} ->
-                            case fdsrv:bind_socket(tcp, Port) of
-                                {ok, Fd} ->
-                                    gen_tcp_listen(Port, [{fd, Fd} | Opts], State);
-                                _ ->
-                                    {stop, fdsrv_bind_failed}
-                            end;
-                        _ ->
-                            {stop, fdsrv_start_failed}
-                    end;
-                false ->
-                    {stop, eacces}
-            end;
-        Other ->
-            error_logger:info_msg("thrift service listening on port ~p", [Port]),
-            Other
-    end.
-
-gen_tcp_listen(Port, Opts, State) ->
+    BaseOpts = [
+        binary,
+        {reuseaddr, true},
+        {packet, 0},
+        {backlog, 4096},
+        {recbuf, 8192},
+        {active, false}
+    ],
+    Opts =
+        case maps:get(ip, State, undefined) of
+            undefined ->
+                BaseOpts;
+            Ip ->
+                [{ip, Ip} | BaseOpts]
+        end,
     case gen_tcp:listen(Port, Opts) of
         {ok, Listen} ->
             {ok, ListenPort} = inet:port(Listen),
-            {ok, new_acceptor(State#thrift_socket_server{listen=Listen,
-                                                         port=ListenPort})};
+            {ok,
+                new_acceptor(#thrift_socket_server{
+                    acceptors_left = maps:get(max, State, 2048),
+                    listen = Listen,
+                    port = ListenPort,
+                    service = maps:get(service, State),
+                    handler = maps:get(handler, State),
+                    socket_opts = maps:get(socket_opts, State, [{recv_timeout, 500}]),
+                    framed = maps:get(framed, State, false),
+                    protocol = maps:get(protocol, State, binary),
+                    ssltransport = maps:get(ssltransport, State, false),
+                    ssloptions = maps:get(ssloptions, State, [])
+                })};
         {error, Reason} ->
             {stop, Reason}
     end.
 
-new_acceptor(State=#thrift_socket_server{max=0}) ->
+new_acceptor(State = #thrift_socket_server{acceptors_left = 0}) ->
     error_logger:error_msg("Not accepting new connections"),
-    State#thrift_socket_server{acceptor=null};
-new_acceptor(State=#thrift_socket_server{listen=Listen,
-                                         service=Service, handler=Handler,
-                                         socket_opts=Opts, framed=Framed, protocol=Proto,
-                                         ssltransport=SslTransport, ssloptions=SslOptions
-                                        }) ->
-    Pid = proc_lib:spawn_link(?MODULE, acceptor_loop,
-                              [{self(), Listen, Service, Handler, Opts, Framed, SslTransport, SslOptions, Proto}]),
-    State#thrift_socket_server{acceptor=Pid}.
+    State#thrift_socket_server{acceptor = undefined};
+new_acceptor(
+    State = #thrift_socket_server{
+        listen = Listen,
+        service = Service,
+        handler = Handler,
+        socket_opts = Opts,
+        framed = Framed,
+        protocol = Proto,
+        ssltransport = SslTransport,
+        ssloptions = SslOptions
+    }
+) ->
+    Pid = proc_lib:spawn_link(
+        ?MODULE,
+        acceptor_loop,
+        [{self(), Listen, Service, Handler, Opts, Framed, SslTransport, SslOptions, Proto}]
+    ),
+    State#thrift_socket_server{acceptor = Pid}.
 
-acceptor_loop({Server, Listen, Service, Handler, SocketOpts, Framed, SslTransport, SslOptions, Proto})
-  when is_pid(Server), is_list(SocketOpts) ->
-    case catch gen_tcp:accept(Listen) of % infinite timeout
+acceptor_loop(
+    {Server, Listen, Service, Handler, SocketOpts, Framed, SslTransport, SslOptions, Proto}
+) when
+    is_pid(Server), is_list(SocketOpts)
+->
+    % infinite timeout
+    case catch gen_tcp:accept(Listen) of
         {ok, Socket} ->
             gen_server:cast(Server, {accepted, self()}),
             ProtoGen = fun() ->
-                               {ok, SocketTransport} = case SslTransport of
-                                                           true  -> thrift_sslsocket_transport:new(Socket, SocketOpts, SslOptions);
-                                                           false -> thrift_socket_transport:new(Socket, SocketOpts)
-                                                       end,
-                               {ok, Transport}       = case Framed of
-                                                           true  -> thrift_framed_transport:new(SocketTransport);
-                                                           false -> thrift_buffered_transport:new(SocketTransport)
-                                                       end,
-                               {ok, Protocol}        = case Proto of
-                                                         compact -> thrift_compact_protocol:new(Transport);
-                                                         json -> thrift_json_protocol:new(Transport);
-                                                         _ -> thrift_binary_protocol:new(Transport)
-                                                       end,
-                               {ok, Protocol}
-                       end,
+                {ok, SocketTransport} =
+                    case SslTransport of
+                        true -> thrift_sslsocket_transport:new(Socket, SocketOpts, SslOptions);
+                        false -> thrift_socket_transport:new(Socket, SocketOpts)
+                    end,
+                {ok, Transport} =
+                    case Framed of
+                        true -> thrift_framed_transport:new(SocketTransport);
+                        false -> thrift_buffered_transport:new(SocketTransport)
+                    end,
+                {ok, Protocol} =
+                    case Proto of
+                        compact ->
+                            thrift_compact_protocol:new(Transport);
+                        {compact, Options} ->
+                            thrift_compact_protocol:new(Transport, Options);
+                        json ->
+                            thrift_json_protocol:new(Transport);
+                        {json, Options} ->
+                            thrift_json_protocol:new(Transport, Options);
+                        binary ->
+                            thrift_binary_protocol:new(Transport);
+                        {binary, Options} ->
+                            thrift_binary_protocol:new(Transport, Options);
+                        {custom, Module, Options} ->
+                            case erlang:function_exported(Module, new, 2) of
+                                true -> Module:new(Transport, Options);
+                                false -> throw("Could not instantiate custom protocol")
+                            end
+                    end,
+                {ok, Protocol}
+            end,
             thrift_processor:init({Server, ProtoGen, Service, Handler});
         {error, closed} ->
             exit({error, closed});
         Other ->
             error_logger:error_report(
-              [{application, thrift},
-               "Accept failed error",
-               lists:flatten(io_lib:format("~p", [Other]))]),
+                [
+                    {application, thrift},
+                    "Accept failed error",
+                    lists:flatten(io_lib:format("~p", [Other]))
+                ]
+            ),
             exit({error, accept_failed})
     end.
 
-handle_call({get, port}, _From, State=#thrift_socket_server{port=Port}) ->
+handle_call({get, port}, _From, State = #thrift_socket_server{port = Port}) ->
     {reply, Port, State};
 handle_call(_Message, _From, State) ->
     Res = error,
     {reply, Res, State}.
 
-handle_cast({accepted, Pid},
-            State=#thrift_socket_server{acceptor=Pid, max=Max}) ->
+handle_cast(
+    {accepted, Pid},
+    State = #thrift_socket_server{acceptor = Pid, acceptors_left = Max}
+) ->
     % io:format("accepted ~p~n", [Pid]),
-    State1 = State#thrift_socket_server{max=Max - 1},
+    State1 = State#thrift_socket_server{acceptors_left = Max - 1},
     {noreply, new_acceptor(State1)};
 handle_cast(stop, State) ->
     {stop, normal, State}.
 
-terminate(Reason, #thrift_socket_server{listen=Listen, port=Port}) ->
+terminate(Reason, #thrift_socket_server{listen = Listen}) ->
     gen_tcp:close(Listen),
     case Reason of
-        normal -> ok;
-        shutdown -> ok;
-        _ -> {backtrace, Bt} = erlang:process_info(self(), backtrace),
-             error_logger:error_report({?MODULE, ?LINE,
-                                       {child_error, Reason, Bt}})
-    end,
-    case Port < 1024 of
-        true ->
-            catch fdsrv:stop(),
+        normal ->
             ok;
-        false ->
-            ok
+        shutdown ->
+            ok;
+        _ ->
+            {backtrace, Bt} = erlang:process_info(self(), backtrace),
+            error_logger:error_report({?MODULE, ?LINE, {child_error, Reason, Bt}})
     end.
 
 code_change(_OldVsn, State, _Extra) ->
     State.
 
-handle_info({'EXIT', Pid, normal},
-            State=#thrift_socket_server{acceptor=Pid}) ->
+handle_info(
+    {'EXIT', Pid, normal},
+    State = #thrift_socket_server{acceptor = Pid}
+) ->
     {noreply, new_acceptor(State)};
-handle_info({'EXIT', Pid, Reason},
-            State=#thrift_socket_server{acceptor=Pid}) ->
-    error_logger:error_report({?MODULE, ?LINE,
-                               {acceptor_error, Reason}}),
+handle_info(
+    {'EXIT', Pid, Reason},
+    State = #thrift_socket_server{acceptor = Pid}
+) ->
+    error_logger:error_report({?MODULE, ?LINE, {acceptor_error, Reason}}),
     timer:sleep(100),
     {noreply, new_acceptor(State)};
-handle_info({'EXIT', _LoopPid, Reason},
-            State=#thrift_socket_server{acceptor=Pid, max=Max}) ->
+handle_info(
+    {'EXIT', _LoopPid, Reason},
+    State = #thrift_socket_server{acceptor = Pid, acceptors_left = AcceptorsLeft}
+) ->
     case Reason of
         normal -> ok;
         shutdown -> ok;
-        _ -> error_logger:error_report({?MODULE, ?LINE,
-                                        {child_error, Reason, erlang:get_stacktrace()}})
+        _ -> error_logger:error_report({?MODULE, ?LINE, {child_error, Reason}})
     end,
-    State1 = State#thrift_socket_server{max=Max + 1},
-    State2 = case Pid of
-                 null -> new_acceptor(State1);
-                 _ -> State1
-             end,
+    State1 = State#thrift_socket_server{acceptors_left = AcceptorsLeft + 1},
+    State2 =
+        case Pid of
+            undefined -> new_acceptor(State1);
+            _ -> State1
+        end,
     {noreply, State2};
 handle_info(Info, State) ->
     error_logger:info_report([{'INFO', Info}, {'State', State}]),
diff --git a/lib/erl/src/thrift_socket_transport.erl b/lib/erl/src/thrift_socket_transport.erl
index fe210da..a5b68e1 100644
--- a/lib/erl/src/thrift_socket_transport.erl
+++ b/lib/erl/src/thrift_socket_transport.erl
@@ -28,113 +28,89 @@
 %% legacy api
 -export([new_transport_factory/3]).
 
-
 -record(t_socket, {
-  socket,
-  recv_timeout=60000,
-  buffer = []
+    socket :: gen_tcp:socket(),
+    recv_timeout = 60000 :: timeout(),
+    buffer = [] :: iodata()
 }).
 
--type state() :: #t_socket{}.
-
-
--spec new(Socket::any()) ->
-  thrift_transport:t_transport().
+-spec new(Socket :: any()) -> {ok, thrift_transport:t_transport()}.
 
 new(Socket) -> new(Socket, []).
 
--spec new(Socket::any(), Opts::list()) ->
-  thrift_transport:t_transport().
+-spec new(Socket :: any(), Opts :: list()) -> {ok, thrift_transport:t_transport()}.
 
 new(Socket, Opts) when is_list(Opts) ->
-  State = parse_opts(Opts, #t_socket{socket = Socket}),
-  thrift_transport:new(?MODULE, State).
+    State = parse_opts(Opts, #t_socket{socket = Socket}),
+    thrift_transport:new(?MODULE, State).
 
-
-parse_opts([{recv_timeout, Timeout}|Rest], State)
-when is_integer(Timeout), Timeout > 0 ->
-  parse_opts(Rest, State#t_socket{recv_timeout = Timeout});
-parse_opts([{recv_timeout, infinity}|Rest], State) ->
-  parse_opts(Rest, State#t_socket{recv_timeout = infinity});
+parse_opts([{recv_timeout, Timeout} | Rest], State) when
+    is_integer(Timeout), Timeout > 0
+->
+    parse_opts(Rest, State#t_socket{recv_timeout = Timeout});
+parse_opts([{recv_timeout, infinity} | Rest], State) ->
+    parse_opts(Rest, State#t_socket{recv_timeout = infinity});
 parse_opts([], State) ->
-  State.
+    State.
 
+read(State = #t_socket{buffer = Buf}, Len) when
+    is_integer(Len), Len >= 0
+->
+    Binary = iolist_to_binary(Buf),
+    case iolist_size(Binary) of
+        X when X >= Len ->
+            {Result, Remaining} = split_binary(Binary, Len),
+            {State#t_socket{buffer = Remaining}, {ok, Result}};
+        _ ->
+            loop_recv(State, Len, Len)
+    end.
 
--include("thrift_transport_behaviour.hrl").
-
-
-read(State = #t_socket{buffer = Buf}, Len)
-when is_integer(Len), Len >= 0 ->
-  Binary = iolist_to_binary(Buf),
-  case iolist_size(Binary) of
-    X when X >= Len ->
-      {Result, Remaining} = split_binary(Binary, Len),
-      {State#t_socket{buffer = Remaining}, {ok, Result}};
-    _ ->
-     %%recv(State, Len)
-     loop_recv(State,Len,Len)
-  end.
-
-loop_recv(State=#t_socket{buffer = Buf},ReadLen,NextReadLen) when NextReadLen =< 0->
-  {Result,Remaining}=split_binary(Buf,ReadLen),
-  {State#t_socket{buffer = Remaining},{ok,Result}};
-
-loop_recv(State=#t_socket{socket = Socket,buffer = Buf},ReadLen,NextReadLen) when NextReadLen >0 ->
-  case gen_tcp:recv(Socket,0,State#t_socket.recv_timeout) of
-    {error,Error}->
-      gen_tcp:close(Socket),
-      {State,{error,Error}};
-    {ok,Data}->
-      Binary=iolist_to_binary([Buf,Data]),
-      Give=min(iolist_size(Binary),ReadLen),
-      loop_recv(State#t_socket{buffer = Binary},ReadLen,ReadLen-Give)
-  end.
-
-recv(State = #t_socket{socket = Socket, buffer = Buf}, Len) ->
-  case gen_tcp:recv(Socket, 0, State#t_socket.recv_timeout) of
-    {error, Error} ->
-      gen_tcp:close(Socket),
-      {State, {error, Error}};
-    {ok, Data} ->
-      Binary = iolist_to_binary([Buf, Data]),
-      Give = min(iolist_size(Binary), Len),
-      {Result, Remaining} = split_binary(Binary, Give),
-      {State#t_socket{buffer = Remaining}, {ok, Result}}
-  end.
-
-
-read_exact(State = #t_socket{buffer = Buf}, Len)
-when is_integer(Len), Len >= 0 ->
-  Binary = iolist_to_binary(Buf),
-  case iolist_size(Binary) of
-    X when X >= Len -> read(State, Len);
-    X ->
-      case gen_tcp:recv(State#t_socket.socket, Len - X, State#t_socket.recv_timeout) of
+loop_recv(State = #t_socket{buffer = Buf}, ReadLen, NextReadLen) when NextReadLen =< 0 ->
+    {Result, Remaining} = split_binary(Buf, ReadLen),
+    {State#t_socket{buffer = Remaining}, {ok, Result}};
+loop_recv(State = #t_socket{socket = Socket, buffer = Buf}, ReadLen, NextReadLen) when
+    NextReadLen > 0
+->
+    case gen_tcp:recv(Socket, 0, State#t_socket.recv_timeout) of
         {error, Error} ->
-          gen_tcp:close(State#t_socket.socket),
-          {State, {error, Error}};
+            gen_tcp:close(Socket),
+            {State, {error, Error}};
         {ok, Data} ->
-          {State#t_socket{buffer = []}, {ok, <<Binary/binary, Data/binary>>}}
-      end
-  end.
+            Binary = iolist_to_binary([Buf, Data]),
+            Give = min(iolist_size(Binary), ReadLen),
+            loop_recv(State#t_socket{buffer = Binary}, ReadLen, ReadLen - Give)
+    end.
 
+read_exact(State = #t_socket{buffer = Buf}, Len) when
+    is_integer(Len), Len >= 0
+->
+    Binary = iolist_to_binary(Buf),
+    case iolist_size(Binary) of
+        X when X >= Len -> read(State, Len);
+        X ->
+            case gen_tcp:recv(State#t_socket.socket, Len - X, State#t_socket.recv_timeout) of
+                {error, Error} ->
+                    gen_tcp:close(State#t_socket.socket),
+                    {State, {error, Error}};
+                {ok, Data} ->
+                    {State#t_socket{buffer = []}, {ok, <<Binary/binary, Data/binary>>}}
+            end
+    end.
 
 write(State = #t_socket{socket = Socket}, Data) ->
-  case gen_tcp:send(Socket, Data) of
-    {error, Error} ->
-      gen_tcp:close(Socket),
-      {State, {error, Error}};
-    ok -> {State, ok}
-  end.
-
+    case gen_tcp:send(Socket, Data) of
+        {error, Error} ->
+            gen_tcp:close(Socket),
+            {State, {error, Error}};
+        ok ->
+            {State, ok}
+    end.
 
 flush(State) ->
-  {State#t_socket{buffer = []}, ok}.
-
+    {State#t_socket{buffer = []}, ok}.
 
 close(State = #t_socket{socket = Socket}) ->
-  {State, gen_tcp:close(Socket)}.
-
+    {State, gen_tcp:close(Socket)}.
 
 %% legacy api. left for compatibility
 
@@ -143,51 +119,61 @@
 %% proplists-style option list. They're parsed like this so it is an O(n)
 %% operation instead of O(n^2)
 -record(factory_opts, {
-  connect_timeout = infinity,
-  sockopts = [],
-  framed = false
+    connect_timeout = infinity :: timeout(),
+    sockopts = [] :: [inet:inet_backend() | gen_tcp:connect_option()],
+    framed = false :: boolean()
 }).
 
-parse_factory_options([], FactoryOpts, TransOpts) -> {FactoryOpts, TransOpts};
-parse_factory_options([{framed, Bool}|Rest], FactoryOpts, TransOpts)
-when is_boolean(Bool) ->
-  parse_factory_options(Rest, FactoryOpts#factory_opts{framed = Bool}, TransOpts);
-parse_factory_options([{sockopts, OptList}|Rest], FactoryOpts, TransOpts)
-when is_list(OptList) ->
-  parse_factory_options(Rest, FactoryOpts#factory_opts{sockopts = OptList}, TransOpts);
-parse_factory_options([{connect_timeout, TO}|Rest], FactoryOpts, TransOpts)
-when TO =:= infinity; is_integer(TO) ->
-  parse_factory_options(Rest, FactoryOpts#factory_opts{connect_timeout = TO}, TransOpts);
-parse_factory_options([{recv_timeout, TO}|Rest], FactoryOpts, TransOpts)
-when TO =:= infinity; is_integer(TO) ->
-  parse_factory_options(Rest, FactoryOpts, [{recv_timeout, TO}] ++ TransOpts).
-
+parse_factory_options([], FactoryOpts, TransOpts) ->
+    {FactoryOpts, TransOpts};
+parse_factory_options([{framed, Bool} | Rest], FactoryOpts, TransOpts) when
+    is_boolean(Bool)
+->
+    parse_factory_options(Rest, FactoryOpts#factory_opts{framed = Bool}, TransOpts);
+parse_factory_options([{sockopts, OptList} | Rest], FactoryOpts, TransOpts) when
+    is_list(OptList)
+->
+    parse_factory_options(Rest, FactoryOpts#factory_opts{sockopts = OptList}, TransOpts);
+parse_factory_options([{connect_timeout, TO} | Rest], FactoryOpts, TransOpts) when
+    TO =:= infinity; is_integer(TO)
+->
+    parse_factory_options(Rest, FactoryOpts#factory_opts{connect_timeout = TO}, TransOpts);
+parse_factory_options([{recv_timeout, TO} | Rest], FactoryOpts, TransOpts) when
+    TO =:= infinity; is_integer(TO)
+->
+    parse_factory_options(Rest, FactoryOpts, [{recv_timeout, TO}] ++ TransOpts).
 
 %% Generates a "transport factory" function - a fun which returns a thrift_transport()
 %% instance.
 %% State can be passed into a protocol factory to generate a connection to a
 %% thrift server over a socket.
 new_transport_factory(Host, Port, Options) ->
-  {FactoryOpts, TransOpts} = parse_factory_options(Options, #factory_opts{}, []),
-  {ok, fun() -> SockOpts = [binary,
-      {packet, 0},
-      {active, false},
-      {nodelay, true}|FactoryOpts#factory_opts.sockopts
-    ],
-    case catch gen_tcp:connect(
-      Host,
-      Port,
-      SockOpts,
-      FactoryOpts#factory_opts.connect_timeout
-    ) of
-      {ok, Sock} ->
-        {ok, Transport} = thrift_socket_transport:new(Sock, TransOpts),
-        {ok, BufTransport} = case FactoryOpts#factory_opts.framed of
-          true  -> thrift_framed_transport:new(Transport);
-          false -> thrift_buffered_transport:new(Transport)
-        end,
-        {ok, BufTransport};
-      Error  -> Error
-    end
-  end}.
-
+    {FactoryOpts, TransOpts} = parse_factory_options(Options, #factory_opts{}, []),
+    {ok, fun() ->
+        SockOpts = [
+            binary,
+            {packet, 0},
+            {active, false},
+            {nodelay, true}
+            | FactoryOpts#factory_opts.sockopts
+        ],
+        case
+            catch gen_tcp:connect(
+                Host,
+                Port,
+                SockOpts,
+                FactoryOpts#factory_opts.connect_timeout
+            )
+        of
+            {ok, Sock} ->
+                {ok, Transport} = thrift_socket_transport:new(Sock, TransOpts),
+                {ok, BufTransport} =
+                    case FactoryOpts#factory_opts.framed of
+                        true -> thrift_framed_transport:new(Transport);
+                        false -> thrift_buffered_transport:new(Transport)
+                    end,
+                {ok, BufTransport};
+            Error ->
+                Error
+        end
+    end}.
diff --git a/lib/erl/src/thrift_sslsocket_transport.erl b/lib/erl/src/thrift_sslsocket_transport.erl
index 211153f..43e64b1 100644
--- a/lib/erl/src/thrift_sslsocket_transport.erl
+++ b/lib/erl/src/thrift_sslsocket_transport.erl
@@ -18,80 +18,97 @@
 %%
 -module(thrift_sslsocket_transport).
 
--include("thrift_transport_behaviour.hrl").
-
 -behaviour(thrift_transport).
 
--export([new/3,
-         write/2, read/2, flush/1, close/1,
+-export([
+    new/3,
+    write/2,
+    read/2,
+    flush/1,
+    close/1,
 
-         new_transport_factory/3]).
+    new_transport_factory/3
+]).
 
 %% Export only for the transport factory
 -export([new/2]).
 
--record(data, {socket,
-               recv_timeout=infinity}).
--type state() :: #data{}.
+-record(data, {
+    socket :: ssl:sslsocket(),
+    recv_timeout = infinity :: infinity | timeout()
+}).
+
+-type data() :: #data{}.
+-type reason() :: thrift_transport:reason().
 
 %% The following "local" record is filled in by parse_factory_options/2
 %% below. These options can be passed to new_protocol_factory/3 in a
 %% proplists-style option list. They're parsed like this so it is an O(n)
 %% operation instead of O(n^2)
--record(factory_opts, {connect_timeout = infinity,
-                       sockopts = [],
-                       framed = false,
-                       ssloptions = []}).
+-record(factory_opts, {
+    connect_timeout = infinity :: infinity | timeout(),
+    sockopts = [] :: [inet:inet_backend() | gen_tcp:connect_option()],
+    framed = false :: boolean(),
+    ssloptions = [] :: [ssl:tls_client_option()]
+}).
 
 parse_factory_options([], Opts) ->
     Opts;
 parse_factory_options([{framed, Bool} | Rest], Opts) when is_boolean(Bool) ->
-    parse_factory_options(Rest, Opts#factory_opts{framed=Bool});
+    parse_factory_options(Rest, Opts#factory_opts{framed = Bool});
 parse_factory_options([{sockopts, OptList} | Rest], Opts) when is_list(OptList) ->
-    parse_factory_options(Rest, Opts#factory_opts{sockopts=OptList});
+    parse_factory_options(Rest, Opts#factory_opts{sockopts = OptList});
 parse_factory_options([{connect_timeout, TO} | Rest], Opts) when TO =:= infinity; is_integer(TO) ->
-    parse_factory_options(Rest, Opts#factory_opts{connect_timeout=TO});
+    parse_factory_options(Rest, Opts#factory_opts{connect_timeout = TO});
 parse_factory_options([{ssloptions, SslOptions} | Rest], Opts) when is_list(SslOptions) ->
-    parse_factory_options(Rest, Opts#factory_opts{ssloptions=SslOptions}).
+    parse_factory_options(Rest, Opts#factory_opts{ssloptions = SslOptions}).
 
 new(Socket, SockOpts, SslOptions) when is_list(SockOpts), is_list(SslOptions) ->
-    inet:setopts(Socket, [{active, false}]), %% => prevent the ssl handshake messages get lost
+    %% => prevent the ssl handshake messages get lost
+    ok = inet:setopts(Socket, [{active, false}]),
 
     %% upgrade to an ssl socket
-    case catch ssl:ssl_accept(Socket, SslOptions) of % infinite timeout
+
+    % infinite timeout
+    case catch ssl:handshake(Socket, SslOptions) of
         {ok, SslSocket} ->
             new(SslSocket, SockOpts);
         {error, Reason} ->
             exit({error, Reason});
         Other ->
             error_logger:error_report(
-              [{application, thrift},
-               "SSL accept failed error",
-               lists:flatten(io_lib:format("~p", [Other]))]),
+                [
+                    {application, thrift},
+                    "SSL accept failed error",
+                    lists:flatten(io_lib:format("~p", [Other]))
+                ]
+            ),
             exit({error, ssl_accept_failed})
     end.
 
 new(SslSocket, SockOpts) ->
     State =
         case lists:keysearch(recv_timeout, 1, SockOpts) of
-            {value, {recv_timeout, Timeout}}
-              when is_integer(Timeout), Timeout > 0 ->
-                #data{socket=SslSocket, recv_timeout=Timeout};
+            {value, {recv_timeout, Timeout}} when
+                is_integer(Timeout), Timeout > 0
+            ->
+                #data{socket = SslSocket, recv_timeout = Timeout};
             _ ->
-                #data{socket=SslSocket}
+                #data{socket = SslSocket}
         end,
     thrift_transport:new(?MODULE, State).
 
 %% Data :: iolist()
+-spec write(data(), iolist()) -> {data(), ok | {error, reason()}}.
 write(This = #data{socket = Socket}, Data) ->
     {This, ssl:send(Socket, Data)}.
 
-read(This = #data{socket=Socket, recv_timeout=Timeout}, Len)
-  when is_integer(Len), Len >= 0 ->
+read(This = #data{socket = Socket, recv_timeout = Timeout}, Len) when
+    is_integer(Len), Len >= 0
+->
     case ssl:recv(Socket, Len, Timeout) of
         Err = {error, timeout} ->
-            error_logger:info_msg("read timeout: peer conn ~p", [inet:peername(Socket)]),
-            ssl:close(Socket),
+            ok = ssl:close(Socket),
             {This, Err};
         Data ->
             {This, Data}
@@ -116,32 +133,48 @@
     ParsedOpts = parse_factory_options(Options, #factory_opts{}),
 
     F = fun() ->
-                SockOpts = [binary,
-                            {packet, 0},
-                            {active, false},
-                            {nodelay, true} |
-                            ParsedOpts#factory_opts.sockopts],
-                case catch gen_tcp:connect(Host, Port, SockOpts,
-                                           ParsedOpts#factory_opts.connect_timeout) of
-                    {ok, Sock} ->
-                        SslSock = case catch ssl:connect(Sock, ParsedOpts#factory_opts.ssloptions,
-                                                         ParsedOpts#factory_opts.connect_timeout) of
-                                      {ok, SslSocket} ->
-                                          SslSocket;
-                                      Other ->
-                                          error_logger:info_msg("error while connecting over ssl - reason: ~p~n", [Other]),
-                                          catch gen_tcp:close(Sock),
-                                          exit(error)
-                                  end,
-                        {ok, Transport} = thrift_sslsocket_transport:new(SslSock, SockOpts),
-                        {ok, BufTransport} =
-                            case ParsedOpts#factory_opts.framed of
-                                true  -> thrift_framed_transport:new(Transport);
-                                false -> thrift_buffered_transport:new(Transport)
-                            end,
-                        {ok, BufTransport};
-                    Error  ->
-                        Error
-                end
-        end,
-    {ok, F}.
\ No newline at end of file
+        SockOpts = [
+            binary,
+            {packet, 0},
+            {active, false},
+            {nodelay, true}
+            | ParsedOpts#factory_opts.sockopts
+        ],
+        case
+            catch gen_tcp:connect(
+                Host,
+                Port,
+                SockOpts,
+                ParsedOpts#factory_opts.connect_timeout
+            )
+        of
+            {ok, Sock} ->
+                SslSock =
+                    case
+                        catch ssl:connect(
+                            Sock,
+                            ParsedOpts#factory_opts.ssloptions,
+                            ParsedOpts#factory_opts.connect_timeout
+                        )
+                    of
+                        {ok, SslSocket} ->
+                            SslSocket;
+                        Other ->
+                            error_logger:info_msg(
+                                "error while connecting over ssl - reason: ~p~n", [Other]
+                            ),
+                            catch gen_tcp:close(Sock),
+                            exit(error)
+                    end,
+                {ok, Transport} = thrift_sslsocket_transport:new(SslSock, SockOpts),
+                {ok, BufTransport} =
+                    case ParsedOpts#factory_opts.framed of
+                        true -> thrift_framed_transport:new(Transport);
+                        false -> thrift_buffered_transport:new(Transport)
+                    end,
+                {ok, BufTransport};
+            Error ->
+                Error
+        end
+    end,
+    {ok, F}.
diff --git a/lib/erl/src/thrift_transport.erl b/lib/erl/src/thrift_transport.erl
index 2414bde..cc9ca1b 100644
--- a/lib/erl/src/thrift_transport.erl
+++ b/lib/erl/src/thrift_transport.erl
@@ -19,108 +19,105 @@
 
 -module(thrift_transport).
 
--export([behaviour_info/1]).
 %% constructors
 -export([new/1, new/2]).
 %% transport callbacks
 -export([read/2, read_exact/2, write/2, flush/1, close/1]).
 
+-record(t_transport, {
+    module :: module(),
+    state :: term()
+}).
+-type t_transport() :: #t_transport{}.
 -export_type([t_transport/0]).
 
+%%%=========================================================================
+%%%  API
+%%%=========================================================================
+-type state() :: term().
+-export_type([state/0]).
+-type reason() :: term().
+-export_type([reason/0]).
 
-behaviour_info(callbacks) ->
-  [{read, 2}, {write, 2}, {flush, 1}, {close, 1}].
-
-
--record(t_transport, {
-  module,
-  state
-}).
-
--type state() :: #t_transport{}.
--type t_transport() :: #t_transport{}.
-
+-callback write(state(), iolist() | binary()) -> {state(), ok | {error, reason()}}.
+-callback read(state(), non_neg_integer()) -> {state(), {ok, binary()} | {error, reason()}}.
+-callback flush(state()) -> {state(), ok | {error, reason()}}.
+-callback close(state()) -> {state(), ok | {error, reason()}}.
 
 -ifdef(transport_wrapper_module).
 -define(debug_wrap(Transport),
-  case Transport#t_transport.module of
-    ?transport_wrapper_module -> Transport;
-    _Else ->
-      {ok, Result} = ?transport_wrapper_module:new(Transport),
-      Result
-  end
+    case Transport#t_transport.module of
+        ?transport_wrapper_module ->
+            Transport;
+        _Else ->
+            {ok, Result} = ?transport_wrapper_module:new(Transport),
+            Result
+    end
 ).
 -else.
 -define(debug_wrap(Transport), Transport).
 -endif.
 
-
 -type wrappable() ::
-  binary() |
-  list() |
-  {membuffer, binary() | list()} |
-  {tcp, port()} |
-  {tcp, port(), list()} |
-  {file, file:io_device()} |
-  {file, file:io_device(), list()} |
-  {file, file:filename()} |
-  {file, file:filename(), list()}.
+    binary()
+    | list()
+    | {membuffer, binary() | list()}
+    | {membuffer, binary() | list(), list()}
+    | {tcp, port()}
+    | {tcp, port(), list()}
+    | {file, file:io_device()}
+    | {file, file:io_device(), list()}
+    | {file, file:filename()}
+    | {file, file:filename(), list()}.
 
 -spec new(wrappable()) -> {ok, #t_transport{}}.
 
-new({membuffer, Membuffer}) when is_binary(Membuffer); is_list(Membuffer) ->
-  thrift_membuffer_transport:new(Membuffer);
-new({membuffer, Membuffer, []}) when is_binary(Membuffer); is_list(Membuffer) ->
-  thrift_membuffer_transport:new(Membuffer);
+new({membuffer, Membuffer}) ->
+    new({membuffer, Membuffer, []});
+new({membuffer, Membuffer, Opts}) when is_binary(Membuffer); is_list(Membuffer) ->
+    thrift_membuffer_transport:new(Membuffer, Opts);
 new({tcp, Socket}) when is_port(Socket) ->
-  new({tcp, Socket, []});
+    new({tcp, Socket, []});
 new({tcp, Socket, Opts}) when is_port(Socket) ->
-  thrift_socket_transport:new(Socket, Opts);
+    thrift_socket_transport:new(Socket, Opts);
 new({file, Filename}) when is_list(Filename); is_binary(Filename) ->
-  new({file, Filename, []});
+    new({file, Filename, []});
 new({file, Filename, Opts}) when is_list(Filename); is_binary(Filename) ->
-  {ok, File} = file:open(Filename, [raw, binary]),
-  new({file, File, Opts});
+    {ok, File} = file:open(Filename, [raw, binary]),
+    new({file, File, Opts});
 new({file, File, Opts}) ->
-  thrift_file_transport:new(File, Opts).
+    thrift_file_transport:new(File, Opts).
 
--spec new(Module::module(), State::any()) -> {ok, #t_transport{}}.
+-spec new(Module :: module(), State :: any()) -> {ok, t_transport()}.
 
 new(Module, State) when is_atom(Module) ->
-  {ok, ?debug_wrap(#t_transport{module = Module, state = State})}.
+    {ok, ?debug_wrap(#t_transport{module = Module, state = State})}.
 
+read(Transport = #t_transport{module = Module}, Len) when
+    is_integer(Len), Len >= 0
+->
+    {NewState, Result} = Module:read(Transport#t_transport.state, Len),
+    {Transport#t_transport{state = NewState}, Result}.
 
--include("thrift_transport_behaviour.hrl").
-
-
-read(Transport = #t_transport{module = Module}, Len)
-when is_integer(Len), Len >= 0 ->
-  {NewState, Result} = Module:read(Transport#t_transport.state, Len),
-  {Transport#t_transport{state = NewState}, Result}.
-
-
-read_exact(Transport = #t_transport{module = Module}, Len)
-when is_integer(Len), Len >= 0 ->
-  case lists:keyfind(read_exact, 1, Module:module_info(exports)) of
-    {read_exact, 2} ->
-      {NewState, Result} = Module:read_exact(Transport#t_transport.state, Len),
-      {Transport#t_transport{state = NewState}, Result};
-    _ ->
-      read(Transport, Len)
-  end.
-
+read_exact(Transport = #t_transport{module = Module}, Len) when
+    is_integer(Len), Len >= 0
+->
+    case lists:keyfind(read_exact, 1, Module:module_info(exports)) of
+        {read_exact, 2} ->
+            {NewState, Result} = Module:read_exact(Transport#t_transport.state, Len),
+            {Transport#t_transport{state = NewState}, Result};
+        _ ->
+            read(Transport, Len)
+    end.
 
 write(Transport = #t_transport{module = Module}, Data) ->
-  {NewState, Result} = Module:write(Transport#t_transport.state, Data),
-  {Transport#t_transport{state = NewState}, Result}.
-
+    {NewState, Result} = Module:write(Transport#t_transport.state, Data),
+    {Transport#t_transport{state = NewState}, Result}.
 
 flush(Transport = #t_transport{module = Module}) ->
-  {NewState, Result} = Module:flush(Transport#t_transport.state),
-  {Transport#t_transport{state = NewState}, Result}.
-
+    {NewState, Result} = Module:flush(Transport#t_transport.state),
+    {Transport#t_transport{state = NewState}, Result}.
 
 close(Transport = #t_transport{module = Module}) ->
-  {NewState, Result} = Module:close(Transport#t_transport.state),
-  {Transport#t_transport{state = NewState}, Result}.
-
+    {NewState, Result} = Module:close(Transport#t_transport.state),
+    {Transport#t_transport{state = NewState}, Result}.
diff --git a/lib/erl/src/thrift_transport_state_test.erl b/lib/erl/src/thrift_transport_state_test.erl
index e83a44d..99b5649 100644
--- a/lib/erl/src/thrift_transport_state_test.erl
+++ b/lib/erl/src/thrift_transport_state_test.erl
@@ -26,28 +26,35 @@
 -export([new/1]).
 
 %% gen_server callbacks
--export([init/1, handle_call/3, handle_cast/2, handle_info/2,
-         terminate/2, code_change/3]).
+-export([
+    init/1,
+    handle_call/3,
+    handle_cast/2,
+    handle_info/2,
+    terminate/2,
+    code_change/3
+]).
 
 %% thrift_transport callbacks
 -export([write/2, read/2, flush/1, close/1]).
 
--record(trans, {wrapped, % #thrift_transport{}
-                version :: integer(),
-                counter :: pid()
-               }).
--type state() :: #trans{}.
--include("thrift_transport_behaviour.hrl").
+% #thrift_transport{}
+-record(trans, {
+    wrapped :: thrift_transport:t_transport(),
+    version :: integer(),
+    counter :: pid()
+}).
 
 -record(state, {cversion :: integer()}).
 
-
 new(WrappedTransport) ->
     case gen_server:start_link(?MODULE, [], []) of
         {ok, Pid} ->
-            Trans = #trans{wrapped = WrappedTransport,
-                           version = 0,
-                           counter = Pid},
+            Trans = #trans{
+                wrapped = WrappedTransport,
+                version = 0,
+                counter = Pid
+            },
             thrift_transport:new(?MODULE, Trans);
         Else ->
             Else
@@ -82,7 +89,6 @@
     Transport2 = Transport1#trans{wrapped = Wrapped1},
     {Transport2, Result}.
 
-
 %%====================================================================
 %% gen_server callbacks
 %%====================================================================
@@ -91,7 +97,7 @@
     {ok, #state{cversion = 0}}.
 
 handle_call(check_version, _From, State = #state{cversion = Version}) ->
-    {reply, Version, State#state{cversion = Version+1}}.
+    {reply, Version, State#state{cversion = Version + 1}}.
 
 handle_cast(shutdown, State) ->
     {stop, normal, State}.
@@ -107,7 +113,7 @@
 check_version(Transport = #trans{version = Version, counter = Counter}) ->
     case gen_server:call(Counter, check_version) of
         Version ->
-            Transport#trans{version = Version+1};
+            Transport#trans{version = Version + 1};
         _Else ->
             % State wasn't propagated properly.  Die.
             erlang:error(state_not_propagated)