src/hope_kv_list.erl

   1 %%%----------------------------------------------------------------------------
   2 %%% Equivalent to stdlib's orddict, but with a pretty (IMO), uniform interface.
   3 %%%----------------------------------------------------------------------------
   4 -module(hope_kv_list).
   5
   6 -behavior(hope_dictionary).
   7
   8 -export_type(
   9     [ t/2
  10     ]).
  11
  12 -export(
  13     [ empty/0
  14     , get/2
  15     , set/3
  16     , update/3
  17     , pop/2
  18     , iter/2
  19     , map/2
  20     , filter/2
  21     , fold/3
  22     , of_kv_list/1
  23     , to_kv_list/1
  24     ]).
  25
  26
  27 -type t(K, V) ::
  28     [{K, V}].
  29
  30
  31 %% ============================================================================
  32 %% API
  33 %% ============================================================================
  34
  35 -spec empty() ->
  36     [].
  37 empty() ->
  38     [].
  39
  40 get(T, K) ->
  41     case lists:keyfind(K, 1, T)
  42     of  false  -> none
  43     ;   {K, V} -> {some, V}
  44     end.
  45
  46 set(T, K, V) ->
  47     lists:keystore(K, 1, T, {K, V}).
  48
  49 update(T, K, F) ->
  50     V1Opt = get(T, K),
  51     V2 = F(V1Opt),
  52     % TODO: Eliminate the 2nd lookup.
  53     set(T, K, V2).
  54
  55 pop(T1, K) ->
  56     case lists:keytake(K, 1, T1)
  57     of  {value, {K, V}, T2} -> {{some, V}, T2}
  58     ;   false               -> {none     , T1}
  59     end.
  60
  61 iter(T, F1) ->
  62     F2 = lift_map(F1),
  63     lists:foreach(F2, T).
  64
  65 map(T, F1) ->
  66     F2 = fun ({K, _}=X) -> {K, apply_map(F1, X)} end,
  67     lists:map(F2, T).
  68
  69 filter(T, F1) ->
  70     F2 = lift_map(F1),
  71     lists:filter(F2, T).
  72
  73 fold(T, F1, Accumulator) ->
  74     F2 = fun ({K, V}, Acc) -> F1(K, V, Acc) end,
  75     lists:foldl(F2, T, Accumulator).
  76
  77 to_kv_list(T) ->
  78     T.
  79
  80 of_kv_list(List) ->
  81     % TODO: Decide if validation is to be done here. Do so if yes.
  82     List.
  83
  84
  85 %% ============================================================================
  86 %% Helpers
  87 %% ============================================================================
  88
  89 -spec lift_map(F) ->
  90     G
  91     when F :: fun(( K, V1 ) -> V2)
  92        , G :: fun(({K, V1}) -> V2)
  93        .
  94 lift_map(F) ->
  95     fun (X) -> apply_map(F, X) end.
  96
  97 -spec apply_map(fun((K, V1) -> V2), {K, V1}) ->
  98     V2.
  99 apply_map(F, {K, V}) ->
 100     F(K, V).