Set

A set of unique values. The values can be any comparable type. This includes Int, Float, Time, Char, String, and tuples or lists of comparable types.

Insert, remove, and query operations all take O(log n) time.

Sets

type Set t = Set t

Represents a set of unique values. So (Set Int) is a set of integers and (Set String) is a set of strings.

Build

empty :: Set a

Create an empty set.

singleton :: comparable -> Set comparable

Create a set with one value.

insert :: Ord comparable => comparable -> Set comparable -> Set comparable

Insert a value into a set.

remove :: Ord comparable => comparable -> Set comparable -> Set comparable

Remove a value from a set. If the value is not found, no changes are made.

Query

isEmpty :: Set a -> Bool

Determine if a set is empty.

member :: Ord comparable => comparable -> Set comparable -> Bool

Determine if a value is in a set.

size :: Set a -> Int

Determine the number of elements in a set.

Combine

union :: Ord comparable => Set comparable -> Set comparable -> Set comparable

Get the union of two sets, preferring the first set when equal elements are encountered.

In Elm it's not possible to have two comparable elements that are not equal, but it is possible in Haskell.

intersect :: Ord comparable => Set comparable -> Set comparable -> Set comparable

Get the intersection of two sets, preferring the first set when equal elements are encountered.

In Elm it's not possible to have two comparable elements that are not equal, but it is possible in Haskell.

diff :: Ord comparable => Set comparable -> Set comparable -> Set comparable

Get the difference between the first set and the second. Keeps values that do not appear in the second set.

Lists

toList :: Set a -> List a

Convert a set into a list, sorted from lowest to highest.

fromList :: Ord comparable => List comparable -> Set comparable

Convert a list into a set, removing any duplicates.

Transform

map :: Ord comparable2 => (comparable -> comparable2) -> Set comparable -> Set comparable2

Map a function onto a set, creating a new set with no duplicates.

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.

filter :: (comparable -> Bool) -> Set comparable -> Set comparable

Only keep elements that pass the given test.

 import Set exposing (Set)

 numbers : Set Int
 numbers =
   Set.fromList [-2,-1,0,1,2]

 positives : Set Int
 positives =
   Set.filter (\x -> x > 0) numbers

 -- positives == Set.fromList [1,2]

partition :: (comparable -> Bool) -> Set comparable -> (Set comparable, Set comparable)

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.