Merge pull request #1565 from jakub-gonet/jgonet/dropwhile

Add lists:dropwhile, fix lists:duplicate/2

See also #1509

These changes are made under both the "Apache 2.0" and the "GNU Lesser General
Public License 2.1 or later" license terms (dual license).

SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later

Author: bettio

CHANGELOG.md

@@ -23,10 +23,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Added `erlang:+/1`
 - Added `lists:append/1` and `lists:append/2`
 - Added `erlang:spawn_monitor/1`, `erlang:spawn_monitor/3`
+- Added `lists:dropwhile/2`.
 
 ### Fixed
 - ESP32: improved sntp sync speed from a cold boot.
 - Utilize reserved `phy_init` partition on ESP32 to store wifi calibration for faster connections.
+- Support for zero count in `lists:duplicate/2`.
 
 ## [0.6.6] - Unreleased
 

libs/eavmlib/src/esp.erl

@@ -486,7 +486,7 @@ nvs_reformat() ->
 %% @end
 %%-----------------------------------------------------------------------------
 -spec partition_erase_range(Partition_id :: binary(), Offset :: non_neg_integer()) -> ok | error.
-partition_erase_range(Partition_id, Offset) ->
+partition_erase_range(_Partition_id, _Offset) ->
     erlang:nif_error(undefined).
 
 %%-----------------------------------------------------------------------------
@@ -505,7 +505,7 @@ partition_erase_range(Partition_id, Offset) ->
 -spec partition_erase_range(
     Partition_id :: binary(), Offset :: non_neg_integer(), Size :: pos_integer()
 ) -> ok | error.
-partition_erase_range(Partition_id, Offset, Size) ->
+partition_erase_range(_Partition_id, _Offset, _Size) ->
     erlang:nif_error(undefined).
 
 %%-----------------------------------------------------------------------------
@@ -531,7 +531,7 @@ partition_list() ->
 -spec partition_read(
     Partition_id :: binary(), Offset :: non_neg_integer(), Read_size :: non_neg_integer()
 ) -> {ok, binary()} | error.
-partition_read(Partition_id, Offset, Read_size) ->
+partition_read(_Partition_id, _Offset, _Read_size) ->
     erlang:nif_error(undefined).
 
 %%-----------------------------------------------------------------------------
@@ -550,7 +550,7 @@ partition_read(Partition_id, Offset, Read_size) ->
 %%-----------------------------------------------------------------------------
 -spec partition_write(Partition_id :: binary(), Offset :: non_neg_integer(), Data :: binary()) ->
     ok | error.
-partition_write(Partition_id, Offset, Data) ->
+partition_write(_Partition_id, _Offset, _Data) ->
     erlang:nif_error(undefined).
 
 %%-----------------------------------------------------------------------------

libs/estdlib/src/lists.erl

@@ -60,6 +60,7 @@
     sort/1, sort/2,
     split/2,
     usort/1, usort/2,
+    dropwhile/2,
     duplicate/2,
     sublist/2,
     append/1,
@@ -731,6 +732,32 @@ unique([X, Y | Tail], Fun) ->
             [X | unique([Y | Tail], Fun)]
     end.
 
+%%-----------------------------------------------------------------------------
+%% @param   Pred the predicate to check against elements in List1
+%% @param   List1
+%% @returns List List1 tail at the point predicate returned false for a element
+%% @doc     Drops elements Elem from List1 while Pred(Elem) returns true and returns
+%%          the remaining list. The Pred function must return a boolean.
+%% @end
+%%-----------------------------------------------------------------------------
+% Attribution: https://github.com/erlang/otp/blob/05737d130706c7189a8e6750d9c2252d2cc7987e/lib/stdlib/src/lists.erl#L2403
+-spec dropwhile(Pred, List1) -> List2 when
+    Pred :: fun((Elem :: T) -> boolean()),
+    List1 :: [T],
+    List2 :: [T],
+    T :: term().
+
+dropwhile(Pred, List) when is_function(Pred, 1) ->
+    dropwhile_1(Pred, List).
+
+dropwhile_1(Pred, [Hd | Tail] = Rest) ->
+    case Pred(Hd) of
+        true -> dropwhile_1(Pred, Tail);
+        false -> Rest
+    end;
+dropwhile_1(_Pred, []) ->
+    [].
+
 %%-----------------------------------------------------------------------------
 %% @param   Elem the element to duplicate
 %% @param   Count the number of times to duplicate the element
@@ -739,7 +766,7 @@ unique([X, Y | Tail], Fun) ->
 %% @end
 %%-----------------------------------------------------------------------------
 -spec duplicate(integer(), Elem) -> [Elem].
-duplicate(Count, Elem) when is_integer(Count) andalso Count > 0 ->
+duplicate(Count, Elem) when is_integer(Count) andalso Count >= 0 ->
     duplicate(Count, Elem, []).
 
 duplicate(0, _Elem, Acc) -> Acc;

