| base-3.0.0.0: Basic libraries | Contents | Index

Data.Ix |

Portability | portable
Stability | stable
Maintainer | libraries@haskell.org

Contents

The `Ix` class
Deriving Instances of `Ix`

Description
The `Ix` class is used to map a contiguous subrange of values in type onto integers. It is used primarily for array indexing (see Data.Array, Data.Array.IArray and Data.Array.MArray).
Synopsis

class Ord a => Ix a where

range :: (a, a) -> [a]
index :: (a, a) -> a -> Int
inRange :: (a, a) -> a -> Bool
rangeSize :: (a, a) -> Int

The `Ix` class
class Ord a => Ix a where

The `Ix` class is used to map a contiguous subrange of values in a type onto integers. It is used primarily for array indexing (see Data.Array, Data.Array.IArray and Data.Array.MArray). The first argument `(l,u)` of each of these operations is a pair specifying the lower and upper bounds of a contiguous subrange of values.

An implementation is entitled to assume the following laws about these operations:

-     inRange (l,u) i == elem i (range (l,u))

- ``range` (l,u) `!!` `index` (l,u) i == i`, when ``inRange` (l,u) i`

-     map (index (l,u)) (range (l,u))) == [0..rangeSize (l,u)-1]

-     rangeSize (l,u) == length (range (l,u))

Minimal complete instance: `range`, `index` and `inRange`.

Methods

range :: (a, a) -> [a]
The list of values in the subrange defined by a bounding pair.
index :: (a, a) -> a -> Int
The position of a subscript in the subrange.
inRange :: (a, a) -> a -> Bool
Returns `True` the given subscript lies in the range defined the bounding pair.
rangeSize :: (a, a) -> Int
The size of the subrange defined by a bounding pair.

Instances

Ix Bool
Ix Char
Ix GeneralCategory
Ix IOMode
Ix Int
Ix Int16
Ix Int32
Ix Int64
Ix Int8
Ix Integer
Ix Ordering
Ix SeekMode
Ix Word
Ix Word16
Ix Word32
Ix Word64
Ix Word8
Ix ()
(Ix a, Ix b) => Ix (a, b)
(Ix a1, Ix a2, Ix a3) => Ix (a1, a2, a3)
(Ix a1, Ix a2, Ix a3, Ix a4) => Ix (a1, a2, a3, a4)
(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5) => Ix (a1, a2, a3, a4, a5)

Deriving Instances of `Ix`
Derived instance declarations for the class `Ix` are only possible for enumerations (i.e. datatypes having only nullary constructors) and single-constructor datatypes, including arbitrarily large tuples, whose constituent types are instances of `Ix`.

- For an enumeration, the nullary constructors are assumed to be numbered left-to-right with the indices being 0 to n-1 inclusive. This is the same numbering defined by the `Enum` class. For example, given the datatype:

    	data Colour = Red | Orange | Yellow | Green | Blue | Indigo | Violet

we would have:

    	range   (Yellow,Blue)        ==  [Yellow,Green,Blue]
    	index   (Yellow,Blue) Green  ==  1
    	inRange (Yellow,Blue) Red    ==  False

- For single-constructor datatypes, the derived instance declarations are as shown for tuples in Figure 1 http://www.haskell.org/onlinelibrary/ix.html#prelude-index.

Produced by Haddock version 0.8