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