expiring-mvar provides the type ExpiringMVar. ExpiringMVar is a container for a single value. When creating an ExpiringMVar, a thread is spawned which deletes the value held in the ExpiringMVar after a given period of time. The timer can be reset, cancelled, or restarted with a new time amount.
Synchronous and Asynchronous exceptions which are explicit in the type signature. The first ones are very similar to Either and Control.Monad.Error.ErrorT. The second ones are used for System.IO.readFile and System.IO.hGetContents. This package is a proposal for improved exception handling in Haskell. It strictly separates between handling of exceptional situations (file not found, invalid user input, see http://www.haskell.org/haskellwiki/Exception) and (programming) errors (division by zero, index out of range, see http://www.haskell.org/haskellwiki/Error). Handling of the first one is called "exception handling", whereas handling of errors is better known as "debugging".
For applications see the packages midi, spreadsheet, http-monad.
Although I'm not happy with the identifier style of the Monad Transformer Library (partially intended for unqualified use) I have tried to adopt it for this library, in order to let Haskell programmers get accustomed easily to it.
To do: Because many people requested it, we will provide a bracket function that frees a resource both when an exception and an error occurs, that is, it combines exception handling and debugging. However note that freeing resources in case of an error is dangerous and may cause further damage.
The module System.IO.ExplicitIOModes exports a Handle to a file which is parameterized with the IOMode the handle is in. All operations on handles explicitly specify the needed IOMode. This way it is impossible to read from a write-only handle or write to a read-only handle for example.
See the explicit-iomodes-bytestring/text package for ByteString/Text operations.
Extends explicit-iomodes with ByteString operations
Extends explicit-iomodes with Text operations
This package implements a monad for non-deterministic computations with sharing.
Very first prototype of a command line tool to extract pixel positions matching a given colour to help reconstruct plot data. See example.ods or example.xls, README and Main.hs on the project homepage to figure out its usage.
Generalization of parsec's expression parser.
This package allows defining simulation experiments for the Aivika package. Such experiments define in declarative manner what should be simulated and in which view the simulation results should be generated. It can be charts, tables and so on.
The library is extensible and you can add new views for the results.
This package complements the Aivika and Aivika Experiment packages with charting capabilites. Now the simulation results can be represented as charts.
It was intentionally made a separate package as it has heavy dependencies on Haskell Charts, Cairo and GTK.
Port of parsec's expression parser to attoparsec.
Allows you to generate hexpat node trees using blaze syntax.
Boolean expressions with various representations and search queries.
Let's make music with text! We can use Csound to describe our music. Csound has so many fantastic sound generators. It's very efficient. But sometimes Csound is too low level. So many details: integer identifiers for instruments and arrays, should I use control rate or audio rate signals, lack of abstractions, no nested expressions and it has limited set of types. This library embeds Csound in Haskell. It's Csound code generator. We can use powerful Csound's primitives and glue them together with Haskell abstractions. Start with the module Csound.Base. It contains basic types and functions.
* Keep it simple and compact.
* Try to hide low level csound's wiring as much as we can (no ids for ftables, instruments, global variables).
* Don't describe the whole csound in all it's generality but give the user some handy tools to play with sound.
* No distinction between audio and control rates on the type level. Derive all rates from the context. If the user plugs signal to an opcode that expects an audio rate signal the argument is converted to the right rate.
* Watch out for side-effects. There is a special type called SE. It functions as IO in Haskell.
* Less typing, more music. Use short names for all types. Make library so that all expressions can be built without type annotations. Make it simple for the compiler to derive all types. Don't use complex type classes.
* Make low level opcode definitions simple. Let user define his own opcodes (if they are missing).
* Ensure that output signal is limited by amplitude. Csound can produce signals with HUGE amplitudes. Little typo can damage your ears and your speakers. In generated code all signals are clipped by 0dbfs value. 0dbfs is set to 1. Just as in Pure Data. So 1 is absolute maximum value for amplitude.
* No dependency on Score-generation libraries. Score (or list of events) is represented with type class. You can use your favorite Score-generation library if you provide an instance for the CsdSco type class. Currently there is support for temporal-music-notation library (see temporal-csound package).
For the future
* Make composable guis. Just plug the slider in the opcode and see it on the screen. Interactive instruments should be easy to make.
* Remove score/instrument barrier. Let instrument play a score within a note and trigger other instruments.
* Timing of events. User can set the beat rate and align events by beat events.
* Set Csound flags with meaningful (well-typed) values. Derive as much as you can from the context.
* Optimization of the memory allocation (liveness analysis).
dataToExpQ converts a value to a 'Q Exp' representation of the same value. It takes a function to handle type-specific cases.
Show more results