Data.PrimitiveArray.Index.Class

Documentation

data a :. b infixl 3

Strict pairs -- as in repa.

Constructors

!a :. !b infixl 3

Instances

(Unbox a0, Unbox b0) => Vector Vector ((:.) a0 b0)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a0 :. b0) -> m (Vector (a0 :. b0))

basicUnsafeThaw :: PrimMonad m => Vector (a0 :. b0) -> m (Mutable Vector (PrimState m) (a0 :. b0))

basicLength :: Vector (a0 :. b0) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a0 :. b0) -> Vector (a0 :. b0)

basicUnsafeIndexM :: Monad m => Vector (a0 :. b0) -> Int -> m (a0 :. b0)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a0 :. b0) -> Vector (a0 :. b0) -> m ()

elemseq :: Vector (a0 :. b0) -> (a0 :. b0) -> b -> b

(Unbox a0, Unbox b0) => MVector MVector ((:.) a0 b0)

Methods

basicLength :: MVector s (a0 :. b0) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a0 :. b0) -> MVector s (a0 :. b0)

basicOverlaps :: MVector s (a0 :. b0) -> MVector s (a0 :. b0) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a0 :. b0))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a0 :. b0) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a0 :. b0) -> m (MVector (PrimState m) (a0 :. b0))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a0 :. b0) -> Int -> m (a0 :. b0)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a0 :. b0) -> Int -> (a0 :. b0) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a0 :. b0) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a0 :. b0) -> (a0 :. b0) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a0 :. b0) -> MVector (PrimState m) (a0 :. b0) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a0 :. b0) -> MVector (PrimState m) (a0 :. b0) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a0 :. b0) -> Int -> m (MVector (PrimState m) (a0 :. b0))

(Functor m, Applicative m, Monad m, PrimMonad m, FreezeTables m ts, PrimArrayOps arr sh elm) => FreezeTables m ((:.) ts (MutArr m (arr sh elm)))

Associated Types

type Frozen ((:.) ts (MutArr m (arr sh elm))) :: *

Methods

freezeTables :: (ts :. MutArr m (arr sh elm)) -> m (Frozen (ts :. MutArr m (arr sh elm)))

(WriteCell m cs sh, Monad m, MPrimArrayOps arr sh a, PrimMonad m) => WriteCell m ((:.) cs (MutArr m (arr sh a), sh -> m a)) sh

Methods

unsafeWriteCell :: (cs :. (MutArr m (arr sh a), sh -> m a)) -> sh -> m ()

writeCell :: (cs :. (MutArr m (arr sh a), sh -> m a)) -> sh -> m ()

(Eq b, Eq a) => Eq ((:.) a b)

Methods

(==) :: (a :. b) -> (a :. b) -> Bool

(/=) :: (a :. b) -> (a :. b) -> Bool

(Ord b, Ord a) => Ord ((:.) a b)

Methods

compare :: (a :. b) -> (a :. b) -> Ordering

(<) :: (a :. b) -> (a :. b) -> Bool

(<=) :: (a :. b) -> (a :. b) -> Bool

(>) :: (a :. b) -> (a :. b) -> Bool

(>=) :: (a :. b) -> (a :. b) -> Bool

max :: (a :. b) -> (a :. b) -> a :. b

min :: (a :. b) -> (a :. b) -> a :. b

(Read a, Read b) => Read ((:.) a b)

Methods

readsPrec :: Int -> ReadS (a :. b)

readList :: ReadS [a :. b]

readPrec :: ReadPrec (a :. b)

readListPrec :: ReadPrec [a :. b]

(Show b, Show a) => Show ((:.) a b)

Methods

showsPrec :: Int -> (a :. b) -> ShowS

show :: (a :. b) -> String

showList :: [a :. b] -> ShowS

Generic ((:.) a b)

Associated Types

type Rep ((:.) a b) :: * -> *

Methods

from :: (a :. b) -> Rep (a :. b) x

to :: Rep (a :. b) x -> a :. b

(Arbitrary a, Arbitrary b) => Arbitrary ((:.) a b)

Methods

arbitrary :: Gen (a :. b)

shrink :: (a :. b) -> [a :. b]

(Hashable a, Hashable b) => Hashable ((:.) a b)

Methods

hashWithSalt :: Int -> (a :. b) -> Int

hash :: (a :. b) -> Int

(ToJSON a, ToJSON b) => ToJSON ((:.) a b)

Methods

toJSON :: (a :. b) -> Value

toEncoding :: (a :. b) -> Encoding

toJSONList :: [a :. b] -> Value

toEncodingList :: [a :. b] -> Encoding

(ToJSON a, ToJSONKey a, ToJSON b, ToJSONKey b) => ToJSONKey ((:.) a b)

Methods

toJSONKey :: ToJSONKeyFunction (a :. b)

toJSONKeyList :: ToJSONKeyFunction [a :. b]

(FromJSON a, FromJSON b) => FromJSON ((:.) a b)

Methods

parseJSON :: Value -> Parser (a :. b)

parseJSONList :: Value -> Parser [a :. b]

(FromJSON a, FromJSONKey a, FromJSON b, FromJSONKey b) => FromJSONKey ((:.) a b)

Methods

fromJSONKey :: FromJSONKeyFunction (a :. b)

fromJSONKeyList :: FromJSONKeyFunction [a :. b]