tests/erlang_tests/unary_plus.erl

@@ -29,11 +29,11 @@ start() ->
     0.
 
 unary_plus_int(A) ->
-    +A,
+    A = +A,
     ok.
 
 unary_plus_float(A) ->
-    +A,
+    A = +A,
     ok.
 
 unary_plus_str(A) ->

tests/libs/estdlib/test_lists.erl

@@ -47,6 +47,8 @@ test() ->
     ok = test_sort(),
     ok = test_split(),
     ok = test_usort(),
+    ok = test_dropwhile(),
+    ok = test_duplicate(),
     ok = test_filtermap(),
     ok = test_last(),
     ok = test_mapfoldl(),
@@ -99,54 +101,45 @@ test_keydelete() ->
     ?ASSERT_MATCH(lists:keydelete(a, 1, []), []),
     ?ASSERT_MATCH(lists:keydelete(a, 1, [{a, x}, b, []]), [b, []]),
     ?ASSERT_MATCH(lists:keydelete(a, 1, [b, {a, x}, []]), [b, []]),
-    ?ASSERT_MATCH(lists:keydelete(a, 1, [b, {a, x}, {a, x}, {a, x}, []]), [b, {a, x}, {a, x}, []]),
+    ?ASSERT_MATCH(
+        lists:keydelete(a, 1, [b, {a, x}, {a, x}, {a, x}, []]),
+        [b, {a, x}, {a, x}, []]
+    ),
     ok.
 
 test_keyreplace() ->
     ?ASSERT_MATCH(lists:keyreplace(a, 1, [], {foo, bar}), []),
     ?ASSERT_MATCH(lists:keyreplace(a, 1, [{a, x}, b, []], {1, 2}), [{1, 2}, b, []]),
     ?ASSERT_MATCH(lists:keyreplace(x, 2, [b, {a, x}, []], {1, 2}), [b, {1, 2}, []]),
-    ?ASSERT_MATCH(lists:keyreplace(a, 1, [b, {a, x}, {a, x}, {a, x}, []], {1, 2}), [
-        b,
-        {1, 2},
-        {a, x},
-        {a, x},
-        []
-    ]),
-    ?ASSERT_MATCH(lists:keyreplace(a, 3, [b, {a, x}, {a, x}, {a, x}, []], {1, 2}), [
-        b,
-        {a, x},
-        {a, x},
-        {a, x},
-        []
-    ]),
+    ?ASSERT_MATCH(
+        lists:keyreplace(a, 1, [b, {a, x}, {a, x}, {a, x}, []], {1, 2}),
+        [b, {1, 2}, {a, x}, {a, x}, []]
+    ),
+    ?ASSERT_MATCH(
+        lists:keyreplace(a, 3, [b, {a, x}, {a, x}, {a, x}, []], {1, 2}),
+        [b, {a, x}, {a, x}, {a, x}, []]
+    ),
     ok.
 
 test_keystore() ->
     ?ASSERT_MATCH(lists:keystore(a, 1, [], {foo, bar}), [{foo, bar}]),
     ?ASSERT_MATCH(lists:keystore(a, 1, [{a, x}, b, []], {1, 2}), [{1, 2}, b, []]),
     ?ASSERT_MATCH(lists:keystore(x, 2, [b, {a, x}, []], {1, 2}), [b, {1, 2}, []]),
