Merge branch 'dev' of super:otp into dev

* 'dev' of super:otp: (166 commits)
  Corrected documentation error and added examples to Users Guide
  In TLS 1.1, failure to properly close a connection no longer requires that a session not be resumed.  This is a change from TLS 1.0 to conform with widespread implementation practice.  Erlang ssl will now in TLS 1.0 conform to the widespread implementation practice instead of the specification to avoid performance issues.
  Add escript to bootstrap/bin
  Remove unused variable warning in inet_res
  Remove unused variable in epmd_port
  Remove compiler warnings in inet_drv
  Add SASL test suite
  Allow same module name in multiple applications if explicitely excluded
  Fix bugs concerning the option report_missing_types
  Fix default encoding in SAX parser.
  re: remove gratuitous "it " in manpage
  Spelling in (backward *compatibility*) comment.
  Improve erl_docgen's support for Dialyzer specs and types
  dialyzer warning on mnesia_tm
  Add documentation text about majority checking
  add mnesia_majority_test suite
  where_to_wlock optimization + change_table_majority/2
  bug in mnesia_tm:needs_majority/2
  optimize sticky_lock maj. check
  check majority for sticky locks
  ...

1 files changed, 78 insertions, 20 deletions

diff --git a/lib/stdlib/src/orddict.erl b/lib/stdlib/src/orddict.erl
index 4e30c9eefd..45d3c84b3e 100644
--- a/lib/stdlib/src/orddict.erl
+++ b/lib/stdlib/src/orddict.erl
@@ -25,9 +25,11 @@
 -export([store/3,append/3,append_list/3,update/3,update/4,update_counter/3]).
 -export([fold/3,map/2,filter/2,merge/3]).
 
+-export_type([orddict/0]).
+
 %%---------------------------------------------------------------------------
 
--type orddict() :: [{term(), term()}].
+-type orddict() :: [{Key :: term(), Value :: term()}].
 
 %%---------------------------------------------------------------------------
 
@@ -35,45 +37,63 @@
 
 new() -> [].
 
--spec is_key(Key::term(), Dictionary::orddict()) -> boolean().
+-spec is_key(Key, Orddict) -> boolean() when
+      Key :: term(),
+      Orddict :: orddict().
 
 is_key(Key, [{K,_}|_]) when Key < K -> false;
 is_key(Key, [{K,_}|Dict]) when Key > K -> is_key(Key, Dict);
 is_key(_Key, [{_K,_Val}|_]) -> true;		%Key == K
 is_key(_, []) -> false.
 
--spec to_list(orddict()) -> [{term(), term()}].
+-spec to_list(Orddict) -> List when
+      Orddict :: orddict(),
+      List :: [{Key :: term(), Value :: term()}].
 
 to_list(Dict) -> Dict.
 
--spec from_list([{term(), term()}]) -> orddict().
+-spec from_list(List) -> Orddict when
+      List :: [{Key :: term(), Value :: term()}],
+      Orddict :: orddict().
 
 from_list(Pairs) ->
     lists:foldl(fun ({K,V}, D) -> store(K, V, D) end, [], Pairs).
 
--spec size(orddict()) -> non_neg_integer().
+-spec size(Orddict) -> non_neg_integer() when
+      Orddict :: orddict().
 
 size(D) -> length(D).
 
--spec fetch(Key::term(), Dictionary::orddict()) -> term().
+-spec fetch(Key, Orddict) -> Value when
+      Key :: term(),
+      Value :: term(),
+      Orddict :: orddict().
 
 fetch(Key, [{K,_}|D]) when Key > K -> fetch(Key, D);
 fetch(Key, [{K,Value}|_]) when Key == K -> Value.
 
--spec find(Key::term(), Dictionary::orddict()) -> {'ok', term()} | 'error'.
+-spec find(Key, Orddict) -> {'ok', Value} | 'error' when
+      Key :: term(),
+      Orddict :: orddict(),
+      Value :: term().
 
 find(Key, [{K,_}|_]) when Key < K -> error;
 find(Key, [{K,_}|D]) when Key > K -> find(Key, D);
 find(_Key, [{_K,Value}|_]) -> {ok,Value};	%Key == K
 find(_, []) -> error.
 
--spec fetch_keys(Dictionary::orddict()) -> [term()].
+-spec fetch_keys(Orddict) -> Keys when
+      Orddict :: orddict(),
+      Keys :: [term()].
 
 fetch_keys([{Key,_}|Dict]) ->
     [Key|fetch_keys(Dict)];
 fetch_keys([]) -> [].
 
--spec erase(Key::term(), Dictionary::orddict()) -> orddict().
+-spec erase(Key, Orddict1) -> Orddict2 when
+      Key :: term(),
+      Orddict1 :: orddict(),
+      Orddict2 :: orddict().
 
 erase(Key, [{K,_}=E|Dict]) when Key < K -> [E|Dict];
 erase(Key, [{K,_}=E|Dict]) when Key > K ->
@@ -81,7 +101,11 @@ erase(Key, [{K,_}=E|Dict]) when Key > K ->
 erase(_Key, [{_K,_Val}|Dict]) -> Dict;		%Key == K
 erase(_, []) -> [].
 
--spec store(Key::term(), Value::term(), Dictionary::orddict()) -> orddict().
+-spec store(Key, Value, Orddict1) -> Orddict2 when
+      Key :: term(),
+      Value :: term(),
+      Orddict1 :: orddict(),
+      Orddict2 :: orddict().
 
 store(Key, New, [{K,_}=E|Dict]) when Key < K ->
     [{Key,New},E|Dict];