(Binary a, Binary b) => Binary ((:.) a b)

Methods

put :: (a :. b) -> Put

get :: Get (a :. b)

putList :: [a :. b] -> Put

(Serialize a, Serialize b) => Serialize ((:.) a b)

Methods

put :: Putter (a :. b)

get :: Get (a :. b)

(NFData a, NFData b) => NFData ((:.) a b)

Methods

rnf :: (a :. b) -> ()

(Unbox a0, Unbox b0) => Unbox ((:.) a0 b0)

IndexStream z => IndexStream ((:.) z (EdgeBoundary C))

EdgeBoundary C (complement)

Methods

streamUp :: Monad m => (z :. EdgeBoundary C) -> (z :. EdgeBoundary C) -> Stream m (z :. EdgeBoundary C)

streamDown :: Monad m => (z :. EdgeBoundary C) -> (z :. EdgeBoundary C) -> Stream m (z :. EdgeBoundary C)

IndexStream z => IndexStream ((:.) z (EdgeBoundary O))

EdgeBoundary O (outside).

Note: streamUp really needs to use streamDownMk / streamDownStep for the right order of indices!

Methods

streamUp :: Monad m => (z :. EdgeBoundary O) -> (z :. EdgeBoundary O) -> Stream m (z :. EdgeBoundary O)

streamDown :: Monad m => (z :. EdgeBoundary O) -> (z :. EdgeBoundary O) -> Stream m (z :. EdgeBoundary O)

IndexStream z => IndexStream ((:.) z (EdgeBoundary I))

EdgeBoundary I (inside)

Methods

streamUp :: Monad m => (z :. EdgeBoundary I) -> (z :. EdgeBoundary I) -> Stream m (z :. EdgeBoundary I)

streamDown :: Monad m => (z :. EdgeBoundary I) -> (z :. EdgeBoundary I) -> Stream m (z :. EdgeBoundary I)

IndexStream z => IndexStream ((:.) z (PInt C p))

Methods

streamUp :: Monad m => (z :. PInt C p) -> (z :. PInt C p) -> Stream m (z :. PInt C p)

streamDown :: Monad m => (z :. PInt C p) -> (z :. PInt C p) -> Stream m (z :. PInt C p)

IndexStream z => IndexStream ((:.) z (PInt O p))

Methods

streamUp :: Monad m => (z :. PInt O p) -> (z :. PInt O p) -> Stream m (z :. PInt O p)

streamDown :: Monad m => (z :. PInt O p) -> (z :. PInt O p) -> Stream m (z :. PInt O p)

IndexStream z => IndexStream ((:.) z (PInt I p))

Methods

streamUp :: Monad m => (z :. PInt I p) -> (z :. PInt I p) -> Stream m (z :. PInt I p)

streamDown :: Monad m => (z :. PInt I p) -> (z :. PInt I p) -> Stream m (z :. PInt I p)

IndexStream z => IndexStream ((:.) z (PointL C))

Methods

streamUp :: Monad m => (z :. PointL C) -> (z :. PointL C) -> Stream m (z :. PointL C)

streamDown :: Monad m => (z :. PointL C) -> (z :. PointL C) -> Stream m (z :. PointL C)

IndexStream z => IndexStream ((:.) z (PointL O))

Methods

streamUp :: Monad m => (z :. PointL O) -> (z :. PointL O) -> Stream m (z :. PointL O)

streamDown :: Monad m => (z :. PointL O) -> (z :. PointL O) -> Stream m (z :. PointL O)

IndexStream z => IndexStream ((:.) z (PointL I))

Methods

streamUp :: Monad m => (z :. PointL I) -> (z :. PointL I) -> Stream m (z :. PointL I)

streamDown :: Monad m => (z :. PointL I) -> (z :. PointL I) -> Stream m (z :. PointL I)

IndexStream z => IndexStream ((:.) z (Boundary k I))

Methods

streamUp :: Monad m => (z :. Boundary k I) -> (z :. Boundary k I) -> Stream m (z :. Boundary k I)

streamDown :: Monad m => (z :. Boundary k I) -> (z :. Boundary k I) -> Stream m (z :. Boundary k I)

IndexStream z => IndexStream ((:.) z (BS2 i j C))

Methods

streamUp :: Monad m => (z :. BS2 i j C) -> (z :. BS2 i j C) -> Stream m (z :. BS2 i j C)

streamDown :: Monad m => (z :. BS2 i j C) -> (z :. BS2 i j C) -> Stream m (z :. BS2 i j C)

IndexStream z => IndexStream ((:.) z (BS2 i j O))

Methods

streamUp :: Monad m => (z :. BS2 i j O) -> (z :. BS2 i j O) -> Stream m (z :. BS2 i j O)

streamDown :: Monad m => (z :. BS2 i j O) -> (z :. BS2 i j O) -> Stream m (z :. BS2 i j O)

IndexStream z => IndexStream ((:.) z (BS2 i j I))

Methods

streamUp :: Monad m => (z :. BS2 i j I) -> (z :. BS2 i j I) -> Stream m (z :. BS2 i j I)

streamDown :: Monad m => (z :. BS2 i j I) -> (z :. BS2 i j I) -> Stream m (z :. BS2 i j I)

IndexStream z => IndexStream ((:.) z (BS1 i C))

Methods

