Eq -base

package Eq
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
package eq
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
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 equivalence
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
package abstract-deque
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
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
package alsa-seq-tests
Tests for the ALSA sequencer library. Version 0.1
package approximate-equality
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 ] }

Show more results