cats.collections
Members list
Type members
Classlikes
Attributes
Attributes
A fast, immutable BitSet.
A fast, immutable BitSet.
A Bitset is a specialized type of set that tracks the Int values it contains: for each integer value, a BitSet uses a single bit to track whether the value is present (1) or absent (0). Bitsets are often sparse, since "missing" bits can be assumed to be zero.
Unlike scala's default immutable this BitSet does not do a full copy on each added value.
Internally the implementation is a tree. Each leaf uses an Array[Long] value to hold up to 2048 bits, and each branch uses an Array[BitSet] to hold up to 32 subtrees (null subtrees are treated as empty).
Bitset treats the values it stores as 32-bit unsigned values, which is relevant to the internal addressing methods as well as the order used by iterator.
The benchmarks suggest this bitset is MUCH faster than Scala's built-in bitset for cases where you may need many modifications and merges, (for example in a BloomFilter).
Attributes
- Companion
- object
- Source
- BitSet.scala
- Supertypes
- Self type
Attributes
- Companion
- class
- Source
- BitSet.scala
- Supertypes
- Self type
-
BitSet.type
Dequeue - A Double Ended Queue
Dequeue - A Double Ended Queue
Front Back
<- uncons --------- unsnoc -> cons -> --------- <- snoc
Based on the Bankers Double Ended Queue as described by C. Okasaki in "Purely Functional Data Structures"
A queue that allows items to be put onto either the front (cons) or the back (snoc) of the queue in constant time, and constant time access to the element at the very front or the very back of the queue. Dequeuing an element from either end is constant time when amortized over a number of dequeues.
This queue maintains an invariant that whenever there are at least two elements in the queue, neither the front list nor back list are empty. In order to maintain this invariant, a dequeue from either side which would leave that side empty constructs the resulting queue by taking elements from the opposite side
Attributes
- Companion
- object
- Source
- Dequeue.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Dequeue.scala
- Supertypes
- Self type
-
Dequeue.type
Attributes
- Source
- Dequeue.scala
- Supertypes
- Known subtypes
-
object Dequeue.type
Discrete Interval Encoding Tree (Diet).
Discrete Interval Encoding Tree (Diet). It stores subsets of types having a total order, a predecessor and a successor function described by Discrete[A]
Diet is a binary search tree where each node contains a range of values and the set of all nodes is a set of disjoint sets.
In the best case, when there are no "holes" in the stored set, the interval representation consists of just one single interval (node) and finding, inserting and deleting operations are O(1). In the worse case, where there are not two adjacent elements in the set, the representation is equivalent to a binary search tree.
Attributes
- Companion
- object
- Source
- Diet.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Diet.scala
- Supertypes
- Self type
-
Diet.type
Represent discrete operations that can be performed on A
Represent discrete operations that can be performed on A
Attributes
- Companion
- object
- Source
- Discrete.scala
- Supertypes
Attributes
- Companion
- trait
- Source
- Discrete.scala
- Supertypes
- Self type
-
Discrete.type
Attributes
- Companion
- object
- Source
- DisjointSets.scala
- Supertypes
Attributes
- Companion
- class
- Source
- DisjointSets.scala
- Supertypes
- Self type
-
DisjointSets.type
Attributes
- Source
- DisjointSets.scala
- Supertypes
- Known subtypes
-
object DisjointSets.type
An immutable hash map using cats.kernel.Hash for hashing.
An immutable hash map using cats.kernel.Hash for hashing.
Implemented using the CHAMP encoding.
Type parameters
- K
-
the type of the keys contained in this hash map.
- V
-
the type of the values contained in this hash map.
Value parameters
- hashKey
-
the cats.kernel.Hash instance used for hashing keys.
Attributes
- See also
- Companion
- object
- Source
- HashMap.scala
- Supertypes
Attributes
- Companion
- class
- Source
- HashMap.scala
- Supertypes
- Self type
-
HashMap.type
Attributes
- Source
- HashMap.scala
- Supertypes
An immutable hash set using cats.kernel.Hash for hashing.
An immutable hash set using cats.kernel.Hash for hashing.
Implemented using the CHAMP encoding.
Type parameters
- A
-
the type of the elements contained in this hash set.
Value parameters
- hash
-
the cats.kernel.Hash instance used for hashing values.
Attributes
- See also
- Companion
- object
- Source
- HashSet.scala
- Supertypes
Attributes
- Companion
- class
- Source
- HashSet.scala
- Supertypes
- Self type
-
HashSet.type
Attributes
- Source
- HashSet.scala
- Supertypes
Attributes
- Source
- HashSet.scala
- Supertypes
Heap is a Purely Functional Binary Heap.
Heap is a Purely Functional Binary Heap. Binary Heaps are not common in the functional space, especially because their implementation depends on mutable arrays in order to gain in performance. This functional binary heap is based on Vladimir Kostyukov's paper and it does support the basic operations on a heap without compromising performance.
It is important to note that we can, in fact, to create the Binary Heap in order O(n) from a List using the function heapify.
Attributes
- Companion
- object
- Source
- Heap.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Heap.scala
- Supertypes
- Self type
-
Heap.type
A PairingHeap is a heap with excellent empirical performance.
A PairingHeap is a heap with excellent empirical performance.
See: https://en.wikipedia.org/wiki/Pairing_heap in particular: https://en.wikipedia.org/wiki/Pairing_heap#Summary_of_running_times
Additionally, it supports an efficient O(1) combine operation
Attributes
- Companion
- object
- Source
- PairingHeap.scala
- Supertypes
Attributes
- Companion
- class
- Source
- PairingHeap.scala
- Supertypes
- Self type
-
PairingHeap.type
This is a typeclass for Heap-like data-structures which are not totally ordered sets, but can produce the minimimum value, add and remove items.
This is a typeclass for Heap-like data-structures which are not totally ordered sets, but can produce the minimimum value, add and remove items.
Attributes
- Companion
- object
- Source
- PartiallyOrderedSet.scala
- Supertypes
Attributes
- Companion
- trait
- Source
- PartiallyOrderedSet.scala
- Supertypes
- Self type
-
PartiallyOrderedSet.type
An intensional set, which is a set which instead of enumerating its elements as a extensional set does, it is defined by a predicate which is a test for membership.
An intensional set, which is a set which instead of enumerating its elements as a extensional set does, it is defined by a predicate which is a test for membership.
Attributes
- Companion
- object
- Source
- Predicate.scala
- Supertypes
- Self type
-
Predicate[A]
Attributes
- Companion
- class
- Source
- Predicate.scala
- Supertypes
- Self type
-
Predicate.type
Attributes
- Source
- Predicate.scala
- Supertypes
- Known subtypes
-
object Predicate.type
Represent an inclusive range [x, y] that can be generated by using discrete operations
Represent an inclusive range [x, y] that can be generated by using discrete operations
Attributes
- Companion
- object
- Source
- Range.scala
- Supertypes
Attributes
- Companion
- class
- Source
- Range.scala
- Supertypes
- Self type
-
Range.type
Implementation of "Purely Functional Random Access Lists" by Chris Okasaki.
Implementation of "Purely Functional Random Access Lists" by Chris Okasaki. This gives O(1) cons and uncons, and 2 log_2 N lookup.
A consequence of the log N complexity is that naive recursion on the inner methods will (almost) never blow the stack since the depth of the structure is log N, this greatly simplifies many methods. A key example is that unlike List, using a TreeList you can sequence and traverse very large lists without blowing the stack since the stack depth is only log N.
This data-structure is useful when you want fast cons and uncons, but also want to index. It does not have an optimized concatenation.
Attributes
- Companion
- object
- Source
- TreeList.scala
- Supertypes
Attributes
- Companion
- class
- Source
- TreeList.scala
- Supertypes
- Self type
-
TreeList.type
Deprecated types
Attributes
- Deprecated
- true
- Source
- package.scala
Value members
Deprecated fields
Attributes
- Deprecated
- true
- Source
- package.scala