streamUp :: Monad m => (z :. BS1 i C) -> (z :. BS1 i C) -> Stream m (z :. BS1 i C)

streamDown :: Monad m => (z :. BS1 i C) -> (z :. BS1 i C) -> Stream m (z :. BS1 i C)

IndexStream z => IndexStream ((:.) z (BS1 i O))

Methods

streamUp :: Monad m => (z :. BS1 i O) -> (z :. BS1 i O) -> Stream m (z :. BS1 i O)

streamDown :: Monad m => (z :. BS1 i O) -> (z :. BS1 i O) -> Stream m (z :. BS1 i O)

IndexStream z => IndexStream ((:.) z (BS1 i I))

Methods

streamUp :: Monad m => (z :. BS1 i I) -> (z :. BS1 i I) -> Stream m (z :. BS1 i I)

streamDown :: Monad m => (z :. BS1 i I) -> (z :. BS1 i I) -> Stream m (z :. BS1 i I)

IndexStream z => IndexStream ((:.) z (BitSet C))

Methods

streamUp :: Monad m => (z :. BitSet C) -> (z :. BitSet C) -> Stream m (z :. BitSet C)

streamDown :: Monad m => (z :. BitSet C) -> (z :. BitSet C) -> Stream m (z :. BitSet C)

IndexStream z => IndexStream ((:.) z (BitSet O))

Methods

streamUp :: Monad m => (z :. BitSet O) -> (z :. BitSet O) -> Stream m (z :. BitSet O)

streamDown :: Monad m => (z :. BitSet O) -> (z :. BitSet O) -> Stream m (z :. BitSet O)

IndexStream z => IndexStream ((:.) z (BitSet I))

Methods

streamUp :: Monad m => (z :. BitSet I) -> (z :. BitSet I) -> Stream m (z :. BitSet I)

streamDown :: Monad m => (z :. BitSet I) -> (z :. BitSet I) -> Stream m (z :. BitSet I)

IndexStream z => IndexStream ((:.) z (Subword C))

Subword C (complement)

Methods

streamUp :: Monad m => (z :. Subword C) -> (z :. Subword C) -> Stream m (z :. Subword C)

streamDown :: Monad m => (z :. Subword C) -> (z :. Subword C) -> Stream m (z :. Subword C)

IndexStream z => IndexStream ((:.) z (Subword O))

Subword O (outside).

Note: streamUp really needs to use streamDownMk / streamDownStep for the right order of indices!

Methods

streamUp :: Monad m => (z :. Subword O) -> (z :. Subword O) -> Stream m (z :. Subword O)

streamDown :: Monad m => (z :. Subword O) -> (z :. Subword O) -> Stream m (z :. Subword O)

IndexStream z => IndexStream ((:.) z (Subword I))

Subword I (inside)

Methods

streamUp :: Monad m => (z :. Subword I) -> (z :. Subword I) -> Stream m (z :. Subword I)

streamDown :: Monad m => (z :. Subword I) -> (z :. Subword I) -> Stream m (z :. Subword I)

IndexStream z => IndexStream ((:.) z (Unit t))

Methods

streamUp :: Monad m => (z :. Unit t) -> (z :. Unit t) -> Stream m (z :. Unit t)

streamDown :: Monad m => (z :. Unit t) -> (z :. Unit t) -> Stream m (z :. Unit t)

(Index zs, Index z) => Index ((:.) zs z)

Methods

linearIndex :: (zs :. z) -> (zs :. z) -> (zs :. z) -> Int

smallestLinearIndex :: (zs :. z) -> Int

largestLinearIndex :: (zs :. z) -> Int

size :: (zs :. z) -> (zs :. z) -> Int

inBounds :: (zs :. z) -> (zs :. z) -> (zs :. z) -> Bool

data MVector s ((:.) a0 b0)

data MVector s ((:.) a0 b0) = MV_StrictPair (MVector s (a, b))

type Rep ((:.) a b)

type Rep ((:.) a b) = D1 (MetaData ":." "Data.PrimitiveArray.Index.Class" "PrimitiveArray-0.8.0.1-H8L9mO6Qdgd6EjLRyswnkq" False) (C1 (MetaCons ":." (InfixI LeftAssociative 3) False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 b))))

data Vector ((:.) a0 b0)

data Vector ((:.) a0 b0) = V_StrictPair (Vector (a, b))

type Frozen ((:.) ts (MutArr m (arr sh elm)))

type Frozen ((:.) ts (MutArr m (arr sh elm))) = (:.) (Frozen ts) (arr sh elm)

data a :> b infixr 3

A different version of strict pairs. Makes for simpler type inference in multi-tape grammars. We use :> when we have special needs, like non-recursive instances on inductives tuples, as used for set indices.

This one is infixr so that in a :> b we can have the main type in a and the specializing types in b and then dispatch on a :> ts with ts maybe a chain of :>.

Constructors

!a :> !b infixr 3

Instances

(Unbox a0, Unbox b0) => Vector Vector ((:>) a0 b0)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (a0 :> b0) -> m (Vector (a0 :> b0))

basicUnsafeThaw :: PrimMonad m => Vector (a0 :> b0) -> m (Mutable Vector (PrimState m) (a0 :> b0))

basicLength :: Vector (a0 :> b0) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (a0 :> b0) -> Vector (a0 :> b0)

