class
A class declaration introduces a new type class and the overloaded operations that must be supported by any type that is an instance of that class.
> class Num a where
> (+) :: a -> a -> a
> negate :: a -> a
> { class Eq a => Ord a
A class is reified to its declaration and a list of its instances
Conditionally labels test case.
indentation of a class or instance
> Eq (Int, a)
ClassyPrelude is a Prelude for people who know Haskell well. It re-exports some commonly imported modules, replaces Prelude functions with their type-class equivalents where reasonable, and removes some Prelude functions that in my opinion don't belong there. These modules are likely to be incomplete. Suggestions are greatly appreciated.
Version 0.1
* Computation type: Computations which can be interrupted and resumed.
* Binding strategy: Binding a function to a monadic value creates a new continuation which uses the function as the continuation of the monadic computation.
* Useful for: Complex control structures, error handling, and creating co-routines.
* Zero and plus: None.
* Example type: Cont r a
The Continuation monad represents computations in continuation-passing style (CPS). In continuation-passing style function result is not returned, but instead is passed to another function, received as a parameter (continuation). Computations are built up from sequences of nested continuations, terminated by a final continuation (often id) which produces the final result. Since continuations are functions which represent the future of a computation, manipulation of the continuation functions can achieve complex manipulations of the future of the computation, such as interrupting a computation in the middle, aborting a portion of a computation, restarting a computation, and interleaving execution of computations. The Continuation monad adapts CPS to the structure of a monad.
Before using the Continuation monad, be sure that you have a firm understanding of continuation-passing style and that continuations represent the best solution to your particular design problem. Many algorithms which require continuations in other languages do not require them in Haskell, due to Haskell's lazy semantics. Abuse of the Continuation monad can produce code that is impossible to understand and maintain.
* Computation type: Computations which may fail or throw exceptions.
* Binding strategy: Failure records information about the cause/location of the failure. Failure values bypass the bound function, other values are used as inputs to the bound function.
* Useful for: Building computations from sequences of functions that may fail or using exception handling to structure error handling.
* Zero and plus: Zero is represented by an empty error and the plus operation executes its second argument if the first fails.
* Example type: Either String a
The Error monad (also called the Exception monad).
Class of monads based on IO.
* Computation type: Computations which read values from a shared environment.
* Binding strategy: Monad values are functions from the environment to a value. The bound function is applied to the bound value, and both have access to the shared environment.
* Useful for: Maintaining variable bindings, or other shared environment.
* Zero and plus: None.
* Example type: Reader [(String,Value)] a
The Reader monad (also called the Environment monad). Represents a computation, which can read values from a shared environment, pass values from function to function, and execute sub-computations in a modified environment. Using Reader monad for such computations is often clearer and easier than using the State monad.
Inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, Mark P Jones (http://web.cecs.pdx.edu/~mpj/) Advanced School of Functional Programming, 1995.
Declaration of the MonadRWS class.
Inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, Mark P Jones (http://web.cecs.pdx.edu/~mpj/) Advanced School of Functional Programming, 1995.
MonadState class.
This module is inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, Mark P Jones (http://web.cecs.pdx.edu/~mpj/) Advanced School of Functional Programming, 1995.
Classes for monad transformers.
A monad transformer makes a new monad out of an existing monad, such that computations of the old monad may be embedded in the new one. To construct a monad with a desired set of features, one typically starts with a base monad, such as Identity, [] or IO, and applies a sequence of monad transformers.
Most monad transformer modules include the special case of applying the transformer to Identity. For example, State s is an abbreviation for StateT s Identity.
Each monad transformer also comes with an operation runXXX to unwrap the transformer, exposing a computation of the inner monad.
In theory, this allows the design of more data-agnostic APIs.
Version 0.0.0
Allow users of your library to choose which data structure they want to use rather than constraining them to whatever you chose at the time.
Version 0.0.0.0
This package implements a library of first class patterns. The initial basis for this library was Morten Rhiger's "Type-safe pattern combinators"; the patterns can be used in an almost identical way to those of Morten Rhiger. In a series of blog posts at http://reinerp.wordpress.com/category/pattern-combinators/ the types of patterns were made more revealing using type families, and a simpler implementation was used which avoids some book-keeping.
The library reimplements most of Haskell's built-in pattern matching facilities, plus some more. The pattern matches of this library are lightweight: when GHC's optimisation is turned on, all overhead should be optimised away, leaving a standard Haskell pattern match.
If you're just reading the documentation for this library for the first time, start with Data.Pattern.
Version 0.3.1
Haskeline provides all of its functionality within the scope of a monad transformer. This module adds two pieces to this:
* Introduced here is a type-class which defines the operations supported by the Haskeline monad transformer - MonadHaskeline
* A newtype wrapper around Haskeline's InputT, called HaskelineT. Sadly, InputT defines ints own instance of the mtl MonadState, which is no good for folks wanting to use InputT in an existing monad transformer stack.
HaskelineT also has an instance of MonadState, but it merely lifts the functions further in the transformer stack.
Large portions of the Haskeline functionality are re-exported here for convinience.
Note on build-dependencies: If you've succesfully built this with any packages other than the ones noted, please let me know.
Version 0.6.2
Provides an interface for classifiers and functions to use and analyze them. Take one or more hinduce-classifier-* packages for actual classifier implementations.
Version 0.0.0.1
A very simple decision tree construction algorithm; an implementation of hinduce-classifier's Classifier class.
Version 0.0.0.1
Parses compiled Java .class files into the syntax tree of the language-java package
Version 0.2.0
Package to support Propositional and First Order Logic. It includes classes representing the different types of formulas and terms, some instances of those classes for types used in other logic libraries, and implementations of several logic algorithms, including conversion to normal form and a simple resolution-based theorem prover for any instance of FirstOrderFormula.
Version 1.4.5
Pretty printing class similar to Show, based on the HughesPJ pretty printing library. Provides the pretty printing class and instances for the Prelude types.
Version 1.0.0.0
String class library
Version 0.1.5.1
Classes, and Template Haskell code to generate instances, for the Scrap Your Boilerplate With Class system.
Version 0.6.1.3
Provides SYB-with-class instances for Text from the text package.
Version 0.0.1
This library provides the class:
class ToString s where toString :: s -> String
Instances for String, Char and ShowS are provided. For other instances see the package:
http://hackage.haskell.org/package/to-string-instances
Also included is a general coercion function between string-like types:
fromToString :: (IsString s2, ToString s1) => s1 -> s2
fromToString = fromString . toString
Version 0.1.2
A simple game where you need to type the letters scrolling down the screen before they reach the bottom. Using SDL and SDL_ttf.
Version 0.1.1