counter - v1.0.2

counter

Types

Counter

opaque </>

A Counter is a specialized dictionary used for counting the occurrences of items. Counter is implemented using the gleam/dict module.

pub opaque type Counter(a)

Functions

add

</> 
pub fn add(
  counter_1: Counter(a),
  counter_2: Counter(a),
) -> Counter(a)

Add the counts from two Counters into a new Counter.

elements

</> 
pub fn elements(counter: Counter(a)) -> List(a)

Returns a non-unique list of all the items in the Counter. Each item will be repeated in the list the number of times it was inserted into the Counter. Do not write code that relies on the order elements are returned by this function as it may change in later versions of Gleam or Erlang.

from_dict

</> 
pub fn from_dict(d: Dict(a, Int)) -> Counter(a)

Creates a Counter from a gleam/dict of item-count pairs.

from_list

</> 
pub fn from_list(items: List(a)) -> Counter(a)

Creates a Counter from a list of items.

get

</> 
pub fn get(counter: Counter(a), item: a) -> Int

Returns the number of times an item has been inserted into the Counter.

insert

</> 
pub fn insert(counter: Counter(a), item: a) -> Counter(a)

Inserts an item into the Counter.

keys

</> 
pub fn keys(counter: Counter(a)) -> List(a)

Returns a list of all the unique items in the Counter. Do not write code that relies on the order keys are returned by this function as it may change in later versions of Gleam or Erlang.

most_common

</> 
pub fn most_common(counter: Counter(a)) -> List(#(a, Int))

Returns a list containing the item-count tuples, sorted by count in descending order. If n is None, the entire list is returned. If n is Some, a list the top n most-common items is returned. Returns a list containing all item-count tuples, sorted by count, in descending order.

most_common_n

</> 
pub fn most_common_n(
  counter: Counter(a),
  n: Int,
) -> List(#(a, Int))

Returns a list of item-count tuples containing the top n most frequent items, sorted by count, in descending order.

new

</> 
pub fn new() -> Counter(a)

Creates a new empty Counter.

subtract

</> 
pub fn subtract(
  counter_1: Counter(a),
  counter_2: Counter(a),
) -> Counter(a)

Subtracts the counts in the second Counter from the first Counter, returning a new Counter with the results. Only items present in both Counters will be used when subtracting counts from the first Counter and any item with a count of zero or less will be omitted from the new Counter.

to_dict

</> 
pub fn to_dict(counter: Counter(a)) -> Dict(a, Int)

Returns the underlying gleam/dict of the Counter.

to_list

</> 
pub fn to_list(counter: Counter(a)) -> List(#(a, Int))

Returns a list of item-count tuples. Do not write code that relies on the order tuples are returned by this function as it may change in later versions of Gleam or Erlang.

total

</> 
pub fn total(counter: Counter(a)) -> Int

Returns the sum of all counts in the Counter.

unique_size

</> 
pub fn unique_size(counter: Counter(a)) -> Int

Returns the number of unique items in the Counter.

update

</> 
pub fn update(counter: Counter(a), items: List(a)) -> Counter(a)

Updates the Counter from a list of items.

values

</> 
pub fn values(counter: Counter(a)) -> List(Int)

Returns a list of all the counts in the Counter. Do not write code that relies on the order values are returned by this function as it may change in later versions of Gleam or Erlang.

✨ Search Document