Hoogle Search

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

package melf

An Elf parser Parser for ELF object format
package mem-info

Print the core memory usage of programs A utility to accurately report the core memory usage of programs. This is a clone of ps_mem, which is written in python The package provides:
- an executable command printmem that is like ps_mem with extra features
- a library to enable core memory tracking on linux in haskell programs
See the README for further details
package memcache

A memcached client library. A client library for a Memcached cluster. Memcached is an in-memory key-value store typically used as a distributed and shared cache. Clients connect to a group of Memcached servers and perform out-of-band caching for things like SQL results, rendered pages, or third-party APIs. It supports the binary Memcached protocol and SASL authentication. No support for the ASCII protocol is provided. It supports connecting to a single, or a cluster of Memcached servers. When connecting to a cluser, consistent hashing is used for routing requests to the appropriate server. Timeouts, retrying failed operations, and failover to a different server are all supported. Complete coverage of the Memcached protocol is provided except for multi-get and other pipelined operations. Basic usage is:
```
import qualified Database.Memcache.Client as M

mc <- M.newClient [M.ServerSpec "localhost" "11211" M.NoAuth] M.def
M.set mc "key" "value" 0 0
v <- M.get mc "key"
```
You should only need to import Database.Memcache.Client, but for now other modules are exposed.
package mempack

Short description Please see the README on GitHub at https://github.com/lehins/mempack#readme
package mergeful-persistent

Support for using mergeful from persistent-based databases Support for using mergeful from persistent-based databases
package mergeless-persistent

Support for using mergeless from persistent-based databases Support for using mergeless from persistent-based databases
package merkle-tree

An implementation of a Merkle tree and merkle tree proofs of inclusion An implementation of a Merkle tree and merkle tree proofs of inclusion
package mersenne-random

Generate high quality pseudorandom numbers using a SIMD Fast Mersenne Twister The Mersenne twister is a pseudorandom number generator developed by Makoto Matsumoto and Takuji Nishimura that is based on a matrix linear recurrence over a finite binary field. It provides for fast generation of very high quality pseudorandom numbers This library uses SFMT, the SIMD-oriented Fast Mersenne Twister, a variant of Mersenne Twister that is much faster than the original. It is designed to be fast when it runs on 128-bit SIMD. It can be compiled with either SSE2 and PowerPC AltiVec support, to take advantage of these instructions.
```
cabal install -fuse_sse2
```
On an x86 system, for performance win. By default the period of the function is 2^19937-1, however, you can compile in other defaults. Note that this algorithm on its own is not cryptographically secure. For more information about the algorithm and implementation, see the SFMT homepage, http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html and, Mutsuo Saito and Makoto Matsumoto, /SIMD-oriented Fast Mersenne Twister: a 128-bit Pseudorandom Number Generator/, in the Proceedings of MCQMC2006, here: http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/ARTICLES/sfmt.pdf
package metrics

High-performance application metric tracking A port of Coda Hale's excellent metrics library for the JVM https://github.com/codahale/metrics For motivation about why you might want to track application metrics, check Coda's talk: http://www.youtube.com/watch?v=czes-oa0yik Interesting portions of this package's documentation were also appropriated from the metrics library's documentation: http://metrics.codahale.com

Tiny QuickCheck test library with minimal dependencies A tiny (1 module, <500 lines) property-based (and unit) testing library with minimal dependencies. Instead of reinventing the wheel (https://xkcd.com/927), we use a RSpec/HSpec-like DSL and run tests with QuickCheck. For many use-cases, microspec is a drop-in replacement for hspec.

import Test.Microspec

main :: IO ()
main = microspec $ do
describe "replicate" $ do
it "doubles with 2" $
replicate 2 'x' === "xx"
it "creates a list of the right size" $
\(Positive n) -> length (replicate n 'x') === n

describe "reverse" $ do
it "reverse . reverse === id" $ \l ->
reverse (reverse l) === (l :: [Int])

describe "tail" $
it "length is -1" $ \(NonEmpty l) ->
length (tail l :: [Int]) === length l - 1

describe "solve the halting problem" $
pending

Page 217 of many | Previous | Next