Parses .eventlog files emitted by GHC 8.0.2 and later. Includes the ghc-events tool permitting, in particular, to dump an event log file as text.

Euterpea is a domain-specific language embedded in Haskell for computer music research, education, and development, providing both note-level and signal-level abstractions. It is a descendant of Haskore and HasSound, and is intended for both educational purposes as well as serious computer music applications. Euterpea is a wide-spectrum DSL, suitable for high-level music representation, algorithmic composition, and analysis; mid-level concepts such as MIDI; and low-level audio processing, sound synthesis, and instrument design.

This is a Haskell module for PortMidi audio library, which supports real-time MIDI input and output.

Several classes that extend the Arrow class, and some transformers that implement or lift these classes.

Alga is a library for algebraic construction and manipulation of graphs in Haskell.

Extends <http://hackage.haskell.org/package/process>. Read process input and output as ByteStrings or Text, or write your own ProcessOutput instance. Lazy process input and output. ProcessMaker class for more flexibility in the process creation API.

HUnit support for the Tasty test framework. . Note that this package does not depend on HUnit but implements the relevant subset of its API. The name is a legacy of the early versions of tasty-hunit and of test-framework-hunit, which did depend on HUnit.

This package provides a fast lossless compression algorithm, targeting real-time compression scenarios at zlib-level and better compression ratios.

This package provides portable implementations of parts of the unix package. This package re-exports the unix package when available. When it isn't available, portable implementations are used.

Write short and concise generic instances of type classes. one-liner is particularly useful for writing default implementations of type class methods.

This package normalizes variations in the interface for inspecting datatype information via Template Haskell so that packages and support a single, easier to use informational datatype while supporting many versions of Template Haskell.

This package provides a Haskell library for working with files and directories. Includes code for pattern matching, finding files, modifying file contents, and more.

This package provides efficient vector-based hashtable implementation similar to .NET Generic Dictionary implementation (at the time of 2015). . See "Data.Vector.Hashtables" for documentation.

Please see README.md.

This package offers a version of <https://hackage.haskell.org/package/base/docs/GHC-Generics.html GHC.Generics> with two important improvements: . 1. The @to@, @from@, @to1@, and @from1@ methods have multiplicity-polymorphic types, allowing them to be used with either traditional Haskell code or linearly typed code. . 2. The representations used for @Generic1@ are modified slightly. As a result, @to1@ and @from1@ never need to use @fmap@. This can <https://gitlab.haskell.org/ghc/ghc/-/issues/15969 greatly improve performance>, and it is <https://github.com/tweag/linear-base/pull/316 necessary to support multiplicity polymorphism>. A smaller change, approximately <https://gitlab.haskell.org/ghc/ghc/-/issues/7492 as proposed by spl>, reduces the number of instances that must be written to actually use @Generic1@ for deriving instances of other classes. . For more details, see the "Generics.Linear" documentation. . The implementation is based on the @generic-deriving@ package, first described in the paper . * /A generic deriving mechanism for Haskell/. Jose Pedro Magalhaes, Atze Dijkstra, Johan Jeuring, and Andres Loeh. Haskell'10. . This library is organized as follows: . * "Generics.Linear" defines the core functionality for generics, including the multiplicity-polymorphic @Generic(1)@ classes and a replacement for the @:.:@ composition type. . * "Generics.Linear.TH" implements Template Haskell functionality for deriving instances of @Generic(1)@. . * "Generics.Linear.Unsafe.ViaGHCGenerics" offers @DerivingVia@ targets to derive @Generic@ and @Generic1@ instances from @"GHC.Generics".'GHC.Generics.Generic'@. Because these instances necessarily use unsafe coercions, their use will likely inhibit full optimization of code using them. . Educational code: the educational modules exported by <https://hackage.haskell.org/package/generic-deriving generic-deriving> have been copied into the @tests\/Generic\/Deriving@ directory in this repository, with the very few modifications required to accommodate the differences between the @Generic1@ representations here and in @base@. All the same caveats apply as in the originals; see that package's @README@.

QuickCheck support for the Tasty test framework. .

This package provides functions for creating temporary files and directories.

This package provides a minimal pretty-printing library for Show instances in Haskell.

Efficient and optimized non-empty versions of types from /containers/. Inspired by /non-empty-containers/ library, except attempting a more faithful port (with under-the-hood optimizations) of the full /containers/ API. Also contains a convenient typeclass abstraction for converting betwewen non-empty and possibly-empty variants. See README.md for more information.

Generating shrinkable, showable functions with `hedgehog`. See `Hedgehog.Function` for example usages.

This package contains simple wrappers around Data.IntMap and Data.IntSet with Enum keys and elements respectively. Especially useful for Int's wrapped with `newtype`.

This package provides a fancy test runner and support for «golden testing». . A golden test is an IO action that writes its result to a file. To pass the test, this output file should be identical to the corresponding «golden» file, which contains the correct result for the test. . The test runner allows filtering tests using regexes, and to interactively inspect the result of golden tests. . This package is a heavily extended fork of tasty-golden.

Generic implementations of standard type classes. Operations on generic representations to help using "GHC.Generics". See README.

Modern lightweight library for infinite lists with fusion: . * API similar to "Data.List". * No dependencies other than `base`. * Top performance, driven by fusion. * Avoid dangerous instances like `Foldable`. * Use `NonEmpty` where applicable. * Use `Word` for indices. * Be lazy, but not too lazy. . @ \-# LANGUAGE PostfixOperators #-\ import Data.List.Infinite (Infinite(..), (...), (....)) import qualified Data.List.Infinite as Inf @.