Documentation

The empty HtsCSet

The empty HtsCSet with proxy

A HtsCSet with an element

A HtsCSet with an element with proxy

Is the HtsCSet 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 HtsCSet is contain a same type of element?

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

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

The HtsCSet 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 HtsCSet. If the a elem is already present in the HtsCSet 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 HtsCSet

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 HtsCSet with a default value

Update a value in HtsCSet

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 :: HtsCSet Show) == Just 'c'
use () to close the list
lookup (hs :: HtsCSet Show) == Just () -- is False!
let hs' = fill ("a" :+ 'c' :+ True :+ () :+ ())
lookup (hs' :: HtsCSet Show) == 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