basicUnsafeIndexM :: Monad m => Vector (a0 :> b0) -> Int -> m (a0 :> b0)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (a0 :> b0) -> Vector (a0 :> b0) -> m ()

elemseq :: Vector (a0 :> b0) -> (a0 :> b0) -> b -> b

(Unbox a0, Unbox b0) => MVector MVector ((:>) a0 b0)

Methods

basicLength :: MVector s (a0 :> b0) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (a0 :> b0) -> MVector s (a0 :> b0)

basicOverlaps :: MVector s (a0 :> b0) -> MVector s (a0 :> b0) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (a0 :> b0))

basicInitialize :: PrimMonad m => MVector (PrimState m) (a0 :> b0) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> (a0 :> b0) -> m (MVector (PrimState m) (a0 :> b0))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (a0 :> b0) -> Int -> m (a0 :> b0)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (a0 :> b0) -> Int -> (a0 :> b0) -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (a0 :> b0) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (a0 :> b0) -> (a0 :> b0) -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (a0 :> b0) -> MVector (PrimState m) (a0 :> b0) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (a0 :> b0) -> MVector (PrimState m) (a0 :> b0) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (a0 :> b0) -> Int -> m (MVector (PrimState m) (a0 :> b0))

(Eq b, Eq a) => Eq ((:>) a b)

Methods

(==) :: (a :> b) -> (a :> b) -> Bool

(/=) :: (a :> b) -> (a :> b) -> Bool

(Ord b, Ord a) => Ord ((:>) a b)

Methods

compare :: (a :> b) -> (a :> b) -> Ordering

(<) :: (a :> b) -> (a :> b) -> Bool

(<=) :: (a :> b) -> (a :> b) -> Bool

(>) :: (a :> b) -> (a :> b) -> Bool

(>=) :: (a :> b) -> (a :> b) -> Bool

max :: (a :> b) -> (a :> b) -> a :> b

min :: (a :> b) -> (a :> b) -> a :> b

(Read a, Read b) => Read ((:>) a b)

Methods

readsPrec :: Int -> ReadS (a :> b)

readList :: ReadS [a :> b]

readPrec :: ReadPrec (a :> b)

readListPrec :: ReadPrec [a :> b]

(Show b, Show a) => Show ((:>) a b)

Methods

showsPrec :: Int -> (a :> b) -> ShowS

show :: (a :> b) -> String

showList :: [a :> b] -> ShowS

Generic ((:>) a b)

Associated Types

type Rep ((:>) a b) :: * -> *

Methods

from :: (a :> b) -> Rep (a :> b) x

to :: Rep (a :> b) x -> a :> b

(Hashable a, Hashable b) => Hashable ((:>) a b)

Methods

hashWithSalt :: Int -> (a :> b) -> Int

hash :: (a :> b) -> Int

(ToJSON a, ToJSON b) => ToJSON ((:>) a b)

Methods

toJSON :: (a :> b) -> Value

toEncoding :: (a :> b) -> Encoding

toJSONList :: [a :> b] -> Value

toEncodingList :: [a :> b] -> Encoding

(FromJSON a, FromJSON b) => FromJSON ((:>) a b)

Methods

parseJSON :: Value -> Parser (a :> b)

parseJSONList :: Value -> Parser [a :> b]

(Binary a, Binary b) => Binary ((:>) a b)

Methods

put :: (a :> b) -> Put

get :: Get (a :> b)

putList :: [a :> b] -> Put

(Serialize a, Serialize b) => Serialize ((:>) a b)

Methods

put :: Putter (a :> b)

get :: Get (a :> b)

(NFData a, NFData b) => NFData ((:>) a b)

Methods

rnf :: (a :> b) -> ()

(Unbox a0, Unbox b0) => Unbox ((:>) a0 b0)

(Index zs, Index z) => Index ((:>) zs z)

Methods

linearIndex :: (zs :> z) -> (zs :> z) -> (zs :> z) -> Int

smallestLinearIndex :: (zs :> z) -> Int

largestLinearIndex :: (zs :> z) -> Int

size :: (zs :> z) -> (zs :> z) -> Int

inBounds :: (zs :> z) -> (zs :> z) -> (zs :> z) -> Bool

data MVector s ((:>) a0 b0)

data MVector s ((:>) a0 b0) = MV_StrictIxPair (MVector s (a, b))

type Rep ((:>) a b)

type Rep ((:>) a b) = D1 (MetaData ":>" "Data.PrimitiveArray.Index.Class" "PrimitiveArray-0.8.0.1-H8L9mO6Qdgd6EjLRyswnkq" False) (C1 (MetaCons ":>" (InfixI RightAssociative 3) False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 b))))

data Vector ((:>) a0 b0)

data Vector ((:>) a0 b0) = V_StrictIxPair (Vector (a, b))

data Z

Base data constructor for multi-dimensional indices.

Constructors

Z

Instances

Eq Z

Methods

(==) :: Z -> Z -> Bool

(/=) :: Z -> Z -> Bool

Ord Z

Methods

compare :: Z -> Z -> Ordering

(<) :: Z -> Z -> Bool

(<=) :: Z -> Z -> Bool

(>) :: Z -> Z -> Bool

(>=) :: Z -> Z -> Bool

max :: Z -> Z -> Z

min :: Z -> Z -> Z

Read Z

Methods

readsPrec :: Int -> ReadS Z

readList :: ReadS [Z]

