Eq package:rio

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. The Haskell Report defines no laws for Eq. However, instances are encouraged to follow these properties:

• Reflexivity x == x = True
• Symmetry x == y = y == x
• Transitivity if x == y && y == z = True, then x == z = True
• Extensionality if x == y = True and f is a function whose return type is an instance of Eq, then f x == f y = True
• Negation x /= y = not (x == y)

Minimal complete definition: either == or /=.

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. Similar to normalise, this does not expand "..", because of symlinks.

x == y ==> equalFilePath x y
normalise x == normalise y ==> equalFilePath x y
equalFilePath "foo" "foo/"
not (equalFilePath "/a/../c" "/c")
not (equalFilePath "foo" "/foo")
Posix:   not (equalFilePath "foo" "FOO")
Windows: equalFilePath "foo" "FOO"
Windows: not (equalFilePath "C:" "C:/")

A Deque specialized to boxed vectors.

A double-ended queue supporting any underlying vector type and any monad. This implements a circular double-ended queue with exponential growth.

A Deque specialized to storable vectors.

A Deque specialized to unboxed vectors.

Helper function to assist with type inference, forcing usage of a boxed vector.

Helper function to assist with type inference, forcing usage of a storable vector.

Helper function to assist with type inference, forcing usage of an unboxed vector.

Convert a Deque into a list. Does not modify the Deque.

Convert to an immutable vector of any type. If resulting pure vector corresponds to the mutable one used by the Deque, it will be more efficient to use freezeDeque instead.

Example

>>> :set -XTypeApplications

>>> import qualified RIO.Vector.Unboxed as U

>>> import qualified RIO.Vector.Storable as S

>>> d <- newDeque @U.MVector @Int

>>> mapM_ (pushFrontDeque d) [0..10]

>>> dequeToVector @S.Vector d
[10,9,8,7,6,5,4,3,2,1,0]

Fold over a Deque, starting at the beginning. Does not modify the Deque.

Fold over a Deque, starting at the end. Does not modify the Deque.

Yield an immutable copy of the underlying mutable vector. The difference from dequeToVector is that the the copy will be performed with a more efficient memcpy, rather than element by element. The downside is that the resulting vector type must be the one that corresponds to the mutable one that is used in the Deque.

Example

>>> :set -XTypeApplications

>>> import qualified RIO.Vector.Unboxed as U

>>> d <- newDeque @U.MVector @Int

>>> mapM_ (pushFrontDeque d) [0..10]

>>> freezeDeque @U.Vector d
[10,9,8,7,6,5,4,3,2,1,0]

O(1) - Get the number of elements that is currently in the Deque

Create a new, empty Deque

Pop the first value from the end of the Deque

Pop the first value from the beginning of the Deque

Push a new value to the end of the Deque

Push a new value to the beginning of the Deque

The isSubsequenceOf function takes two lists and returns True if all the elements of the first list occur, in order, in the second. The elements do not have to occur consecutively. isSubsequenceOf x y is equivalent to x `elem` (subsequences y). Note: isSubsequenceOf is often used in infix form.

Examples

>>> "GHC" `isSubsequenceOf` "The Glorious Haskell Compiler"
True

>>> ['a','d'..'z'] `isSubsequenceOf` ['a'..'z']
True

>>> [1..10] `isSubsequenceOf` [10,9..0]
False

For the result to be True, the first list must be finite; for the result to be False, the second list must be finite:

>>> [0,2..10] `isSubsequenceOf` [0..]
True

>>> [0..] `isSubsequenceOf` [0,2..10]
False

>>> [0,2..] `isSubsequenceOf` [0..]
* Hangs forever*