total-maps-1.0.0.2: Dense and sparse total maps.

LicenseMIT
MaintainerPaweł Nowak <pawel834@gmail.com>
PortabilityGHC only
Safe HaskellNone
LanguageHaskell2010

Data.Total.Array.Subset

Description

Subset, dense, total map implemented as a vector.

Synopsis

Documentation

type Subset s k = Reifies s (Set k) Source

Subset s k means that s reifies a subset of k.

newtype TotalSubsetArray s k a Source

A total map from a subset s of keys k to values a, e.g. a restriction of a partial function k -> a to a subset of its domain on which the function is defined. Implemented as a vector.

n is equal to the number of keys.

Constructors

TotalSubsetArray (Vector a) 

Instances

Functor (TotalSubsetArray s k) 
Subset s k => Applicative (TotalSubsetArray s k)

Zippy applicative. Complexity: pure O(n), <*> O(n).

Foldable (TotalSubsetArray s k) 
Traversable (TotalSubsetArray s k) 
Subset s k => Distributive (TotalSubsetArray s k)

Complexity: distribute O(n * fmap)

(Ord k, Subset s k) => Representable (TotalSubsetArray s k)

Convert from and to a partial function that would be total if restricted to s.

Complexity: tabulate O(n), index O(log n)

Subset s k => Serial1 (TotalSubsetArray s k)

Complexity: serializeWith O(n), deserializeWith O(n)

Subset s k => Keyed (TotalSubsetArray s k)

Complexity: mapWithKey O(n)

Zip (TotalSubsetArray s k)

Complexity: all O(n)

Subset s k => ZipWithKey (TotalSubsetArray s k)

Complexity: all O(n)

(Ord k, Subset s k) => Indexable (TotalSubsetArray s k)

Complexity: index O(log n)

(Ord k, Subset s k) => Lookup (TotalSubsetArray s k)

Complexity: lookup O(log n)

(Ord k, Subset s k) => Adjustable (TotalSubsetArray s k)

Complexity: adjust O(n)

Subset s k => FoldableWithKey (TotalSubsetArray s k)

Complexity: foldMapWithKey O(n)

Subset s k => TraversableWithKey (TotalSubsetArray s k)

Complexity: traverseWithKey O(n)

Subset s k => Metric (TotalSubsetArray s k)

Complexity: all O(n)

Subset s k => Additive (TotalSubsetArray s k)

Complexity: all O(n)

Eq a => Eq (TotalSubsetArray s k a) 
Ord a => Ord (TotalSubsetArray s k a) 
Read a => Read (TotalSubsetArray s k a) 
Show a => Show (TotalSubsetArray s k a) 
(Subset s k, Serial a) => Serial (TotalSubsetArray s k a)

Complexity: serialize O(n), deserialize O(n)

type Rep (TotalSubsetArray s k) = k 
type Key (TotalSubsetArray s k) = k