The HashSetFn functor
Author: John Reppy
Keywords: Standard ML, SML, SML/NJ Library

The SML of NJ Library
The `HashSetFn` functor

The `HashSetFn` functor provides an imperative, hash-table-based implementation of sets parameterized over a `Key` structure.

## Synopsis

    signature MONO_HASH_SET
    functor HashSetFn (Key : HASH_KEY) : MONO_HASH_SET

## Functor Argument Interface

    Key : HASH_KEY

## Functor Argument Description

`Key : HASH_KEY`

  A structure that implements the `HASH_KEY` signature, where `Key.hash_key` will be the type of the elements in the hash set.

## Interface

    structure Key : HASH_KEY

    type item = Key.hash_key
    type set

    val mkEmpty : int -> set

    val mkSingleton : item -> set

    val mkFromList : item list -> set

    val toList : set -> item list

    val add  : set * item -> unit
    val add' : item * set -> unit
    val addc : set -> item -> unit

    val addList : set * item list -> unit

    val addSet : set * set -> unit

    val subtract  : set * item -> unit
    val subtract' : item * set -> unit
    val subtractc : set -> item -> unit

    val subtractList : set * item list -> unit

    val subtractSet : set * set -> unit

    val delete : set * item -> bool

    val member : set * item -> bool

    val isEmpty : set -> bool

    val isSubset : (set * set) -> bool

    val disjoint : set * set -> bool

    val numItems : set ->  int

    val union : set * set -> set
    val intersection : set * set -> set
    val difference : set * set -> set

    val map : (item -> item) -> set -> set
    val mapPartial : (item -> item option) -> set -> set
    val app : (item -> unit) -> set -> unit
    val fold : (item * 'b -> 'b) -> 'b -> set -> 'b

    val partition : (item -> bool) -> set -> (set * set)

    val filter : (item -> bool) -> set -> unit

    val exists : (item -> bool) -> set -> bool
    val all : (item -> bool) -> set -> bool

    val find : (item -> bool) -> set -> item option

    val listItems : set -> item list
    val without : set * item -> unit

## Interface Description

`structure Key : HASH_KEY`

  This substructure is the argument structure, which defines the type of set elements, and hash and equality functions on the key type.

`type item = Key.hash_key`

  The type of items in the sets.

`type set`

  The type of imperative sets of items.

`val mkEmpty : int -> set`

  `mkEmpty n` creates an empty set that has initial space to store at least `n` items.

`val mkSingleton : item -> set`

  `mkSingleton item` creates a set with `item` as its only initial element.

`val mkFromList : item list -> set`

  `mkFromList items` creates a set with `items` as its initial elements.

`val toList : set -> item list`

  `toList set` returns a list of the items in `set`.

`val add : set * item -> unit`

  `add (set, item)` destructively adds the item to the set.

`val add' : item * set -> unit`

  `add (item, set)` destructively adds the item to the set.

`val addc : set -> item -> unit`

  `addc set item` destructively adds the item to the set.

`val addList : set * item list -> unit`

  `addList (set, items)` destructively adds the list of items to the set.

`val addSet : set * set -> unit`

  `addSet (set1, set2)` destructively adds the items of `set2` to `set1`.

`val subtract : set * item -> unit`

  `subtract (set, item)` removes the object `item` from `set`; it has no effect if `item` is not in `set`.

`val subtract' : item * set -> unit`

  `subtract (item, set)` removes the object `item` from `set`; it has no effect if `item` is not in `set`.

`val subtractc : set -> item -> unit`

  `subtractc set item` removes the object `item` from `set`; it has no effect if `item` is not in `set`.

`val subtractList : set * item list -> unit`

  `subtractList (set, items)` removes the `items` from `set`. This expression is equivalent to

      List.app (subtractc set) items

`val subtractSet : set * set -> unit`

  `subtractSet (set1, set2)` removes the `items` that are in `set2` from `set1`.

`val delete : set * item -> bool`

  `subtract (set, item)` removes the object `item` from `set` (if present) and returns `true` if the item was removed and `false` if it was not present.

`val member : set * item -> bool`

  `member (item, set)` returns `true` if, and only if, `item` is an element of `set`.

`val isEmpty : set -> bool`

  `isEmpty set` returns true if, and only if, `set` is empty.

`val disjoint : (set * set) -> bool`

  `isSubset (set1, set2)` returns true if, and only if, the two sets are disjoint.

`val isSubset : (set * set) -> bool`

  `isSubset (set1, set2)` returns true if, and only if, `set1` is a subset of `set2` (i.e., any element of `set1` is an element of `set2`).

`val numItems : set -> int`

  `numItems set` returns the number of items in the `set`.

`val union : set * set -> set`

  `union (set1, set2)` returns a new set that is the union of the two sets.

`val intersection : set * set -> set`

  `intersection (set1, set2)` returns a new set that is the intersection of the two sets.

`val difference : set * set -> set`

  `difference (set1, set2)` returns a new set that is the difference of the two sets; i.e., the set of items that are in `set1`, but not in `set2`.

`val map : (item -> item) -> set -> set`

  `map f set` creates a new set from the result of applying the function `f` to the elements of `set`. This expression is equivalent to

      mkFromList (List.map f (toList set))

`val mapPartial : (item -> item option) -> set -> set`

  `mapPartial f set` creates a new set from the result of applying the partial function `f` to the elements of `set`. This expression is equivalent to

      mkFromList (List.mapPartial f (toList set))

`val app : (item -> unit) -> set -> unit`

  `app f set` applies the function `f` to the items in `set`.

`val fold : (item * 'b -> 'b) -> 'b -> set -> 'b`

  `foldl f init set` folds the function `f` over the items in `set` using `init` as the initial value.

`val partition : (item -> bool) -> set -> (set * set)`

  `partition pred set` returns a pair of disjoint sets `(tSet, fSet)`, where the predicate `pred` returns true for every element of `tSet`, `false` for every element of `fSet`, and `set` is the union of `tSet` and `fSet`.

`val filter : (item -> bool) -> set -> unit`

  `filter pred set` removes any elements of set for which the predicate `pred` returns false.

`val exists : (item -> bool) -> set -> bool`

  `all pred set` returns `true` if, and only if, `pred item` returns true for all elements `item` in `set`. Elements are checked in an undefined order.

`val all : (item -> bool) -> set -> bool`

  `exists pred set` returns `true` if, and only if, there exists an element `item` in `set` such that `pred item` returns `true`. Elements are checked in an undefined order.

`val find : (item -> bool) -> set -> item option`

  `find pred set` returns `SOME item` if there exists an object `item` in the set for which `pred item` returns `true`; otherwise `NONE` is returned. Items are tested in an undefined order.

### Deprecated functions

`val without : set * item -> unit`

  Use `subtract` instead.

`val listItems : set -> item list`

  Use `toList` instead.

## See Also

`HASH_KEY`, `ORD_SET`, The Util Library

SML/NJ Version 110.99.9 (November 4, 2025)
Last updated 2025-11-04 15:48:25 UTC