Hoogle Search

Within LTS Haskell 24.64 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

package bitvec

Space-efficient bit vectors A newtype over Bool with a better Vector instance: 8x less memory, up to 3500x faster. The vector package represents unboxed arrays of Bools spending 1 byte (8 bits) per boolean. This library provides a newtype wrapper Bit and a custom instance of an unboxed Vector, which packs bits densely, achieving an 8x smaller memory footprint. The performance stays mostly the same; the most significant degradation happens for random writes (up to 10% slower). On the other hand, for certain bulk bit operations Vector Bit is up to 3500x faster than Vector Bool.
Thread safety
- Data.Bit is faster, but writes and flips are not thread-safe. This is because naive updates are not atomic: they read the whole word from memory, then modify a bit, then write the whole word back. Concurrently modifying non-intersecting slices of the same underlying array may also lead to unexpected results, since they can share a word in memory.
- Data.Bit.ThreadSafe is slower (usually 10-20%), but writes and flips are thread-safe. Additionally, concurrently modifying non-intersecting slices of the same underlying array works as expected. However, operations that affect multiple elements are not guaranteed to be atomic.
Similar packages
- bv and bv-little do not offer mutable vectors.
- array is memory-efficient for Bool, but lacks a handy Vector interface and is not thread-safe.
package blas-ffi

Auto-generated interface to Fortran BLAS BLAS is a package for efficient basic linear algebra operations. The reference implementation is written in FORTRAN. This is an automatically generated low-level interface. We provide bindings to functions of all variants for Float, Double, Complex Float and Complex Double. We do not use TemplateHaskell nor HSC nor CHS, but instead Haskell 98 code generated by the custom lapack-ffi-tools package.
package blaze-textual

Fast rendering of common datatypes A library for efficiently rendering Haskell datatypes to bytestrings. Note: if you use GHCi or Template Haskell, please see the README file for important details about building this package, and other packages that depend on it: https://github.com/swamp-agr/blaze-textual#readme
package bmp

Read and write uncompressed BMP image files. Read and write uncompressed BMP image files. 100% robust Haskell implementation.
package bound

Making de Bruijn Succ Less We represent the target language itself as an ideal monad supplied by the user, and provide a Scope monad transformer for introducing bound variables in user supplied terms. Users supply a Monad and Traversable instance, and we traverse to find free variables, and use the Monad to perform substitution that avoids bound variables. Slides describing and motivating this approach to name binding are available online at: http://www.slideshare.net/ekmett/bound-making-de-bruijn-succ-less The goal of this package is to make it as easy as possible to deal with name binding without forcing an awkward monadic style on the user. With generalized de Bruijn term you can lift whole trees instead of just applying succ to individual variables, weakening the all variables bound by a scope and greatly speeding up instantiation. By giving binders more structure we permit easy simultaneous substitution and further speed up instantiation.
package byte-order

Portable big-endian and little-endian conversions This library provides an interface to portably work with byte arrays whose contents are known to be of a fixed endianness. There are two ways to use this module. See the System.ByteOrder module for more documentation.
package bytebuild

Build byte arrays This is similar to the builder facilities provided by Data.ByteString.Builder. It is intended to be used in situations where the following apply:
- An individual entity will be serialized as a small number of bytes (less than 512).
- A large number (more than 32) of entities will be serialized one after another without anything between them.
Unlike builders from the bytestring package, these builders do not track their state when they run out of space. A builder that runs out of space simply aborts and is rerun at the beginning of the next chunk. This strategy for building is suitable for most CSVs and several line protocols (carbon, InfluxDB, etc.).
package byteorder

Exposes the native endianness or byte ordering of the system. This package is for working with the native byte-ordering of the system.
package bytesmith

Nonresumable byte parser Parse bytes as fast as possible. This is a nonresumable parser that aggresively uses UnboxedSums to avoid performing any allocations.
package bytestring-lexing

Efficiently parse and produce common integral and fractional numbers. The bytestring-lexing package offers extremely efficient ByteString parsers for some common lexemes: namely integral and fractional numbers. In addition, it provides efficient serializers for (some of) the formats it parses. As of version 0.3.0, bytestring-lexing offers the best-in-show parsers for integral values. (According to the Warp web server's benchmark of parsing the Content-Length field of HTTP headers.) And as of version 0.5.0 it offers (to my knowledge) the best-in-show parser for fractional/floating numbers. Some benchmarks for this package can be found at: https://github.com/wrengr/bytestring-lexing/tree/master/bench/html

Page 59 of many | Previous | Next

Hoogle Search

Thread safety

Similar packages