-module(gleam@map).
-compile(no_auto_import).

-export([size/1, to_list/1, from_list/1, has_key/2, new/0, get/2, insert/3, map_values/2, keys/1, values/1, filter/2, take/2, merge/2, delete/2, drop/2, update/3, fold/3]).
-export_type([map_/2]).

-type map_(Key, Value) :: any() | {gleam_phantom, Key, Value}.

-spec size(map_(any(), any())) -> integer().
size(A) ->
    maps:size(A).

-spec to_list(map_(BSM, BSN)) -> list({BSM, BSN}).
to_list(A) ->
    maps:to_list(A).

-spec from_list(list({BSR, BSS})) -> map_(BSR, BSS).
from_list(A) ->
    maps:from_list(A).

-spec has_key(map_(BTA, any()), BTA) -> boolean().
has_key(Map, Key) ->
    maps:is_key(Key, Map).

-spec new() -> map_(any(), any()).
new() ->
    maps:new().

-spec get(map_(BTL, BTI), BTL) -> {ok, BTI} | {error, nil}.
get(A, B) ->
    gleam_stdlib:map_get(A, B).

-spec insert(map_(BTU, BTV), BTU, BTV) -> map_(BTU, BTV).
insert(Map, Key, Value) ->
    maps:put(Key, Value, Map).

-spec map_values(map_(BUI, BUJ), fun((BUI, BUJ) -> BUM)) -> map_(BUI, BUM).
map_values(Map, Fun) ->
    maps:map(Fun, Map).

-spec keys(map_(BUP, any())) -> list(BUP).
keys(A) ->
    maps:keys(A).

-spec values(map_(any(), BUU)) -> list(BUU).
values(A) ->
    maps:values(A).

-spec filter(map_(BVF, BVG), fun((BVF, BVG) -> boolean())) -> map_(BVF, BVG).
filter(Map, Property) ->
    maps:filter(Property, Map).

-spec take(map_(BVS, BVT), list(BVS)) -> map_(BVS, BVT).
take(Map, Desired_keys) ->
    maps:with(Desired_keys, Map).

-spec merge(map_(BVZ, BWA), map_(BVZ, BWA)) -> map_(BVZ, BWA).
merge(A, B) ->
    maps:merge(A, B).

-spec delete(map_(BWN, BWO), BWN) -> map_(BWN, BWO).
delete(Map, Key) ->
    maps:remove(Key, Map).

-spec drop(map_(BWT, BWU), list(BWT)) -> map_(BWT, BWU).
drop(Map, Disallowed_keys) ->
    gleam@list:fold(Disallowed_keys, Map, fun(Key, Acc) -> delete(Acc, Key) end).

-spec update(map_(BXA, BXB), BXA, fun(({ok, BXB} | {error, nil}) -> BXB)) -> map_(BXA, BXB).
update(Map, Key, Fun) ->
    insert(Map, Key, Fun(gleam_stdlib:map_get(Map, Key))).

-spec do_fold(list({BXI, BXJ}), BXL, fun((BXI, BXJ, BXL) -> BXL)) -> BXL.
do_fold(List, Initial, Fun) ->
    case List of
        [] ->
            Initial;

        [{K, V} | Tail] ->
            do_fold(Tail, Fun(K, V, Initial), Fun)
    end.

-spec fold(map_(BXM, BXN), BXQ, fun((BXM, BXN, BXQ) -> BXQ)) -> BXQ.
fold(Map, Initial, Fun) ->
    do_fold(maps:to_list(Map), Initial, Fun).