class

keyword class
keyword
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
classD :: CxtQ -> Name -> [TyVarBndr] -> [FunDep] -> [DecQ] -> DecQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
classify :: Testable prop => Bool -> String -> prop -> Property
QuickCheck Test.QuickCheck.Property, QuickCheck Test.QuickCheck
Conditionally labels test case.
package classify
package
classIndent :: PPHsMode -> Indent
haskell-src Language.Haskell.Pretty
indentation of a class or instance
classP :: Name -> [TypeQ] -> PredQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
package classy-parallel
package
package classy-prelude
package
Focuses on using common typeclasses when possible, and creating new ones to avoid name clashing. Exposes many recommended datastructures (Map, ByteString, etc) directly without requiring long import lists and qualified modules. Version 0.7.0
package classy-prelude-conduit
package
conduit instances for classy-prelude Version 0.7.0
package classy-prelude-yesod
package
This is an extension of classy-prelude-conduit, adding in commonly used functions and data types from Yesod. Version 0.7.0
module Control.Monad.Cont.Class
mtl Control.Monad.Cont.Class
* 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.
module Control.Monad.Error.Class
mtl Control.Monad.Error.Class
* 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).
module Control.Monad.IO.Class
transformers Control.Monad.IO.Class
Class of monads based on IO.
module Control.Monad.Reader.Class
mtl Control.Monad.Reader.Class
* 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.
module Control.Monad.RWS.Class
mtl Control.Monad.RWS.Class
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.
module Control.Monad.State.Class
mtl Control.Monad.State.Class
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.
module Control.Monad.Trans.Class
transformers Control.Monad.Trans.Class
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.
module Control.Monad.Writer.Class
mtl Control.Monad.Writer.Class
The MonadWriter class. Inspired by the paper Functional Programming with Overloading and Higher-Order Polymorphism, Mark P Jones (http://web.cecs.pdx.edu/~mpj/pubs/springschool.html) Advanced School of Functional Programming, 1995.
ClassD :: Cxt -> Name -> [TyVarBndr] -> [FunDep] -> [Dec] -> Dec
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
> { class Eq a => Ord a
ClassI :: Dec -> [InstanceDec] -> Info
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
A class, with a list of its visible instances
package ClassLaws
package
The specification of a class in Haskell often starts with stating, in text, the laws that should be satisfied by methods defined in instances of the class, followed by the type of the methods of the class. The ClassLaws library is a framework that supports testing such class laws using QuickCheck.  Our framework is a light-weight class law testing framework, which requires a limited amount of work per class law, and per datatype for which the class law is tested.  We also show how to test class laws with partially-defined values.  Using partially-defined values, we show that the standard lazy and strict implementations of the state monad do not satisfy the expected laws. More information can be found at http://wiki.portal.chalmers.se/cse/pmwiki.php/FP/ClassLaws. Built with ghc-7.4.2 and ghc-7.6.1. (Fails to build with ghc-7.2.2 due to http://hackage.haskell.org/trac/ghc/ticket/5745. Could be worked around.) Version 0.3.1.0
ClassOpI :: Name -> Type -> ParentName -> Fixity -> Info
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
A class method
ClassP :: Name -> [Type] -> Pred
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
> Eq (Int, a)
package ClassyPrelude
package
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
package algebraic-classes
package
Algebraic classes are type classes where all the methods return a value of the same type, which is also the class parameter. Examples from base are Num and Monoid. F-algebras are functions f a -> a, where the functor f is called the signature, and the type a the carrier. This package relates these 2 concepts, and can create conversions between the two using Template Haskell. More specifically, it can generate: * signatures from algebraic classes * instances of algebraic classes from F-algebras. This is useful because type classes are more commonly used in Haskell than F-algebras, but F-algebras are easier to work with, because they are just functions. Version 0.5.1
package bytestring-class
package
In theory, this allows the design of more data-agnostic APIs. Version 0.0.0
checkClassBody :: [HsDecl] -> P [HsDecl]
haskell-src Language.Haskell.ParseUtils
checkClassHeader :: HsQualType -> P (HsContext, HsName, [HsName])
haskell-src Language.Haskell.ParseUtils
package container-classes
package
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
package data-default-class
package
package first-class-patterns
package
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.2
package haskeline-class
package
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
package hinduce-classifier
package
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
package hinduce-classifier-decisiontree
package
A very simple decision tree construction algorithm; an implementation of hinduce-classifier's Classifier class. Version 0.0.0.1
package HLearn-classification
package
This module is for unsupervised, supervised, and semi-supervised classification tasks.  It is in desperate need of documentation and refactoring. Version 1.0.1.1
HsClassDecl :: SrcLoc -> HsContext -> HsName -> [HsName] -> [HsDecl] -> HsDecl
haskell-src Language.Haskell.Syntax
KW_Class :: Token
haskell-src Language.Haskell.Lexer
package language-java-classfile
package
Parses compiled Java .class files into the syntax tree of the language-java package Version 0.2.0
package logic-classes
package
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.8
package modular-prelude-classy
package

Show more results