src/hope_list.erl

   1 -module(hope_list).
   2
   3 -export_type(
   4     [ t/1
   5     ]).
   6
   7 -export(
   8     [ unique_preserve_order/1
   9     , map/2
  10     , map/3  % Tunable recursion limit
  11     , map_rev/2
  12     , map_slow/2
  13     ]).
  14
  15
  16 -define(DEFAULT_RECURSION_LIMIT, 1000).
  17
  18
  19 -type t(A) ::
  20     [A].
  21
  22
  23 %% @doc Tail-recursive equivalent of lists:map/2
  24 %% @end
  25 -spec map([A], fun((A) -> (B))) ->
  26     [B].
  27 map(Xs, F) ->
  28     map(Xs, F, ?DEFAULT_RECURSION_LIMIT).
  29
  30 -spec map([A], fun((A) -> (B)), RecursionLimit :: non_neg_integer()) ->
  31     [B].
  32 map(Xs, F, RecursionLimit) ->
  33     map(Xs, F, RecursionLimit, 0).
  34
  35 map([], _, _, _) ->
  36     [];
  37 map([X1], F, _, _) ->
  38     Y1 = F(X1),
  39     [Y1];
  40 map([X1, X2], F, _, _) ->
  41     Y1 = F(X1),
  42     Y2 = F(X2),
  43     [Y1, Y2];
  44 map([X1, X2, X3], F, _, _) ->
  45     Y1 = F(X1),
  46     Y2 = F(X2),
  47     Y3 = F(X3),
  48     [Y1, Y2, Y3];
  49 map([X1, X2, X3, X4], F, _, _) ->
  50     Y1 = F(X1),
  51     Y2 = F(X2),
  52     Y3 = F(X3),
  53     Y4 = F(X4),
  54     [Y1, Y2, Y3, Y4];
  55 map([X1, X2, X3, X4, X5 | Xs], F, RecursionLimit, RecursionCount) ->
  56     Y1 = F(X1),
  57     Y2 = F(X2),
  58     Y3 = F(X3),
  59     Y4 = F(X4),
  60     Y5 = F(X5),
  61     Ys =
  62         case RecursionCount > RecursionLimit
  63         of  true  -> map_slow(Xs, F)
  64         ;   false -> map     (Xs, F, RecursionLimit, RecursionCount + 1)
  65         end,
  66     [Y1, Y2, Y3, Y4, Y5 | Ys].
  67
  68
  69 %% @doc lists:reverse(map_rev(L, F))
  70 %% @end
  71 -spec map_slow([A], fun((A) -> (B))) ->
  72     [B].
  73 map_slow(Xs, F) ->
  74     lists:reverse(map_rev(Xs, F)).
  75
  76
  77 %% @doc Tail-recursive alternative to lists:map/2, which accumulates and
  78 %% returns list in reverse order.
  79 %% @end
  80 -spec map_rev([A], fun((A) -> (B))) ->
  81     [B].
  82 map_rev(Xs, F) ->
  83     map_rev_acc(Xs, F, []).
  84
  85 -spec map_rev_acc([A], fun((A) -> (B)), [B]) ->
  86     [B].
  87 map_rev_acc([], _, Ys) ->
  88     Ys;
  89 map_rev_acc([X|Xs], F, Ys) ->
  90     Y = F(X),
  91     map_rev_acc(Xs, F, [Y|Ys]).
  92
  93
  94 -spec unique_preserve_order(t(A)) ->
  95     t(A).
  96 unique_preserve_order(L) ->
  97     PrependIfNew =
  98         fun (X, Xs) ->
  99             case lists:member(X, Xs)
 100             of  true  ->      Xs
 101             ;   false -> [X | Xs]
 102             end
 103         end,
 104     lists:reverse(lists:foldl(PrependIfNew, [], L)).