Haskell Data Structures

A tasty Haskell front-end framework

A dependently typed functional programming language and proof assistant

Assorted concrete container types

Extensible Records

A distribution of the 'containers' package, with all modules exposed.

A framework for generating singleton types

Implementation of Univalence in Cubical Sets

Packing and unpacking flat tables.

Bulk array representations and operators.

Low-level parallel operators on bulk random-accessble arrays.

Scalar data types and conversions.

A Haskell version of an Ethereum client

Classes and data structures for working with data-kind indexed types

A language based on homotopy type theory with an interval type

Pure priority search queues

Anonymous records and overloaded labels

Distributive functors -- Dual to Traversable

Compiles Clafer models to other formats

Type-level sets and finite maps (with value-level counterparts)

A Haskell 98 logically uninhabited data type

A purely functional and persistent hash map

A library of efficient, purely-functional data structures (API)

Keyed container types with verified keys.

A space-efficient set data structure.

The Data.MultiSet container type

Asymptotically optimal Brodal/Okasaki heaps.

Anonymous extensible records

Efficient relational queries on Haskell sets.

claferIG is an interactive tool that generates instances of Clafer models.

R-Tree is a spatial data structure similar to Quadtrees or B-Trees.

Generic strict finger-tree structure

Extensions to Data.Map

Bindings to the igraph C library.

Very strict CPS'd transformers

Dependently typed elimination functions using singletons

Composition trees for arbitrary monoids.

Syntax sugar for defining maps

Plugin and base library to support supermonads in Haskell

An efficient finite map from (byte)strings to values.

Efficient relational queries on Haskell sets.

Simple functional ring type.

Support for image reading and writing of Repa arrays using in-place FFI calls

Program to derive type class instances

Program to derive type class instances

Typechecking terms of the Edinburgh Logical Framework (LF).

Combinators for unorthodox structure composition

Type composition classes & instances

Heaps in Haskell

A backend agnostic, concurrent BTree

Combinators for operating with selections over an underlying functor

Regional memory pointers

A modified Merkle Patricia DB

An efficient implementation of maps from strings to arbitrary values

Open type representations and dynamic types

Ethereum Recursive Length Prefix Encoding

A library for permutations and combinations.

A Ethereum contract analyzer.

Generic finger-tree structure, with example instances

Styled console text output using ANSI escape sequences.

Type-safe file handling

Combinators for unorthodox function composition

Queues with verified and unverified versions.

Graphs and networks library

Render just the Agda snippets of a literate Agda file to HTML

Boxed and unboxed arrays for monad transformers

Prototypical type checker for Type Theory with Sized Natural Numbers

Optimised list functions for doing index-related things

BK-tree implementation

Type-safe communication with USB devices.

Monoids with holes.

type-level binary search trees in haskell

Permissions for bookkeeper records

Memoization combinators using arrays for finite sub-domains of functions

Types representing line and column positions and ranges in text files.

Perform fft with repa via FFTW

"Ties the knot" on a given set of structures that reference each other by keys.

bidirectional arrows, bijective functions, and invariant functors

Reading and writing sound files with repa arrays

Extends safer-file-handles with ByteString operations

Subword graph implementation

Maps and sets of partial orders

Extends safer-file-handles with Text operations

Simple and moderately efficient suffix array implementation

The basic stack type

Efficient representable functors

Perfect minimal hashing implementation in native Haskell

Efficient alternating finger trees

Friendly helpers for your recursion schemes.

A simple multi-way tree data structure.

A few more collections

Packed, strict nibble arrays with a list interface (ByteString for nibbles)

Conceptual modelling support for Haskell

Helps when going "seed values" -> alternatives and optional -> answers