Types and specifications have been modified and added

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])];