Current section
Files
Jump to
Current section
Files
src/glib@map.erl
-module(glib@map).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).
-export([size/1, is_empty/1, keys/1, values/1, entries/1, to_string/2, get/2, contains_key/2, remove/2, list_size/1, full_count/1, new_with_size_and_load/2, new_with_size/1, new/0, clear/1, put/3]).
-export_type([entry/1, map_/1]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(
" Maps are a structure similar to dict in that they map keys to values.\n"
" Duplicate keys cannot exist and a key can map to at most one value\n"
" \n"
" The Keys are strings, values can be any type but values must be of the same type\n"
" \n"
" Maps are unordered\n"
).
-type entry(HWP) :: {entry, binary(), HWP}.
-opaque map_(HWQ) :: {map,
glib@treelist:tree_list(gleam@option:option(entry(HWQ))),
integer(),
integer(),
integer(),
boolean()}.
-file("src/glib/map.gleam", 115).
?DOC(
" Determines the size of the map, i.e. the number of key/values\n"
" \n"
" ## Examples\n"
" \n"
" ```gleam\n"
" new() |> size\n"
" // -> 0\n"
" ```\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", \"value\") |> size\n"
" // -> 1\n"
" ```\n"
).
-spec size(map_(any())) -> integer().
size(Map) ->
erlang:element(5, Map).
-file("src/glib/map.gleam", 97).
?DOC(
" Determines whether the map is empty, i.e. contains no key/values\n"
" \n"
" ## Examples\n"
" \n"
" ```gleam\n"
" new() |> is_empty\n"
" // -> True\n"
" ```\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", \"value\") |> is_empty\n"
" // -> False\n"
" ```\n"
).
-spec is_empty(map_(any())) -> boolean().
is_empty(Map) ->
size(Map) =:= 0.
-file("src/glib/map.gleam", 306).
?DOC(
" Returns a list of the keys contained in the map\n"
" \n"
" ## Examples\n"
" \n"
" ```gleam\n"
" new() |> keys\n"
" // -> []\n"
" ```\n"
" \n"
" ``` gleam\n"
" new() |> put(\"key\", \"value\") |> keys\n"
" // -> [\"key\"]\n"
" ```\n"
).
-spec keys(map_(any())) -> list(binary()).
keys(Map) ->
_pipe = glib@treelist:to_iterator(erlang:element(2, Map)),
_pipe@1 = gleam@yielder:filter_map(_pipe, fun(E) -> case E of
none ->
{error, nil};
{some, En} ->
{ok, erlang:element(2, En)}
end end),
gleam@yielder:to_list(_pipe@1).
-file("src/glib/map.gleam", 331).
?DOC(
" Returns a list of the values contained in the map\n"
" \n"
" ## Examples\n"
" \n"
" ```gleam\n"
" new() |> values\n"
" // -> []\n"
" ```\n"
" \n"
" ``` gleam\n"
" new() |> put(\"key\", \"value\") |> values\n"
" // -> [\"value\"]\n"
" ```\n"
).
-spec values(map_(HYH)) -> list(HYH).
values(Map) ->
_pipe = glib@treelist:to_iterator(erlang:element(2, Map)),
_pipe@1 = gleam@yielder:filter_map(_pipe, fun(E) -> case E of
none ->
{error, nil};
{some, En} ->
{ok, erlang:element(3, En)}
end end),
gleam@yielder:to_list(_pipe@1).
-file("src/glib/map.gleam", 356).
?DOC(
" Returns a list of the tuples #(key, value) contained in the map\n"
" \n"
" ## Examples\n"
" \n"
" ```gleam\n"
" new() |> entries\n"
" // -> []\n"
" ```\n"
" \n"
" ``` gleam\n"
" new() |> put(\"key\", \"value\") |> entries\n"
" // -> [#(\"key\", \"value\")]\n"
" ```\n"
).
-spec entries(map_(HYK)) -> list({binary(), HYK}).
entries(Map) ->
_pipe = glib@treelist:to_iterator(erlang:element(2, Map)),
_pipe@1 = gleam@yielder:filter_map(_pipe, fun(E) -> case E of
none ->
{error, nil};
{some, En} ->
{ok, {erlang:element(2, En), erlang:element(3, En)}}
end end),
gleam@yielder:to_list(_pipe@1).
-file("src/glib/map.gleam", 382).
?DOC(
" Returns a string representation of the passed map\n"
" Requires a value_to_string fn to generate the output\n"
" \n"
" ## Examples\n"
" \n"
" ```gleam\n"
" new() |> to_string(fn(v) { v })\n"
" // -> {}\n"
" ```\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", \"value\") |> to_string(fn(v) { v })\n"
" // -> {\"key\": \"value\"}\n"
" ```\n"
).
-spec to_string(map_(HYN), fun((HYN) -> binary())) -> {ok, binary()} |
{error, nil}.
to_string(Map, Value_to_string) ->
{ok,
<<<<"{"/utf8,
(gleam@string:join(
begin
_pipe = glib@treelist:to_iterator(
erlang:element(2, Map)
),
_pipe@1 = gleam@yielder:filter_map(
_pipe,
fun(Opt) -> case Opt of
none ->
{error, Opt};
{some, E} ->
{ok,
<<<<<<<<"\""/utf8,
(erlang:element(
2,
E
))/binary>>/binary,
"\""/utf8>>/binary,
":"/utf8>>/binary,
(Value_to_string(
erlang:element(3, E)
))/binary>>}
end end
),
gleam@yielder:to_list(_pipe@1)
end,
<<","/utf8>>
))/binary>>/binary,
"}"/utf8>>}.
-file("src/glib/map.gleam", 404).
-spec do_remove(map_(HYR), integer(), HYR) -> {ok,
{gleam@option:option(HYR), map_(HYR)}} |
{error, nil}.
do_remove(Map, Index, Value) ->
gleam@result:'try'(
glib@treelist:set(erlang:element(2, Map), Index, none),
fun(Entry) ->
New_map = begin
_record = Map,
{map,
Entry,
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, Map) - 1,
erlang:element(6, _record)}
end,
{ok, {{some, Value}, New_map}}
end
).
-file("src/glib/map.gleam", 438).
-spec find_gap(map_(any()), binary(), integer(), integer()) -> {ok,
{integer(), boolean()}} |
{error, nil}.
find_gap(Map, Key, Last_position, Position) ->
gleam@result:'try'(
glib@treelist:get(erlang:element(2, Map), Position),
fun(Entry) -> case Entry of
none ->
{ok, {Position, false}};
{some, E} ->
case erlang:element(2, E) =:= Key of
true ->
{ok, {Position, true}};
false ->
case Position of
Position@1 when Position@1 =:= Last_position ->
{ok, {-1, false}};
0 ->
find_gap(
Map,
Key,
Last_position,
erlang:element(3, Map) - 1
);
Position@2 ->
find_gap(
Map,
Key,
Last_position,
Position@2 - 1
)
end
end
end end
).
-file("src/glib/map.gleam", 472).
-spec find_key(
map_(HZH),
binary(),
integer(),
integer(),
fun((integer(), HZH) -> HZJ)
) -> {ok, gleam@option:option(HZJ)} | {error, nil}.
find_key(Map, Key, Last_position, Position, Ret_fn) ->
gleam@result:'try'(
glib@treelist:get(erlang:element(2, Map), Position),
fun(Entry) -> case Entry of
none ->
{ok, none};
{some, E} ->
case erlang:element(2, E) =:= Key of
true ->
{ok, {some, Ret_fn(Position, erlang:element(3, E))}};
false ->
case Position of
Position@1 when Position@1 =:= Last_position ->
{ok, none};
0 ->
find_key(
Map,
Key,
Last_position,
erlang:element(3, Map) - 1,
Ret_fn
);
Position@2 ->
find_key(
Map,
Key,
Last_position,
Position@2 - 1,
Ret_fn
)
end
end
end end
).
-file("src/glib/map.gleam", 497).
-spec ret_value(integer(), HZN) -> HZN.
ret_value(_, Value) ->
Value.
-file("src/glib/map.gleam", 501).
-spec ret_exists(integer(), any()) -> boolean().
ret_exists(_, _) ->
true.
-file("src/glib/map.gleam", 505).
-spec ret_index_and_value(integer(), HZP) -> {integer(), HZP}.
ret_index_and_value(Index, Value) ->
{Index, Value}.
-file("src/glib/map.gleam", 622).
-spec prepend_none(integer(), list(gleam@option:option(entry(HZV)))) -> list(gleam@option:option(entry(HZV))).
prepend_none(Times, Acc) ->
case Times =< 0 of
true ->
Acc;
false ->
prepend_none(Times - 1, [none | Acc])
end.
-file("src/glib/map.gleam", 629).
-spec do_repeat(IAA, integer(), list(IAA)) -> list(IAA).
do_repeat(A, Times, Acc) ->
case Times =< 0 of
true ->
Acc;
false ->
do_repeat(A, Times, [A | Acc])
end.
-file("src/glib/map.gleam", 636).
-spec fix_hash(integer(), integer()) -> integer().
fix_hash(Map_size, Hash) ->
case Map_size of
0 -> 0;
Gleam@denominator -> begin
_pipe = Hash,
gleam@int:absolute_value(_pipe)
end
rem Gleam@denominator
end.
-file("src/glib/map.gleam", 644).
-spec calc_hash(integer(), binary()) -> {integer(), integer()}.
calc_hash(Map_size, Key) ->
Hash_value = glib@hash:hash(Key),
{fix_hash(Map_size, Hash_value), Hash_value}.
-file("src/glib/map.gleam", 194).
?DOC(
" Retrieves the option wrapped value from the map for the stored key\n"
" \n"
" The key may not exist so then None is returned\n"
" \n"
" ## Examples\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", \"value\") |> get(\"key\")\n"
" // -> Ok(\"value\")\n"
" ```\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", \"value\") |> get(\"non-existent\")\n"
" // -> None\n"
" ```\n"
).
-spec get(map_(HXR), binary()) -> {ok, gleam@option:option(HXR)} | {error, nil}.
get(Map, Key) ->
{Hash, _} = calc_hash(erlang:element(3, Map), Key),
gleam@result:'try'(
glib@treelist:get(erlang:element(2, Map), Hash),
fun(Entry) -> case Entry of
none ->
{ok, none};
{some, E} ->
case erlang:element(2, E) =:= Key of
true ->
{ok, {some, erlang:element(3, E)}};
false ->
find_key(Map, Key, case erlang:element(3, Map) of
0 -> 0;
Gleam@denominator -> (Hash + 1) rem Gleam@denominator
end, Hash, fun ret_value/2)
end
end end
).
-file("src/glib/map.gleam", 225).
?DOC(
" Returns the existence in the map for the stored key\n"
" \n"
" \n"
" ## Examples\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", \"value\") |> contains_key(\"key\")\n"
" // -> True\n"
" ```\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", \"value\") |> contains_key(\"non-existent\")\n"
" // -> False\n"
" ```\n"
).
-spec contains_key(map_(any()), binary()) -> boolean().
contains_key(Map, Key) ->
{Hash, _} = calc_hash(erlang:element(3, Map), Key),
case glib@treelist:get(erlang:element(2, Map), Hash) of
{error, _} ->
false;
{ok, none} ->
false;
{ok, {some, E}} ->
case erlang:element(2, E) =:= Key of
true ->
true;
false ->
gleam@option:unwrap(
gleam@result:unwrap(
find_key(Map, Key, case erlang:element(3, Map) of
0 -> 0;
Gleam@denominator -> (Hash + 1) rem Gleam@denominator
end, Hash, fun ret_exists/2),
none
),
false
)
end
end.
-file("src/glib/map.gleam", 262).
?DOC(
" Removes the specified key from the map and returns a tuple containing\n"
" the removed option wrapped value or None and the altered map without the\n"
" specified key\n"
" \n"
" ## Examples\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", \"value\") |> remove(\"key\")\n"
" // -> #(Some(\"value\"), {})\n"
" ```\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", \"value\") |> remove(\"non-existent\")\n"
" // -> #(None, {\"key\": \"value\"})\n"
" ```\n"
).
-spec remove(map_(HXY), binary()) -> {ok, {gleam@option:option(HXY), map_(HXY)}} |
{error, nil}.
remove(Map, Key) ->
{Hash, _} = calc_hash(erlang:element(3, Map), Key),
gleam@result:'try'(
glib@treelist:get(erlang:element(2, Map), Hash),
fun(Entry) -> case Entry of
none ->
{ok, {none, Map}};
{some, E} ->
case erlang:element(2, E) =:= Key of
true ->
do_remove(Map, Hash, erlang:element(3, E));
false ->
gleam@result:'try'(
find_key(
Map,
Key,
case erlang:element(3, Map) of
0 -> 0;
Gleam@denominator -> (Hash + 1) rem Gleam@denominator
end,
Hash,
fun ret_index_and_value/2
),
fun(Item) -> case Item of
none ->
{ok, {none, Map}};
{some, {Index, Value}} ->
do_remove(Map, Index, Value)
end end
)
end
end end
).
-file("src/glib/map.gleam", 651).
?DOC(
" Returns the internal storage size of the map\n"
" This is mainly for testing use\n"
).
-spec list_size(map_(any())) -> integer().
list_size(Map) ->
glib@treelist:size(erlang:element(2, Map)).
-file("src/glib/map.gleam", 659).
?DOC(
" Returns a count of the number of entries in the map\n"
" This is used for testing to compare against the cached size\n"
" Performs a full iteration of the list incrementing for all Some(_)\n"
" entries\n"
).
-spec full_count(map_(any())) -> integer().
full_count(Map) ->
_pipe = glib@treelist:to_iterator(erlang:element(2, Map)),
gleam@yielder:fold(_pipe, 0, fun(Acc, E) -> case E of
none ->
Acc;
{some, _} ->
Acc + 1
end end).
-file("src/glib/map.gleam", 59).
?DOC(
" Creates an empty map with specified size and loading factor\n"
" load is a value 0->1 (non-inclusive) which specifies a percentage (e.g. 0.5 is 50%)\n"
" at which point the backing list is resized\n"
" This should be kept around 0.6-0.8 to avoid either excessive resizing or\n"
" excessive key hash collisions\n"
).
-spec new_with_size_and_load(integer(), float()) -> {ok, map_(any())} |
{error, nil}.
new_with_size_and_load(Size, Load) ->
Load@1 = case (Load >= 1.0) orelse (Load < +0.0) of
true ->
0.75;
false ->
Load
end * 100.0,
Size@1 = case Size < 1 of
true ->
1;
false ->
Size
end,
gleam@result:'try'(
glib@treelist:repeat(none, Size@1),
fun(Backing_list) ->
{ok, {map, Backing_list, Size@1, erlang:round(Load@1), 0, false}}
end
).
-file("src/glib/map.gleam", 49).
?DOC(
" Creates an empty map with specified size\n"
" The loading factor is set to default\n"
).
-spec new_with_size(integer()) -> {ok, map_(any())} | {error, nil}.
new_with_size(Size) ->
new_with_size_and_load(Size, 0.75).
-file("src/glib/map.gleam", 43).
?DOC(
" Creates an empty map\n"
" The size and loading factor are set to the default\n"
" The size is the starting size for the list that contains the values\n"
" The loading factor is the value 0 -> 1 that determines when the\n"
" list is resized. This is the percentage of the backing list that is filled.\n"
" For example, if the loading factor was 0.5 then when one half of the backing\n"
" list is populated, the next addition to the Map will trigger a resize to\n"
" ensure the map has usable space\n"
).
-spec new() -> {ok, map_(any())} | {error, nil}.
new() ->
new_with_size(11).
-file("src/glib/map.gleam", 76).
?DOC(
" Creates a new empty map with the same sizing/loading properties as the\n"
" passed map\n"
).
-spec clear(map_(HXD)) -> {ok, map_(HXD)} | {error, nil}.
clear(Previous_map) ->
new_with_size_and_load(
erlang:element(3, Previous_map),
erlang:float(erlang:element(4, Previous_map)) / 100.0
).
-file("src/glib/map.gleam", 607).
-spec basic_rehash(map_(HZQ), integer()) -> {ok, map_(HZQ)} | {error, nil}.
basic_rehash(Map, New_size) ->
gleam@result:'try'(
new_with_size_and_load(
New_size,
erlang:float(erlang:element(4, Map)) / 100.0
),
fun(New_map) ->
_pipe = glib@treelist:to_iterator(erlang:element(2, Map)),
gleam@yielder:try_fold(
_pipe,
begin
_record = New_map,
{map,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
true}
end,
fun(Map@1, Entry) -> case Entry of
{some, Entry@1} ->
put(
Map@1,
erlang:element(2, Entry@1),
erlang:element(3, Entry@1)
);
none ->
{ok, Map@1}
end end
)
end
).
-file("src/glib/map.gleam", 140).
?DOC(
" Inserts a value into the map with the given key\n"
" \n"
" Will replace value if key already exists\n"
" \n"
" ## Examples\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", 999) |> to_string(fn(i) { int.to_string(i) })\n"
" // -> {\"key\":999}\n"
" ```\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", 999) |> put(\"key2\", 111) |> to_string(fn(i) { int.to_string(i) })\n"
" // -> {\"key\":999, \"key2\":111}\n"
" ```\n"
" \n"
" ```gleam\n"
" new() |> put(\"key\", 999) |> put(\"key\", 123) |> to_string(fn(i) { int.to_string(i) })\n"
" // -> {\"key\":123}\n"
" ```\n"
).
-spec put(map_(HXM), binary(), HXM) -> {ok, map_(HXM)} | {error, nil}.
put(Map, Key, Value) ->
{Hash, Original_hash} = calc_hash(erlang:element(3, Map), Key),
gleam@result:'try'(
glib@treelist:get(erlang:element(2, Map), Hash),
fun(Entry) -> gleam@result:'try'(case Entry of
{some, E} when erlang:element(2, E) =:= Key ->
{ok, {Map, Hash, true}};
_ ->
gleam@result:'try'(
check_capacity(Map, Original_hash),
fun(_use0) ->
{Map@1, New_hash} = _use0,
New_hash@1 = gleam@option:unwrap(New_hash, Hash),
gleam@result:'try'(
find_gap(
Map@1,
Key,
case erlang:element(3, Map@1) of
0 -> 0;
Gleam@denominator -> (New_hash@1 + 1)
rem Gleam@denominator
end,
New_hash@1
),
fun(_use0@1) ->
{Entry_pos, Overwrite} = _use0@1,
{ok, {Map@1, Entry_pos, Overwrite}}
end
)
end
)
end, fun(_use0@2) ->
{Map@2, Entry_pos@1, Overwrite@1} = _use0@2,
gleam@result:'try'(
glib@treelist:set(
erlang:element(2, Map@2),
Entry_pos@1,
{some, {entry, Key, Value}}
),
fun(Inner) ->
{ok,
begin
_record = Map@2,
{map,
Inner,
erlang:element(3, _record),
erlang:element(4, _record),
case Overwrite@1 of
true ->
erlang:element(5, Map@2);
false ->
erlang:element(5, Map@2) + 1
end,
erlang:element(6, _record)}
end}
end
)
end) end
).
-file("src/glib/map.gleam", 421).
?DOC(
" Checks whether the current map contains >= load entries\n"
" If so return a tuple containing the new resized map and the new hash of the \n"
" key we are currently processing\n"
" Otherwise just return the a tuple containing the original map and None to signify\n"
" no change to the capacity\n"
).
-spec check_capacity(map_(HYX), integer()) -> {ok,
{map_(HYX), gleam@option:option(integer())}} |
{error, nil}.
check_capacity(Map, Original_hash) ->
case {erlang:element(6, Map),
erlang:element(5, Map) >= ((erlang:element(3, Map) * erlang:element(
4,
Map
))
div 100)} of
{false, true} ->
gleam@result:'try'(
basic_rehash(Map, (erlang:element(3, Map) * 2) + 1),
fun(New_map) ->
{ok,
{begin
_record = New_map,
{map,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
false}
end,
{some,
fix_hash(
erlang:element(3, New_map),
Original_hash
)}}}
end
);
{_, _} ->
{ok, {Map, none}}
end.