readPrec :: ReadPrec Z

readListPrec :: ReadPrec [Z]

Show Z

Methods

showsPrec :: Int -> Z -> ShowS

show :: Z -> String

showList :: [Z] -> ShowS

Generic Z

Associated Types

type Rep Z :: * -> *

Methods

from :: Z -> Rep Z x

to :: Rep Z x -> Z

Arbitrary Z

Methods

arbitrary :: Gen Z

shrink :: Z -> [Z]

Hashable Z

Methods

hashWithSalt :: Int -> Z -> Int

hash :: Z -> Int

ToJSON Z

Methods

toJSON :: Z -> Value

toEncoding :: Z -> Encoding

toJSONList :: [Z] -> Value

toEncodingList :: [Z] -> Encoding

FromJSON Z

Methods

parseJSON :: Value -> Parser Z

parseJSONList :: Value -> Parser [Z]

Binary Z

Methods

put :: Z -> Put

get :: Get Z

putList :: [Z] -> Put

Serialize Z

Methods

put :: Putter Z

get :: Get Z

NFData Z

Methods

rnf :: Z -> ()

Unbox Z

IndexStream Z

Methods

streamUp :: Monad m => Z -> Z -> Stream m Z

streamDown :: Monad m => Z -> Z -> Stream m Z

Index Z

Methods

linearIndex :: Z -> Z -> Z -> Int

smallestLinearIndex :: Z -> Int

largestLinearIndex :: Z -> Int

size :: Z -> Z -> Int

inBounds :: Z -> Z -> Z -> Bool

Vector Vector Z

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Z -> m (Vector Z)

basicUnsafeThaw :: PrimMonad m => Vector Z -> m (Mutable Vector (PrimState m) Z)

basicLength :: Vector Z -> Int

basicUnsafeSlice :: Int -> Int -> Vector Z -> Vector Z

basicUnsafeIndexM :: Monad m => Vector Z -> Int -> m Z

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Z -> Vector Z -> m ()

elemseq :: Vector Z -> Z -> b -> b

MVector MVector Z

Methods

basicLength :: MVector s Z -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Z -> MVector s Z

basicOverlaps :: MVector s Z -> MVector s Z -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Z)

basicInitialize :: PrimMonad m => MVector (PrimState m) Z -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Z -> m (MVector (PrimState m) Z)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Z -> Int -> m Z

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Z -> Int -> Z -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Z -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Z -> Z -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Z -> MVector (PrimState m) Z -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Z -> MVector (PrimState m) Z -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Z -> Int -> m (MVector (PrimState m) Z)

Applicative m => FreezeTables m Z

Associated Types

type Frozen Z :: *

Methods

freezeTables :: Z -> m (Frozen Z)

Monad m => WriteCell m Z sh

Methods

unsafeWriteCell :: Z -> sh -> m ()

writeCell :: Z -> sh -> m ()

type Rep Z

type Rep Z = D1 (MetaData "Z" "Data.PrimitiveArray.Index.Class" "PrimitiveArray-0.8.0.1-H8L9mO6Qdgd6EjLRyswnkq" False) (C1 (MetaCons "Z" PrefixI False) U1)

data Vector Z

data Vector Z = V_Z (Vector ())

type Frozen Z

type Frozen Z = Z

data MVector s Z

data MVector s Z = MV_Z (MVector s ())

class Index i where

Index structures for complex, heterogeneous indexing. Mostly designed for indexing in DP grammars, where the indices work for linear and context-free grammars on one or more tapes, for strings, sets, later on tree structures.

Minimal complete definition

linearIndex, smallestLinearIndex, largestLinearIndex, size, inBounds

Methods

linearIndex :: i -> i -> i -> Int

Given a minimal size, a maximal size, and a current index, calculate the linear index.

smallestLinearIndex :: i -> Int

Given an index element from the smallest subset, calculate the highest linear index that is *not* stored.

largestLinearIndex :: i -> Int

Given an index element from the largest subset, calculate the highest linear index that *is* stored.

size :: i -> i -> Int

Given smallest and largest index, return the number of cells required for storage.

inBounds :: i -> i -> i -> Bool

Check if an index is within the bounds.

Instances

Index Z

Methods

linearIndex :: Z -> Z -> Z -> Int

smallestLinearIndex :: Z -> Int

largestLinearIndex :: Z -> Int

size :: Z -> Z -> Int

inBounds :: Z -> Z -> Z -> Bool

Index (EdgeBoundary t)

Methods

linearIndex :: EdgeBoundary t -> EdgeBoundary t -> EdgeBoundary t -> Int

smallestLinearIndex :: EdgeBoundary t -> Int

largestLinearIndex :: EdgeBoundary t -> Int

size :: EdgeBoundary t -> EdgeBoundary t -> Int

inBounds :: EdgeBoundary t -> EdgeBoundary t -> EdgeBoundary t -> Bool

Index (PointR t)

Methods

linearIndex :: PointR t -> PointR t -> PointR t -> Int

smallestLinearIndex :: PointR t -> Int

largestLinearIndex :: PointR t -> Int

size :: PointR t -> PointR t -> Int

inBounds :: PointR t -> PointR t -> PointR t -> Bool

Index (PointL t)

Methods

linearIndex :: PointL t -> PointL t -> PointL t -> Int

smallestLinearIndex :: PointL t -> Int

