Documentation

The empty HtsSet

A HtsSet with an element

Is the HtsSet is empty?

null empty == True
null (singleton "a") == False

The number of elements in the HtsSet

size empty == 0
size (singleton "a") == 1

The HtsSet is contain an element?

member (Proxy :: Proxy String) empty == False
member (Proxy :: Proxy String) (singleton "a") == True

The HtsSet is not contain an element?

The HtsSet is contain a same type of element?

let hs = insert "a" $ insert (2 :: Int) $ insert 'c' $ empty
existTypeOf "string" hs == True

The HtsSet is contain a same type of element? (by proxy)

The HtsSet is contain a same type of element? (by fixed proxy)

Apply a function to an element with a default value

appl "no ABC" (:"BC") $ singleton 'A' == "ABC"
appl "no ABC" (:"BC") $ singleton "s" == "no ABC"

appl specialization

Insert a new value in the HtsSet. If the a elem is already present in the HtsSet with type, the associated value is replaced with the supplied value

insert "a" $ insert (2 :: Int) $ insert 'c' $ empty

Lookup a value from in the HtsSet

let hs = insert "a" $ insert (2 :: Int) $ insert 'c' $ empty
lookup hs == Just "a"
lookup hs == Just (2 :: Int)
but
lookup hs == Just 2 -- is False! Because the type of 2 is Num t => t not Int

Lookup a value from in the HtsSet with a default value

Update a value in HtsSet

let hs = insert "a" $ insert (2 :: Int) $ insert 'c' $ empty
let hs' = update (++"b") hs
lookup hs' == Just "ab"

Delete an element by type

(member 'c' $ deleteByType 'b' $ singleton 'c') == False

Delete an element by type (by proxy)

(member 'c' $ deleteByTypeP (Proxy :: Proxy Char) $ singleton 'c') == False

Delete an element by type (by fixed proxy)

Delete an element by condition

Helper heterogeneous list for comfortable HtsSet building (with append and fill)

let hs = fill ("a" :+ 'c' :+ True :+ ())
lookup hs == Just 'c'
use () to close the list
lookup hs == Just () -- is False!
let hs' = fill ("a" :+ 'c' :+ True :+ () :+ ())
lookup hs' == Just () -- is Ok

Proxy is a type that holds no data, but has a phantom parameter of arbitrary type (or even kind). Its use is to provide type information, even though there is no value available of that type (or it may be too costly to create one).

Historically, Proxy :: Proxy a is a safer alternative to the 'undefined :: a' idiom.

>>> Proxy :: Proxy (Void, Int -> Int)
Proxy

Proxy can even hold types of higher kinds,

>>> Proxy :: Proxy Either
Proxy

>>> Proxy :: Proxy Functor
Proxy

>>> Proxy :: Proxy complicatedStructure
Proxy