Haskell identifier, e.g. foo, Baz
* Computation type: Simple function application.
* Binding strategy: The bound function is applied to the input value. Identity x >>= f == Identity (f x)
* Useful for: Monads can be derived from monad transformers applied to the Identity monad.
* Zero and plus: None.
* Example type: Identity a
The Identity monad is a monad that does not embody any computational strategy. It simply applies the bound function to its input without any modification. Computationally, there is no reason to use the Identity monad instead of the much simpler act of simply applying functions to their arguments. The purpose of the Identity monad is its fundamental role in the theory of monad transformers. Any monad transformer applied to the Identity monad yields a non-transformer version of that monad.
The identity monad transformer.
This is useful for functions parameterized by a monad transformer.
The identity functor and monad.
This trivial type constructor serves two purposes:
* It can be used with functions parameterized by functor or monad classes.
* It can be used as a base monad to which a series of monad transformers may be applied to construct a composite monad. 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.
ideas provides feedback services to intelligent tutoring systems such as the digital mathematical environment of the Freudenthal Institute, MathDox, and Activemath.
This lexeme parser parses a legal identifier. Returns the identifier string. This parser will fail on identifiers that are reserved words. Legal identifier (start) characters and reserved words are defined in the LanguageDef that is passed to makeTokenParser. An identifier is treated as a single token using try.
Identity functor and monad.
The trivial monad transformer, which maps a monad to an equivalent monad.
This parser should accept any legal tail characters of identifiers. For example alphaNum <|> char "_".
This parser should accept any start characters of identifiers. For example letter <|> char "_".
Reading and writing of ID3v2 tags
Controls the global idle callback so a GLUT program can perform background processing tasks or continuous animation when window system events are not being received. If enabled, the idle callback is continuously called when events are not being received. The current window and current menu will not be changed before the idle callback. Programs with multiple windows and/or menus should explicitly set the current window and/or /current menu/ and not rely on its current setting.
The amount of computation and rendering done in an idle callback should be minimized to avoid affecting the program's interactive response. In general, not more than a single frame of rendering should be done in an idle callback.
Implements IDNA -- Internationalized Domain Names in Applications (RFC 3490).
Library to convert internationalized domain names between the ASCII (ACE) and Unicode encodings in accordance with IDNA2008 (RFC 5991: Internationalized Domain Names in Applications (IDNA): Protocol). Unlike IDNA2003, IDNA2008 is not based on RFC 3454: Preparation of Internationalized Strings ("stringprep").
return immediate dominators for each node of a graph, given a root
Idris is a general purpose language with full dependent types. It is compiled, with eager evaluation. Dependent types allow types to be predicated on values, meaning that some aspects of a program's behaviour can be specified precisely in the type. The language is closely related to Epigram and Agda. There is a tutorial at http://www.idris-lang.org/documentation. Features include:
* Full dependent types with dependent pattern matching
* where clauses, with rule, simple case expressions, pattern matching let and lambda bindings
* Type classes, monad comprehensions
* do notation, idiom brackets, syntactic conveniences for lists, tuples, dependent pairs
* Indentation significant syntax, extensible syntax
* Tactic based theorem proving (influenced by Coq)
* Cumulative universes
* Simple foreign function interface (to C)
* Hugs style interactive environment
A variant of Data.Dynamic that can be indexed, stored, transmitted trough communications etc.
A class for monoids (types with an associative binary operation that has an identity) with various general-purpose instances.
Yield True if the given Errno value is valid on the system. This implies that the Eq instance of Errno is also system dependent as it is only defined for valid values of Errno.
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:
* append mempty x =
* append x mempty =
* append x (mappend y z) = mappend (mappend x y)
* concat = foldr mappend memp
The method names refer to the monoid of lists under concatenation, but there are many other instances.
Minimal complete definition: mempty and mappend.
Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.
Returns the ThreadId of the calling thread (GHC only).
A ThreadId is an abstract type representing a handle to a thread. ThreadId is an instance of Eq, Ord and Show, total ordering over ThreadIds. The Show instance lets you convert an arbitrary-valued ThreadId to string form; showing a ThreadId value is occasionally useful when debugging or diagnosing the behaviour of a concurrent program.
Note: in GHC, if you have a ThreadId, you essentially have a pointer to the thread itself. This means the thread itself can't be garbage collected until you drop the ThreadId. This misfeature will hopefully be corrected at a later date.
Note: Hugs does not provide any operations on other threads; it defines ThreadId as a synonym for ().
Discard the return value of an IO action
Show more results