largestLinearIndex :: PointL t -> Int

size :: PointL t -> PointL t -> Int

inBounds :: PointL t -> PointL t -> PointL t -> Bool

Index (BitSet t)

Methods

linearIndex :: BitSet t -> BitSet t -> BitSet t -> Int

smallestLinearIndex :: BitSet t -> Int

largestLinearIndex :: BitSet t -> Int

size :: BitSet t -> BitSet t -> Int

inBounds :: BitSet t -> BitSet t -> BitSet t -> Bool

Index (Subword t)

Methods

linearIndex :: Subword t -> Subword t -> Subword t -> Int

smallestLinearIndex :: Subword t -> Int

largestLinearIndex :: Subword t -> Int

size :: Subword t -> Subword t -> Int

inBounds :: Subword t -> Subword t -> Subword t -> Bool

Index (Unit t)

Methods

linearIndex :: Unit t -> Unit t -> Unit t -> Int

smallestLinearIndex :: Unit t -> Int

largestLinearIndex :: Unit t -> Int

size :: Unit t -> Unit t -> Int

inBounds :: Unit t -> Unit t -> Unit t -> Bool

(Index zs, Index z) => Index ((:.) zs z)

Methods

linearIndex :: (zs :. z) -> (zs :. z) -> (zs :. z) -> Int

smallestLinearIndex :: (zs :. z) -> Int

largestLinearIndex :: (zs :. z) -> Int

size :: (zs :. z) -> (zs :. z) -> Int

inBounds :: (zs :. z) -> (zs :. z) -> (zs :. z) -> Bool

(Index zs, Index z) => Index ((:>) zs z)

Methods

linearIndex :: (zs :> z) -> (zs :> z) -> (zs :> z) -> Int

smallestLinearIndex :: (zs :> z) -> Int

largestLinearIndex :: (zs :> z) -> Int

size :: (zs :> z) -> (zs :> z) -> Int

inBounds :: (zs :> z) -> (zs :> z) -> (zs :> z) -> Bool

Index (PInt t p)

Methods

linearIndex :: PInt t p -> PInt t p -> PInt t p -> Int

smallestLinearIndex :: PInt t p -> Int

largestLinearIndex :: PInt t p -> Int

size :: PInt t p -> PInt t p -> Int

inBounds :: PInt t p -> PInt t p -> PInt t p -> Bool

Index (BS1 i t)

linearIndex explicitly maps BS1 0 whatever to 0.

Methods

linearIndex :: BS1 i t -> BS1 i t -> BS1 i t -> Int

smallestLinearIndex :: BS1 i t -> Int

largestLinearIndex :: BS1 i t -> Int

size :: BS1 i t -> BS1 i t -> Int

inBounds :: BS1 i t -> BS1 i t -> BS1 i t -> Bool

Index (Boundary i t)

Methods

linearIndex :: Boundary i t -> Boundary i t -> Boundary i t -> Int

smallestLinearIndex :: Boundary i t -> Int

largestLinearIndex :: Boundary i t -> Int

size :: Boundary i t -> Boundary i t -> Int

inBounds :: Boundary i t -> Boundary i t -> Boundary i t -> Bool

Index (BS2 i j t)

Methods

linearIndex :: BS2 i j t -> BS2 i j t -> BS2 i j t -> Int

smallestLinearIndex :: BS2 i j t -> Int

largestLinearIndex :: BS2 i j t -> Int

size :: BS2 i j t -> BS2 i j t -> Int

inBounds :: BS2 i j t -> BS2 i j t -> BS2 i j t -> Bool

class IndexStream i where

Generate a stream of indices in correct order for dynamic programming. Since the stream generators require concatMap / flatten we have to write more specialized code for (z:.IX) stuff.

Methods

streamUp :: Monad m => i -> i -> Stream m i

This generates an index stream suitable for forward structure filling. The first index is the smallest (or the first indices considered are all equally small in partially ordered sets). Larger indices follow up until the largest one.

streamUp :: (Monad m, IndexStream (Z :. i)) => i -> i -> Stream m i

This generates an index stream suitable for forward structure filling. The first index is the smallest (or the first indices considered are all equally small in partially ordered sets). Larger indices follow up until the largest one.

streamDown :: Monad m => i -> i -> Stream m i

If streamUp generates indices from smallest to largest, then streamDown generates indices from largest to smallest. Outside grammars make implicit use of this. Asking for an axiom in backtracking requests the first element from this stream.

streamDown :: (Monad m, IndexStream (Z :. i)) => i -> i -> Stream m i

If streamUp generates indices from smallest to largest, then streamDown generates indices from largest to smallest. Outside grammars make implicit use of this. Asking for an axiom in backtracking requests the first element from this stream.

Instances

IndexStream Z

Methods

streamUp :: Monad m => Z -> Z -> Stream m Z

streamDown :: Monad m => Z -> Z -> Stream m Z

IndexStream ((:.) Z (EdgeBoundary t)) => IndexStream (EdgeBoundary t)

Methods

streamUp :: Monad m => EdgeBoundary t -> EdgeBoundary t -> Stream m (EdgeBoundary t)

streamDown :: Monad m => EdgeBoundary t -> EdgeBoundary t -> Stream m (EdgeBoundary t)

IndexStream ((:.) Z (PointL t)) => IndexStream (PointL t)

Methods