-    ?ASSERT_MATCH(lists:keystore(a, 1, [b, {a, x}, {a, x}, {a, x}, []], {1, 2}), [
-        b,
-        {1, 2},
-        {a, x},
-        {a, x},
-        []
-    ]),
-    ?ASSERT_MATCH(lists:keystore(a, 3, [b, {a, x}, {a, x}, {a, x}, []], {1, 2}), [
-        b,
-        {a, x},
-        {a, x},
-        {a, x},
-        [],
-        {1, 2}
-    ]),
+    ?ASSERT_MATCH(
+        lists:keystore(a, 1, [b, {a, x}, {a, x}, {a, x}, []], {1, 2}),
+        [b, {1, 2}, {a, x}, {a, x}, []]
+    ),
+    ?ASSERT_MATCH(
+        lists:keystore(a, 3, [b, {a, x}, {a, x}, {a, x}, []], {1, 2}),
+        [b, {a, x}, {a, x}, {a, x}, [], {1, 2}]
+    ),
     ok.
 
 test_keytake() ->
     List1 = [{name, "Joe"}, {name, "Robert"}, {name, "Mike"}],
     ?ASSERT_MATCH(
-        lists:keytake("Joe", 2, List1), {value, {name, "Joe"}, [{name, "Robert"}, {name, "Mike"}]}
+        lists:keytake("Joe", 2, List1),
+        {value, {name, "Joe"}, [{name, "Robert"}, {name, "Mike"}]}
     ),
     ?ASSERT_MATCH(
         lists:keytake("Robert", 2, List1),
@@ -208,7 +201,10 @@ test_flatten() ->
     ?ASSERT_MATCH(lists:flatten([[a], [b]]), [a, b]),
     ?ASSERT_MATCH(lists:flatten([[a], [b, [c]]]), [a, b, c]),
     ?ASSERT_MATCH(lists:flatten([[a], [b, {c, [d, [e, [f]]]}]]), [a, b, {c, [d, [e, [f]]]}]),
-    ?ASSERT_MATCH(lists:flatten([[a, b, c], [d, e, f], [g, h, i]]), [a, b, c, d, e, f, g, h, i]),
+    ?ASSERT_MATCH(
+        lists:flatten([[a, b, c], [d, e, f], [g, h, i]]),
+        [a, b, c, d, e, f, g, h, i]
+    ),
     ok.
 
 test_filter() ->
@@ -243,7 +239,6 @@ test_seq() ->
     ?ASSERT_ERROR(lists:seq(-1, 1, -1)),
     ?ASSERT_ERROR(lists:seq(1, -1, 1)),
     ?ASSERT_ERROR(lists:seq(1, 2, 0)),
-
     ok.
 
 test_sort() ->
@@ -286,13 +281,32 @@ test_usort() ->
     ?ASSERT_MATCH(lists:usort([1, 3, 5, 2, 1, 4]), [1, 2, 3, 4, 5]),
     ?ASSERT_MATCH(lists:usort([1, 3, 5, 2, 5, 4]), [1, 2, 3, 4, 5]),
 
-    ?ASSERT_MATCH(lists:usort(fun(A, B) -> A > B end, [1, 2, 3, 4, 3, 5]), [5, 4, 3, 3, 2, 1]),
+    ?ASSERT_MATCH(
+        lists:usort(fun(A, B) -> A > B end, [1, 2, 3, 4, 3, 5]),
+        [5, 4, 3, 3, 2, 1]
+    ),
     ?ASSERT_MATCH(lists:usort(fun(A, B) -> A >= B end, [1, 2, 3, 4, 3, 5]), [5, 4, 3, 2, 1]),
 
     ?ASSERT_ERROR(lists:usort(1), function_clause),
     ?ASSERT_ERROR(lists:usort(fun(A, B) -> A > B end, 1), function_clause),
     ?ASSERT_ERROR(lists:usort(1, [1]), function_clause),
+    ok.
+
+test_dropwhile() ->
+    ?ASSERT_MATCH(lists:dropwhile(fun(_X) -> true end, []), []),
+    ?ASSERT_MATCH(lists:dropwhile(fun(_X) -> false end, []), []),
+    ?ASSERT_MATCH(lists:dropwhile(fun(_X) -> false end, [1]), [1]),
+    ?ASSERT_MATCH(lists:dropwhile(fun(X) -> X == 1 end, [1, 1, 1, 2, 3]), [2, 3]),
+    ?ASSERT_ERROR(lists:dropwhile([], []), function_clause),
+    ?ASSERT_ERROR(lists:dropwhile(fun(X) -> X == 1 end, [1 | 1]), function_clause),
+    ok.
 
+test_duplicate() ->
+    ?ASSERT_MATCH(lists:duplicate(0, x), []),
+    ?ASSERT_MATCH(lists:duplicate(1, x), [x]),
+    ?ASSERT_MATCH(lists:duplicate(3, []), [[], [], []]),
+    ?ASSERT_ERROR(lists:duplicate(-1, x), function_clause),
+    ?ASSERT_ERROR(lists:duplicate(x, x), function_clause),
     ok.
 
 test_filtermap() ->
@@ -319,7 +333,10 @@ test_last() ->
 
 test_mapfoldl() ->
     ?ASSERT_MATCH({[], 1}, lists:mapfoldl(fun(X, A) -> {X * A, A + 1} end, 1, [])),
-    ?ASSERT_MATCH({[1, 4, 9], 4}, lists:mapfoldl(fun(X, A) -> {X * A, A + 1} end, 1, [1, 2, 3])),
+    ?ASSERT_MATCH(
+        {[1, 4, 9], 4},
+        lists:mapfoldl(fun(X, A) -> {X * A, A + 1} end, 1, [1, 2, 3])
+    ),
     ?ASSERT_ERROR(lists:mapfoldl(fun(X, A) -> {X * A, A + 1} end, 1, foo), function_clause),
     ok.
 
@@ -335,4 +352,5 @@ test_append() ->
     ?ASSERT_ERROR(lists:append(1, 3), badarg),
     ok.
 
-id(X) -> X.
+id(X) ->
+    X.