@@ -91,7 +115,11 @@ store(Key, New, [{_K,_Old}|Dict]) ->		%Key == K
     [{Key,New}|Dict];
 store(Key, New, []) -> [{Key,New}].
 
--spec append(Key::term(), Value::term(), Dictionary::orddict()) -> orddict().
+-spec append(Key, Value, Orddict1) -> Orddict2 when
+      Key :: term(),
+      Value :: term(),
+      Orddict1 :: orddict(),
+      Orddict2 :: orddict().
 
 append(Key, New, [{K,_}=E|Dict]) when Key < K ->
     [{Key,[New]},E|Dict];
@@ -101,7 +129,11 @@ append(Key, New, [{_K,Old}|Dict]) ->		%Key == K
     [{Key,Old ++ [New]}|Dict];
 append(Key, New, []) -> [{Key,[New]}].
 
--spec append_list(Key::term(), ValueList::[term()], orddict()) -> orddict().
+-spec append_list(Key, ValList, Orddict1) -> Orddict2 when
+      Key :: term(),
+      ValList :: [Value :: term()],
+      Orddict1 :: orddict(),
+      Orddict2 :: orddict().
 
 append_list(Key, NewList, [{K,_}=E|Dict]) when Key < K ->
     [{Key,NewList},E|Dict];
@@ -112,14 +144,23 @@ append_list(Key, NewList, [{_K,Old}|Dict]) ->		%Key == K
 append_list(Key, NewList, []) ->
     [{Key,NewList}].
 
--spec update(Key::term(), Fun::fun((term()) -> term()), orddict()) -> orddict().
+-spec update(Key, Fun, Orddict1) -> Orddict2 when
+      Key :: term(),
+      Fun :: fun((Value1 :: term()) -> Value2 :: term()),
+      Orddict1 :: orddict(),
+      Orddict2 :: orddict().
 
 update(Key, Fun, [{K,_}=E|Dict]) when Key > K ->
     [E|update(Key, Fun, Dict)];
 update(Key, Fun, [{K,Val}|Dict]) when Key == K ->
     [{Key,Fun(Val)}|Dict].
 
--spec update(term(), fun((term()) -> term()), term(), orddict()) -> orddict().
+-spec update(Key, Fun, Initial, Orddict1) -> Orddict2 when
+      Key :: term(),
+      Initial :: term(),
+      Fun :: fun((Value1 :: term()) -> Value2 :: term()),
+      Orddict1 :: orddict(),
+      Orddict2 :: orddict().
 
 update(Key, _, Init, [{K,_}=E|Dict]) when Key < K ->
     [{Key,Init},E|Dict];
@@ -129,7 +170,11 @@ update(Key, Fun, _Init, [{_K,Val}|Dict]) ->		%Key == K
     [{Key,Fun(Val)}|Dict];
 update(Key, _, Init, []) -> [{Key,Init}].
 
--spec update_counter(Key::term(), Incr::number(), orddict()) -> orddict().
+-spec update_counter(Key, Increment, Orddict1) -> Orddict2 when
+      Key :: term(),
+      Increment :: number(),
+      Orddict1 :: orddict(),
+      Orddict2 :: orddict().
 
 update_counter(Key, Incr, [{K,_}=E|Dict]) when Key < K ->
     [{Key,Incr},E|Dict];
@@ -139,19 +184,29 @@ update_counter(Key, Incr, [{_K,Val}|Dict]) ->		%Key == K
     [{Key,Val+Incr}|Dict];
 update_counter(Key, Incr, []) -> [{Key,Incr}].
 
--spec fold(fun((term(),term(),term()) -> term()), term(), orddict()) -> term().
+-spec fold(Fun, Acc0, Orddict) -> Acc1 when
+      Fun :: fun((Key :: term(), Value :: term(), AccIn :: term()) -> AccOut :: term()),
+      Acc0 :: term(),
+      Acc1 :: term(),
+      Orddict :: orddict().
 
 fold(F, Acc, [{Key,Val}|D]) ->
     fold(F, F(Key, Val, Acc), D);
 fold(F, Acc, []) when is_function(F, 3) -> Acc.
 
--spec map(fun((term(), term()) -> term()), orddict()) -> orddict().
+-spec map(Fun, Orddict1) -> Orddict2 when
+      Fun :: fun((Key :: term(), Value1 :: term()) -> Value2 :: term()),
+      Orddict1 :: orddict(),
+      Orddict2 :: orddict().
 
 map(F, [{Key,Val}|D]) ->
     [{Key,F(Key, Val)}|map(F, D)];
 map(F, []) when is_function(F, 2) -> [].
 
--spec filter(fun((term(), term()) -> boolean()), orddict()) -> orddict().
+-spec filter(Pred, Orddict1) -> Orddict2 when
+      Pred :: fun((Key :: term(), Value :: term()) -> boolean()),
+      Orddict1 :: orddict(),
+      Orddict2 :: orddict().
 
 filter(F, [{Key,Val}=E|D]) ->
     case F(Key, Val) of
@@ -160,8 +215,11 @@ filter(F, [{Key,Val}=E|D]) ->
     end;
 filter(F, []) when is_function(F, 2) -> [].
 
--spec merge(fun((term(), term(), term()) -> term()), orddict(), orddict()) ->
-    orddict().
+-spec merge(Fun, Orddict1, Orddict2) -> Orddict3 when
+      Fun :: fun((Key :: term(), Value1 :: term(), Value2 :: term()) -> Value :: term()),
+      Orddict1 :: orddict(),
+      Orddict2 :: orddict(),
+      Orddict3 :: orddict().
 
 merge(F, [{K1,_}=E1|D1], [{K2,_}=E2|D2]) when K1 < K2 ->
     [E1|merge(F, D1, [E2|D2])];