streamUp :: Monad m => PointL t -> PointL t -> Stream m (PointL t)

streamDown :: Monad m => PointL t -> PointL t -> Stream m (PointL t)

IndexStream ((:.) Z (BitSet t)) => IndexStream (BitSet t)

Methods

streamUp :: Monad m => BitSet t -> BitSet t -> Stream m (BitSet t)

streamDown :: Monad m => BitSet t -> BitSet t -> Stream m (BitSet t)

IndexStream ((:.) Z (Subword t)) => IndexStream (Subword t)

Methods

streamUp :: Monad m => Subword t -> Subword t -> Stream m (Subword t)

streamDown :: Monad m => Subword t -> Subword t -> Stream m (Subword t)

IndexStream ((:.) Z (Unit t)) => IndexStream (Unit t)

Methods

streamUp :: Monad m => Unit t -> Unit t -> Stream m (Unit t)

streamDown :: Monad m => Unit t -> Unit t -> Stream m (Unit t)

IndexStream z => IndexStream ((:.) z (EdgeBoundary C))

EdgeBoundary C (complement)

Methods

streamUp :: Monad m => (z :. EdgeBoundary C) -> (z :. EdgeBoundary C) -> Stream m (z :. EdgeBoundary C)

streamDown :: Monad m => (z :. EdgeBoundary C) -> (z :. EdgeBoundary C) -> Stream m (z :. EdgeBoundary C)

IndexStream z => IndexStream ((:.) z (EdgeBoundary O))

EdgeBoundary O (outside).

Note: streamUp really needs to use streamDownMk / streamDownStep for the right order of indices!

Methods

streamUp :: Monad m => (z :. EdgeBoundary O) -> (z :. EdgeBoundary O) -> Stream m (z :. EdgeBoundary O)

streamDown :: Monad m => (z :. EdgeBoundary O) -> (z :. EdgeBoundary O) -> Stream m (z :. EdgeBoundary O)

IndexStream z => IndexStream ((:.) z (EdgeBoundary I))

EdgeBoundary I (inside)

Methods

streamUp :: Monad m => (z :. EdgeBoundary I) -> (z :. EdgeBoundary I) -> Stream m (z :. EdgeBoundary I)

streamDown :: Monad m => (z :. EdgeBoundary I) -> (z :. EdgeBoundary I) -> Stream m (z :. EdgeBoundary I)

IndexStream z => IndexStream ((:.) z (PInt C p))

Methods

streamUp :: Monad m => (z :. PInt C p) -> (z :. PInt C p) -> Stream m (z :. PInt C p)

streamDown :: Monad m => (z :. PInt C p) -> (z :. PInt C p) -> Stream m (z :. PInt C p)

IndexStream z => IndexStream ((:.) z (PInt O p))

Methods

streamUp :: Monad m => (z :. PInt O p) -> (z :. PInt O p) -> Stream m (z :. PInt O p)

streamDown :: Monad m => (z :. PInt O p) -> (z :. PInt O p) -> Stream m (z :. PInt O p)

IndexStream z => IndexStream ((:.) z (PInt I p))

Methods

streamUp :: Monad m => (z :. PInt I p) -> (z :. PInt I p) -> Stream m (z :. PInt I p)

streamDown :: Monad m => (z :. PInt I p) -> (z :. PInt I p) -> Stream m (z :. PInt I p)

IndexStream z => IndexStream ((:.) z (PointL C))

Methods

streamUp :: Monad m => (z :. PointL C) -> (z :. PointL C) -> Stream m (z :. PointL C)

streamDown :: Monad m => (z :. PointL C) -> (z :. PointL C) -> Stream m (z :. PointL C)

IndexStream z => IndexStream ((:.) z (PointL O))

Methods

streamUp :: Monad m => (z :. PointL O) -> (z :. PointL O) -> Stream m (z :. PointL O)

streamDown :: Monad m => (z :. PointL O) -> (z :. PointL O) -> Stream m (z :. PointL O)

IndexStream z => IndexStream ((:.) z (PointL I))

Methods

streamUp :: Monad m => (z :. PointL I) -> (z :. PointL I) -> Stream m (z :. PointL I)

streamDown :: Monad m => (z :. PointL I) -> (z :. PointL I) -> Stream m (z :. PointL I)

IndexStream z => IndexStream ((:.) z (Boundary k I))

Methods

streamUp :: Monad m => (z :. Boundary k I) -> (z :. Boundary k I) -> Stream m (z :. Boundary k I)

streamDown :: Monad m => (z :. Boundary k I) -> (z :. Boundary k I) -> Stream m (z :. Boundary k I)

IndexStream z => IndexStream ((:.) z (BS2 i j C))

Methods

streamUp :: Monad m => (z :. BS2 i j C) -> (z :. BS2 i j C) -> Stream m (z :. BS2 i j C)

streamDown :: Monad m => (z :. BS2 i j C) -> (z :. BS2 i j C) -> Stream m (z :. BS2 i j C)

IndexStream z => IndexStream ((:.) z (BS2 i j O))

Methods

streamUp :: Monad m => (z :. BS2 i j O) -> (z :. BS2 i j O) -> Stream m (z :. BS2 i j O)

streamDown :: Monad m => (z :. BS2 i j O) -> (z :. BS2 i j O) -> Stream m (z :. BS2 i j O)

