A set of unique values.
Insert, remove, and query operations all take O(log n) time.
This implementation is based on
Skinney/elm-dict-exploration
,
except that it uses Sorter
instead of comparable
, so it permits keys
that are not comparable
.
Represents a set of unique values. So (Set Int)
is a set of integers and
(Set String)
is a set of strings.
empty : Sorter a -> Set a
Create an empty set.
singleton : Sorter a -> a -> Set a
Create a set with one value.
insert : a -> Set a -> Set a
Insert a value into a set.
remove : a -> Set a -> Set a
Remove a value from a set. If the value is not found, no changes are made.
isEmpty : Set a -> Basics.Bool
Determine if a set is empty.
memberOf : Set a -> a -> Basics.Bool
Return True
if the given value is in the given set.
size : Set a -> Basics.Int
Return the number of elements in a set.
eq : Set a -> Set a -> Basics.Bool
Check if two sets are equal
union : Sorter a -> Set a -> Set a -> Set a
Get the union of two sets. Keep all values.
toList : Set a -> List a
Convert a set into a list, sorted from lowest to highest.
fromList : Sorter a -> List a -> Set a
Convert a list into a set, removing any duplicates.
map : Sorter b -> (a -> b) -> Set a -> Set b
Map a function onto a set, creating a new set with no duplicates.
keepIf : (a -> Basics.Bool) -> Set a -> Set a
Only keep elements that pass the given test.
numbers =
Set.fromList [ -2, -1, 0, 1, 2, 3, 4, 5 ]
positives =
Set.keepIf (\num -> num > 0) numbers
evens =
Set.keepIf (\num -> num % 2 == 0) numbers
positiveEvens =
-- Intersection
Set.keepIf (Set.member evens) positives
dropIf : (a -> Basics.Bool) -> Set a -> Set a
Remove elements that pass the given test.
numbers =
Set.fromList [ -2, -1, 0, 1, 2, 3, 4, 5 ]
positives =
Set.dropIf (\num -> num <= 0) numbers
evens =
Set.dropIf (\num -> num % 2 == 1) numbers
positiveOdds =
-- Difference
Set.dropIf (Set.member evens) positives
foldl : (a -> b -> b) -> b -> Set a -> b
Fold over the values in a set, in order from lowest to highest.
foldr : (a -> b -> b) -> b -> Set a -> b
Fold over the values in a set, in order from highest to lowest.
partition : (a -> Basics.Bool) -> Set a -> ( Set a, Set a )
Create two new sets. The first contains all the elements that passed the given test, and the second contains all the elements that did not.