Eq

class Eq a
base Prelude, base Data.Eq
The Eq class defines equality (==) and inequality (/=). All the basic datatypes exported by the Prelude are instances of Eq, and Eq may be derived for any datatype whose constituents are also instances of Eq. Minimal complete definition: either == or /=.
module Data.Eq
base Data.Eq
Equality
package Eq
package
Haskell formula manipulation program Version 1.1.3
Equal :: ComparisonFunction
OpenGL Graphics.Rendering.OpenGL.GL.PerFragment
EqualP :: Type -> Type -> Pred
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
> F a ~ Bool
Equals :: Token
haskell-src Language.Haskell.Lexer
Equiv :: LogicOp
OpenGL Graphics.Rendering.OpenGL.GL.PerFragment
EQ :: Ordering
base Prelude, base Data.Ord
package eq
package
Leibnizian equality Version 4.0
equal :: Array -> Int -> Array -> Int -> Int -> Bool
text Data.Text.Array
Compare portions of two arrays for equality. No bounds checking is performed.
equal :: (Eq a, Eq b, Graph gr) => gr a b -> gr a b -> Bool
fgl Data.Graph.Inductive.Graph
package equal-files
package
Shell command that finds files with equal content in a given set of files. This is useful for finding duplicates in a set of documents where the same document might have been stored by accident with different names. Use it like > equal-files `find my_dir -type f` or > find my_dir -type f | xargs equal-files If the file names contain spaces, better use > find my_dir -type f -printf "'%p'\n" | xargs equal-files or > equal_files -r my_dir The program reads all input files simultaneously, driven by sorting and grouping of their content. However be prepared that due to the simultaneous access you may exceed the admissible number of opened files. Thus you may prefer to run it like > equal_files -r -p 512 my_dir The program can be used as a nice example of a declarative yet efficient implementation of a non-trivial algorithm, that is enabled by lazy evaluation. Version 0.0.4
equalFilePath :: FilePath -> FilePath -> Bool
filepath System.FilePath.Windows, filepath System.FilePath.Posix
Equality of two FilePaths. If you call System.Directory.canonicalizePath first this has a much better chance of working. Note that this doesn't follow symlinks or DOSNAM~1s. > x == y ==> equalFilePath x y > normalise x == normalise y ==> equalFilePath x y > Posix: equalFilePath "foo" "foo/" > Posix: not (equalFilePath "foo" "/foo") > Posix: not (equalFilePath "foo" "FOO") > Windows: equalFilePath "foo" "FOO"
equalP :: TypeQ -> TypeQ -> PredQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
equals :: Doc
pretty Text.PrettyPrint.HughesPJ, pretty Text.PrettyPrint
equals :: Doc
template-haskell Language.Haskell.TH.PprLib
A '=' character
package equational-reasoning
package
package equivalence
package
This is an implementation of Tarjan's Union-Find algorithm (Robert E. Tarjan. "Efficiency of a Good But Not Linear Set Union Algorithm", JACM 22(2), 1975) in order to maintain an equivalence relation. This implementation is a port of the union-find package using the ST monad transformer (instead of the IO monad). Version 0.2.3
seq :: a -> b -> b
base Prelude
Evaluates its first argument to head normal form, and then returns its second argument as the result.
sequence :: Monad m => [m a] -> m [a]
base Prelude, base Control.Monad
Evaluate each action in the sequence from left to right, and collect the results.
sequence_ :: Monad m => [m a] -> m ()
base Prelude, base Control.Monad
Evaluate each action in the sequence from left to right, and ignore the results.
eDESTADDRREQ :: Errno
base Foreign.C.Error
eILSEQ :: Errno
base Foreign.C.Error
ReqArg :: (String -> a) -> String -> ArgDescr a
base System.Console.GetOpt
option requires argument
RequireOrder :: ArgOrder a
base System.Console.GetOpt
no option processing after first non-option
sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
base Data.Traversable
sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
base Data.Foldable
Evaluate each monadic action in the structure from left to right, and ignore the results.
sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
base Data.Traversable
sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
base Data.Foldable
Evaluate each action in the structure from left to right, and ignore the results.
subsequences :: [a] -> [[a]]
base Data.List
The subsequences function returns the list of all subsequences of the argument. > subsequences "abc" == ["","a","b","ab","c","ac","bc","abc"]
package abstract-deque
package
An abstract interface to highly-parameterizable queues/deques. Background: There exists a feature space for queues that extends between: * simple, single-ended, non-concurrent, bounded queues * double-ended, threadsafe, growable queues ... with important points inbetween (such as the queues used for work-stealing). This package includes an interface for Deques that allows the programmer to use a single API for all of the above, while using the type-system to select an efficient implementation given the requirements (using type families). This package also includes a simple reference implementation based on IORef and Data.Sequence. Version 0.2.2
package alsa-seq
package
This package provides access to ALSA sequencer (MIDI support). For audio support see alsa-pcm. Included are some simple example programs. For more example programs including a GUI, see the alsa-gui programs. Version 0.6.0.2
package alsa-seq-tests
package
Tests for the ALSA sequencer library. Version 0.1
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
ArithSeqE :: Range -> Exp
template-haskell Language.Haskell.TH.Syntax, template-haskell Language.Haskell.TH
> { [ 1 ,2 .. 10 ] }
arithSeqE :: RangeQ -> ExpQ
template-haskell Language.Haskell.TH.Lib, template-haskell Language.Haskell.TH
assertEqual :: (Eq a, Show a) => String -> a -> a -> Assertion
HUnit Test.HUnit.Base
Asserts that the specified actual value is equal to the expected value. The output message will contain the prefix, the expected value, and the actual value. If the prefix is the empty string (i.e., ""), then the prefix is omitted and only the expected and actual values are output.
data BlendEquation
OpenGL Graphics.Rendering.OpenGL.GL.PerFragment
blendEquation :: StateVar BlendEquation
OpenGL Graphics.Rendering.OpenGL.GL.PerFragment
blendEquationSeparate :: StateVar (BlendEquation, BlendEquation)
OpenGL Graphics.Rendering.OpenGL.GL.PerFragment

Show more results