IndexStream z => IndexStream ((:.) z (BS2 i j I))

Methods

streamUp :: Monad m => (z :. BS2 i j I) -> (z :. BS2 i j I) -> Stream m (z :. BS2 i j I)

streamDown :: Monad m => (z :. BS2 i j I) -> (z :. BS2 i j I) -> Stream m (z :. BS2 i j I)

IndexStream z => IndexStream ((:.) z (BS1 i C))

Methods

streamUp :: Monad m => (z :. BS1 i C) -> (z :. BS1 i C) -> Stream m (z :. BS1 i C)

streamDown :: Monad m => (z :. BS1 i C) -> (z :. BS1 i C) -> Stream m (z :. BS1 i C)

IndexStream z => IndexStream ((:.) z (BS1 i O))

Methods

streamUp :: Monad m => (z :. BS1 i O) -> (z :. BS1 i O) -> Stream m (z :. BS1 i O)

streamDown :: Monad m => (z :. BS1 i O) -> (z :. BS1 i O) -> Stream m (z :. BS1 i O)

IndexStream z => IndexStream ((:.) z (BS1 i I))

Methods

streamUp :: Monad m => (z :. BS1 i I) -> (z :. BS1 i I) -> Stream m (z :. BS1 i I)

streamDown :: Monad m => (z :. BS1 i I) -> (z :. BS1 i I) -> Stream m (z :. BS1 i I)

IndexStream z => IndexStream ((:.) z (BitSet C))

Methods

streamUp :: Monad m => (z :. BitSet C) -> (z :. BitSet C) -> Stream m (z :. BitSet C)

streamDown :: Monad m => (z :. BitSet C) -> (z :. BitSet C) -> Stream m (z :. BitSet C)

IndexStream z => IndexStream ((:.) z (BitSet O))

Methods

streamUp :: Monad m => (z :. BitSet O) -> (z :. BitSet O) -> Stream m (z :. BitSet O)

streamDown :: Monad m => (z :. BitSet O) -> (z :. BitSet O) -> Stream m (z :. BitSet O)

IndexStream z => IndexStream ((:.) z (BitSet I))

Methods

streamUp :: Monad m => (z :. BitSet I) -> (z :. BitSet I) -> Stream m (z :. BitSet I)

streamDown :: Monad m => (z :. BitSet I) -> (z :. BitSet I) -> Stream m (z :. BitSet I)

IndexStream z => IndexStream ((:.) z (Subword C))

Subword C (complement)

Methods

streamUp :: Monad m => (z :. Subword C) -> (z :. Subword C) -> Stream m (z :. Subword C)

streamDown :: Monad m => (z :. Subword C) -> (z :. Subword C) -> Stream m (z :. Subword C)

IndexStream z => IndexStream ((:.) z (Subword O))

Subword O (outside).

Note: streamUp really needs to use streamDownMk / streamDownStep for the right order of indices!

Methods

streamUp :: Monad m => (z :. Subword O) -> (z :. Subword O) -> Stream m (z :. Subword O)

streamDown :: Monad m => (z :. Subword O) -> (z :. Subword O) -> Stream m (z :. Subword O)

IndexStream z => IndexStream ((:.) z (Subword I))

Subword I (inside)

Methods

streamUp :: Monad m => (z :. Subword I) -> (z :. Subword I) -> Stream m (z :. Subword I)

streamDown :: Monad m => (z :. Subword I) -> (z :. Subword I) -> Stream m (z :. Subword I)

IndexStream z => IndexStream ((:.) z (Unit t))

Methods

streamUp :: Monad m => (z :. Unit t) -> (z :. Unit t) -> Stream m (z :. Unit t)

streamDown :: Monad m => (z :. Unit t) -> (z :. Unit t) -> Stream m (z :. Unit t)

IndexStream (PInt C p)

Methods

streamUp :: Monad m => PInt C p -> PInt C p -> Stream m (PInt C p)

streamDown :: Monad m => PInt C p -> PInt C p -> Stream m (PInt C p)

IndexStream (PInt O p)

Methods

streamUp :: Monad m => PInt O p -> PInt O p -> Stream m (PInt O p)

streamDown :: Monad m => PInt O p -> PInt O p -> Stream m (PInt O p)

IndexStream (PInt I p)

Methods

streamUp :: Monad m => PInt I p -> PInt I p -> Stream m (PInt I p)

streamDown :: Monad m => PInt I p -> PInt I p -> Stream m (PInt I p)

IndexStream ((:.) Z (BS1 i t)) => IndexStream (BS1 i t)

Methods

streamUp :: Monad m => BS1 i t -> BS1 i t -> Stream m (BS1 i t)

streamDown :: Monad m => BS1 i t -> BS1 i t -> Stream m (BS1 i t)

IndexStream ((:.) Z (Boundary k I)) => IndexStream (Boundary k I)

Methods

streamUp :: Monad m => Boundary k I -> Boundary k I -> Stream m (Boundary k I)

streamDown :: Monad m => Boundary k I -> Boundary k I -> Stream m (Boundary k I)

IndexStream ((:.) Z (BS2 i j t)) => IndexStream (BS2 i j t)

Methods

streamUp :: Monad m => BS2 i j t -> BS2 i j t -> Stream m (BS2 i j t)

streamDown :: Monad m => BS2 i j t -> BS2 i j t -> Stream m (BS2 i j t)