ap +package

package apache-md5
package
Haskell implementation of Apache HTTP server specific MD5 digest algorithm that uses OpenSSL MD5() function. README and ChangeLog can be found in source code package and on GitHub: * https://github.com/trskop/apache-md5/blob/master/README.md * https://github.com/trskop/apache-md5/blob/master/ChangeLog.md Version 0.5.0.1
package apelsin
package
A gtk2hs server and clan browser for the open source game Tremulous http://tremulous.net. Both Tremulous 1.1 and GPP are supported. Features filtering, player search, a list of online clan members, a clan list and basic perferences. Version 1.2.3
package appar
package
A simple applicative parser in Parsec style Version 0.1.4
package applicative-extras
package
Some instances for applicative functors and type-level composition. Forkable on github. Version 0.1.8
package applicative-numbers
package
Any applicative functor can be given numeric instances in a boilerplate way. The applicative-numbers package provides an include file that makes it a snap to define these instances. See Data.Numeric.Function for an example. Project wiki page: http://haskell.org/haskellwiki/applicative-numbers Copyright 2009-2013 Conal Elliott; BSD3 license. Instances of Num classes for applicative functors.  To be #include'd after defining APPLICATIVE as the applicative functor name and CONSTRAINTS as a list of constraints, which must carry its own trailing comma if non-empty. The APPLICATIVE symbol gets #undef'd at the end of the include file, so that multiple includes are convenient. For instance, @ #define INSTANCE_Ord #define INSTANCE_Enum #define APPLICATIVE Vec2 #include "ApplicativeNumeric-inc.hs" #define APPLICATIVE Vec3 #include "ApplicativeNumeric-inc.hs" #define APPLICATIVE Vec4 #include "ApplicativeNumeric-inc.hs" @ You'll also have to import pure and liftA2 from Control.Applicative and specify the FlexibleContexts language extension (due to an implementation hack). Some instances are generated only if a corresponding CPP symbol is defined: INSTANCE_Eq, INSTANCE_Ord, INSTANCE_Show, INSTANCE_Enum Version 0.1.2
package applicative-quoters
package
Quasiquoters taken from Matt Morrow's haskell-src-meta to implement Conor McBride's idiom brackets, and a do-notation that only requires Applicative (and is correspondingly less powerful). applicative-quoters currently has no maintainer: if it is broken and you want it to be fixed, then fix it! Version 0.1.0.8
package approx-rand-test
package
Functions and utilities to perform paired and unpaired approximate randomization tests (Noreen, 1989). The utilities can also draw histograms of the applications of the test statistic to the randomized samples. For support for more file formats, install the package with the -withCairo flag. Version 0.2.1
package approximate
package
This package provides approximate discrete values and numbers. Version 0.2
package approximate-equality
package
The purpose of this module is to provide newtype wrappers that allow one to effectively override the equality operator of a value so that it is approximate rather than exact. The wrappers use type annotations to specify the tolerance; the Digits type constructor has been provided for specifying the tolerance using type-level natural numbers.  Instances for all of the classes in the numerical hierarchy have been provided for the wrappers, so the wrapped values can mostly be used in the same way as the original values. (In fact, most of the time one doesn't even have to wrap the starting values, since expressions such as (1+sqrt 2/3) are automatically wrapped thanks to the fromIntegral method of the Num typeclass.) See the documentation for Data.Eq.Approximate for more detailed information on how to use this package. New in version 1.1:  Added explicit Show constraints to the Show instances, as the Num class in the newest version of GHC (wisely) no longer includes Show as a constraint. Version 1.1
package ApplePush
package
This library provides an interface to send notifications with the Apple Push Notification Service. Note: Your connection to Apple's Push Notification service must be secured with SSL. Currently, Haskell's support for SSL is incomplete, therefore you should use an SSL tunnel to connect your application to the push service, such as                       stunnel. Version 0.1
package AppleScript
package
This package enables you to compile and execute AppleScript code from Haskell, and provides support for this AppleScript code to call back into Haskell. To get started, see Foreign.AppleScript.Rich. Version 0.2.0.1
package 3d-graphics-examples
package
This package demonstrates how to program simple interactive 3D graphics with OpenGL. It contains two programs, which are both about fractals: L-systems: generates graphics from Lindenmayer systems (L-systems). It defines a language for L-systems as an embedded DSL. Mountains: uses the generalized Brownian motion to generate graphics that resemble mountain landscapes. The original versions of these programs were written by Matthias Reisner as part of a student project at the Brandenburg University of Technology at Cottbus, Germany. Wolfgang Jeltsch, who supervised this student project, is now maintaining these programs. Version 0.0.0.0
package acme-lookofdisapproval
package
The Acme.LookOfDisapproval module provides one function ಠ_ಠ, which lets you to express your profound disapproval. Version 0.1
package Adaptive
package
This is a Haskell (plus some extensions) implementation of a library for incremental computing.  It closely follows the implementation in the nice POPL 2002 paper "Adaptive Functional Programming", by Umut Acar, Guy Blelloch and Bob Harper. Version 0.23
package Adaptive-Blaisorblade
package
This is a Haskell (plus some extensions) implementation of a library for incremental computing.  It closely follows the implementation in the nice POPL 2002 paper "Adaptive Functional Programming", by Umut Acar, Guy Blelloch and Bob Harper. This is a small fork of the original library named Adaptive, with the same interface but small adaptations to GHC 7.4. Version 0.23
package adaptive-containers
package
Self optimizing polymorphic container types. Adaptive containers are polymorphic container types that use class associated data types to specialize particular element types to a more efficient container representation. The resulting structures tend to be both more time and space efficient. A self-optimizing pair, for example, will unpack the constructors, yielding a representation for (Int,Char) requiring 8 bytes, instead of 24. This difference can be visualized. Consider the expression: > [ (x,y) | x <- [1..3], y <- [x..3] ] * [(Int,Int)]: A regular list of pairs http://code.haskell.org/~dons/images/vacuum/tuple-list.png * [Pair Int Int]: An adaptive list of pairs http://code.haskell.org/~dons/images/vacuum/pair-list.png * List (Pair Int Int): An adaptive list of adaptive pairs http://code.haskell.org/~dons/images/vacuum/list-pair.png Currently supported adaptive containers: pairs, lists, maybes Most unboxed element types are supported. Version 0.3
package adaptive-tuple
package
Self optimizing tuple types. Adaptive tuples are tuple types in which the number of elements is determined at run-time.  These structures are designed to combine the space-efficiency of tuples with the size flexibility of lists. Adaptive tuples provide lazy and strict, unpacked data structures for all tuple sizes from 0 to 20 elements.  Adaptive tuples of more than 20 elements are allowed, however they are stored in an ordinary list. Version 0.2.0
package arrowapply-utils
package
This package provides useful utilities for making use of the opportunities the ArrowApply class provides, such as the ability to work with Arrows as Monads, and use liftM-like functions. Version 0.2
package authenticate-ldap
package
LDAP authentication for Haskell web applications. Version 0.0.3
package azure-service-api
package
At the moment, this module only provides minimal functionality, just enough to support the &quot;distributed-process-azure&quot; package (Azure backend for Cloud Haskell). However, the code is set up in such a way that adding additional functionality should be relatively straightforward; developers who wish to do will probably want to consult the Windows Azure Service Management REST API Reference (http://msdn.microsoft.com/en-us/library/windowsazure/ee460799.aspx). Version 0.1.0.0
package bimap
package
A data structure representing a bidirectional mapping between two key types. Each value in the bimap is associated with exactly one value of the opposite type. Version 0.2.4
package bindings-apr
package
Bindings to APR: http://apr.apache.org/ Version 0.1
package bindings-apr-util
package
Bindings to APR Utility: http://apr.apache.org/ Version 0.1
package bindings-mmap
package
Deprecated.  Use bindings-posix >= 1.2.3 Bindings.Posix.Sys.Mman instead. Version 1.0
package bitmap
package
A library for handling and manipulating bitmaps (that is, rectangular pixel arrays). Version 0.0.2
package bitmap-opengl
package
OpenGL support for Data.Bitmap. It has its own package so that the bitmap package does not depend on OpenGL. Version 0.0.0.1
package bitmaps
package
Library defining several bitmap types, including ones stored as unboxed arrays, any string type, and functions This library also supports conversion to and from bitmaps as defined in the &quot;bitmap&quot; package. This library has not yet been tested extensively. Note: This library is currently largely designed with RGB pixels with a color depth of 24 bits in mind.  Better support for other pixel and color formats is intended to be implemented in the future. Version 0.2.6.0
package bson-mapping
package
This module defines a Bson class to convert data types to Bson and to convert Bson documents back to datatypes, along with template haskell functions to easily derive the instance. Version 0.1.4.1
package buildwrapper
package
Buildwrapper is an alternative to scion. It provides services to configure, build and give information on source files to help IDEs manage Haskell projects. You can use buildwrapper to build project and retrieve errors, get outline for each module source, get the type of something inside a source file, get lexer tokens, etc. Buildwrapper is used in the EclipseFP project (Eclipse plugins for Haskell development) Version 0.7.7
package bytestring-mmap
package
This library provides a wrapper to mmap(2), allowing files or devices to be lazily loaded into memory as strict or lazy ByteStrings, using the virtual memory subsystem to do on-demand loading. Version 0.2.2
package cabal2doap
package
A converter from Cabal build description files, to Description-of-a-Project (DOAP) RDF files, giving visibility on the semantic web to cabalized Haskell projects. Version 0.2
package cabalgraph
package
Generate pretty graphs of module trees from cabal files Graph exposed modules from .cabal files in some directories: > $ cabalgraph a b c d | dot -Tpng | xv - Results in a graph like: http://code.haskell.org/~dons/images/dot.png Graph exposed modules from a url: > $ cabalgraph http://code.haskell.org/xmonad/xmonad.cabal | circo -Tpng | xv - Results in a graph like: http://code.haskell.org/~dons/images/xmonad-dot.png Version 0.1
package cairo-appbase
package
This template includes working callbacks to handle the File and Help menus and File Save/Open dialogs, with dummy handlers for selecting filenames and the Edit menu's Cut, Copy, and Paste. The main canvas uses Cairo for graphics rendering, and includes example code from the cairo package. To build your own application on top of this, first grab the code. You can either grab it from hackage with cabal unpack cairo-appbase, or clone the git repo: > git clone git://github.com/kfish/cairo-appbase.git To add widgets, install glade from your distro system and run glade data/main.ui. Save the resulting file in GtkBuilder format. Note that you must run cabal install to put the UI file in the correct place for your application to pick it up. To modify the code, edit src/cairo-appbase.hs. Hooking up functions to widgets is very simple: get a widget by name (which you set in ui file), and hook one of its signals (which you found in the Signals tab in glade) to an IO () action: > cut1 <- get G.castToMenuItem &quot;cut1&quot; > G.onActivateLeaf cut1 $ myCut The template code includes a trivial definition of myCut: > myCut :: IO () > myCut = putStrLn &quot;Cut&quot; A real application will want to pass data to the callback. In C, this is fairly tedious as you only have a single void * to pass to callbacks as user_data, and applications typically do lots of marshalling and unmarshalling to pass data around. In Haskell however, you can make yourself a more complex callback handler and use a curried version of it in each instance: > cut1 <- get G.castToMenuItem &quot;cut1&quot; > G.onActivateLeaf cut1 $ myComplexCut project phase 7 > ... > myCut :: Project -> MoonPhase -> LuckyNumber -> IO () > myCut project phase num = do > let selection = currentSelection project > when (phase == Full) howl > when (num /= 7) fail > doActualCut selection Version 0.4
package cap
package
An interpreter and debugger for the cap language. Version 1.0.1
package Capabilities
package
The capabilities library is an effort to make effects in Haskell more explicit by breaking the monolithic IO monad into smaller composable parts called capabilities: a use case might be an action that needs logging with current time but which should not be allowed any other IO. This exists as a pleasant middle ground between pure functions, the ST monad and the kitchen-sink IO providing a more fine-grained approach to effectful computations. Another benefit to this approach is security where a computation should only have access to resources requires to complete its job (principle of least privilege). The implementation of the idea is based on Wouter Swierstra's Functional Pearl Data types a la carte (Journal of Functional Programming, 18(4):423-436, 2008, http://dx.doi.org/10.1017/S0956796808006758) and uses the compdata package for compositional data types. Version 0.1.0.0
package capped-list
package
package capri
package
Capri (abbreviation of CAbal PRIvate) is a wrapper program on top of cabal-install to operate it in project-private mode. In this mode, there is no global or user package databases; only one package database is defined, private to the project, located under the root directory of a project. Capri invokes cabal-install and ghc-pkg in the way that only project's private package database is visible. Starting with minimally required set of packages, all necessary dependencies will be installed into that database, not affecting user or global databases. Capri is mainly intended to build executable programs. It depends on certain features of GHC, and is not usable with other Haskell compilers. Further reading: http://www.haskell.org/haskellwiki/Capri Version 0.1
package chronograph
package
The Chronograph data structure adds a measure field to an existing Haskell expression.  This field will be the time necessary to evaluate the expression using an arbitrary evaluation strategy (WHNF by default). Chronograph preserves laziness, so that the work of performing the evaluation is only done after the result is demanded. If you want to benchmark your program, you should look to other packages like Criterion that perform statistical analysis of your results so you can determine how reliable they are.  Chronograph just takes measurements, leaving the interpretation entirely to you. Version 0.2.0.0
package clckwrks-theme-bootstrap
package
package clckwrks-theme-geo-bootstrap
package

Show more results