-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Efficient multidimensional arrays
--   
--   <a>generalized Algebraic Dynamic Programming</a>
--   
--   This library provides efficient multidimensional arrays. Import
--   <tt>Data.PrimitiveArray</tt> for indices, lenses, and arrays.
--   
--   For <a>generalized ADP</a> users, the library also provides the
--   machinary to fill tables in the correct order required by usual
--   CYK-style parsers, or regular grammars (used e.g. in alignment
--   algorithms). This means that unless your grammar require a strange
--   order in which parsing is to be performed, it will mostly "just work".
--   
--   In general all operations are (highly) unsafe, no bounds-checking or
--   other sanity-checking is performed. Operations are aimed toward
--   efficiency as much as possible.
@package PrimitiveArray
@version 0.7.0.0

module Data.PrimitiveArray.Index.IOC

-- | Phantom type for <tt>Inside</tt> indices.
data I

-- | Phantom type for <tt>Outside</tt> indices.
data O

-- | Phantom type for <tt>Complement</tt> indices.
data C

module Data.PrimitiveArray.Index.Class

-- | Strict pairs -- as in <tt>repa</tt>.
data (:.) a b
(:.) :: !a -> !b -> (:.) a b

-- | A different version of strict pairs. Makes for simpler type inference
--   in multi-tape grammars. We use <tt>:&gt;</tt> when we have special
--   needs, like non-recursive instances on inductives tuples, as used for
--   set indices.
--   
--   This one is <tt>infixr</tt> so that in <tt>a :&gt; b</tt> we can have
--   the main type in <tt>a</tt> and the specializing types in <tt>b</tt>
--   and then dispatch on <tt>a :&gt; ts</tt> with <tt>ts</tt> maybe a
--   chain of <tt>:&gt;</tt>.
data (:>) a b
(:>) :: !a -> !b -> (:>) a b

-- | Base data constructor for multi-dimensional indices.
data Z
Z :: Z

-- | 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.
class Index i

-- | Given a minimal size, a maximal size, and a current index, calculate
--   the linear index.
linearIndex :: Index i => i -> i -> i -> Int

-- | Given an index element from the smallest subset, calculate the highest
--   linear index that is *not* stored.
smallestLinearIndex :: Index i => i -> Int

-- | Given an index element from the largest subset, calculate the highest
--   linear index that *is* stored.
largestLinearIndex :: Index i => i -> Int

-- | Given smallest and largest index, return the number of cells required
--   for storage.
size :: Index i => i -> i -> Int

-- | Check if an index is within the bounds.
inBounds :: Index i => i -> i -> i -> Bool

-- | Generate a stream of indices in correct order for dynamic programming.
--   Since the stream generators require <tt>concatMap</tt> /
--   <tt>flatten</tt> we have to write more specialized code for
--   <tt>(z:.IX)</tt> stuff.
class IndexStream i where streamUp l h = map (\ (Z :. i) -> i) $ streamUp (Z :. l) (Z :. h) streamDown l h = map (\ (Z :. i) -> i) $ streamDown (Z :. l) (Z :. h)

-- | This generates an index stream suitable for <tt>forward</tt> 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 :: (IndexStream i, Monad m) => i -> i -> Stream m i

-- | If <a>streamUp</a> generates indices from smallest to largest, then
--   <a>streamDown</a> 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 :: (IndexStream i, Monad m) => i -> i -> Stream m i
instance Data.Vector.Unboxed.Base.Unbox Data.PrimitiveArray.Index.Class.Z
instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector Data.PrimitiveArray.Index.Class.Z
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector Data.PrimitiveArray.Index.Class.Z
instance Data.Binary.Class.Binary Data.PrimitiveArray.Index.Class.Z
instance Data.Serialize.Serialize Data.PrimitiveArray.Index.Class.Z
instance Data.Aeson.Types.Class.ToJSON Data.PrimitiveArray.Index.Class.Z
instance Data.Aeson.Types.Class.FromJSON Data.PrimitiveArray.Index.Class.Z
instance Data.Hashable.Class.Hashable Data.PrimitiveArray.Index.Class.Z
instance Test.QuickCheck.Arbitrary.Arbitrary Data.PrimitiveArray.Index.Class.Z
instance Control.DeepSeq.NFData Data.PrimitiveArray.Index.Class.Z
instance Data.PrimitiveArray.Index.Class.Index Data.PrimitiveArray.Index.Class.Z
instance Data.PrimitiveArray.Index.Class.IndexStream Data.PrimitiveArray.Index.Class.Z
instance (Data.PrimitiveArray.Index.Class.Index zs, Data.PrimitiveArray.Index.Class.Index z) => Data.PrimitiveArray.Index.Class.Index (zs Data.PrimitiveArray.Index.Class.:. z)
instance (Data.PrimitiveArray.Index.Class.Index zs, Data.PrimitiveArray.Index.Class.Index z) => Data.PrimitiveArray.Index.Class.Index (zs Data.PrimitiveArray.Index.Class.:> z)
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.Class.C1_0Z
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.Class.D1Z
instance GHC.Generics.Generic Data.PrimitiveArray.Index.Class.Z
instance GHC.Show.Show Data.PrimitiveArray.Index.Class.Z
instance GHC.Read.Read Data.PrimitiveArray.Index.Class.Z
instance GHC.Classes.Ord Data.PrimitiveArray.Index.Class.Z
instance GHC.Classes.Eq Data.PrimitiveArray.Index.Class.Z
instance (GHC.Read.Read a, GHC.Read.Read b) => GHC.Read.Read (a Data.PrimitiveArray.Index.Class.:> b)
instance (Data.Vector.Unboxed.Base.Unbox a0, Data.Vector.Unboxed.Base.Unbox b0) => Data.Vector.Unboxed.Base.Unbox (a0 Data.PrimitiveArray.Index.Class.:> b0)
instance (Data.Vector.Unboxed.Base.Unbox a0, Data.Vector.Unboxed.Base.Unbox b0) => Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (a0 Data.PrimitiveArray.Index.Class.:> b0)
instance (Data.Vector.Unboxed.Base.Unbox a0, Data.Vector.Unboxed.Base.Unbox b0) => Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (a0 Data.PrimitiveArray.Index.Class.:> b0)
instance (Data.Binary.Class.Binary a, Data.Binary.Class.Binary b) => Data.Binary.Class.Binary (a Data.PrimitiveArray.Index.Class.:> b)
instance (Data.Serialize.Serialize a, Data.Serialize.Serialize b) => Data.Serialize.Serialize (a Data.PrimitiveArray.Index.Class.:> b)
instance (Data.Aeson.Types.Class.ToJSON a, Data.Aeson.Types.Class.ToJSON b) => Data.Aeson.Types.Class.ToJSON (a Data.PrimitiveArray.Index.Class.:> b)
instance (Data.Aeson.Types.Class.FromJSON a, Data.Aeson.Types.Class.FromJSON b) => Data.Aeson.Types.Class.FromJSON (a Data.PrimitiveArray.Index.Class.:> b)
instance (Data.Hashable.Class.Hashable a, Data.Hashable.Class.Hashable b) => Data.Hashable.Class.Hashable (a Data.PrimitiveArray.Index.Class.:> b)
instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (a Data.PrimitiveArray.Index.Class.:> b)
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.Class.C1_0:>
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.Class.D1:>
instance GHC.Generics.Generic (a Data.PrimitiveArray.Index.Class.:> b)
instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (a Data.PrimitiveArray.Index.Class.:> b)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (a Data.PrimitiveArray.Index.Class.:> b)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (a Data.PrimitiveArray.Index.Class.:> b)
instance (GHC.Read.Read a, GHC.Read.Read b) => GHC.Read.Read (a Data.PrimitiveArray.Index.Class.:. b)
instance (Data.Vector.Unboxed.Base.Unbox a0, Data.Vector.Unboxed.Base.Unbox b0) => Data.Vector.Unboxed.Base.Unbox (a0 Data.PrimitiveArray.Index.Class.:. b0)
instance (Data.Vector.Unboxed.Base.Unbox a0, Data.Vector.Unboxed.Base.Unbox b0) => Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (a0 Data.PrimitiveArray.Index.Class.:. b0)
instance (Data.Vector.Unboxed.Base.Unbox a0, Data.Vector.Unboxed.Base.Unbox b0) => Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (a0 Data.PrimitiveArray.Index.Class.:. b0)
instance (Data.Binary.Class.Binary a, Data.Binary.Class.Binary b) => Data.Binary.Class.Binary (a Data.PrimitiveArray.Index.Class.:. b)
instance (Data.Serialize.Serialize a, Data.Serialize.Serialize b) => Data.Serialize.Serialize (a Data.PrimitiveArray.Index.Class.:. b)
instance (Data.Aeson.Types.Class.ToJSON a, Data.Aeson.Types.Class.ToJSON b) => Data.Aeson.Types.Class.ToJSON (a Data.PrimitiveArray.Index.Class.:. b)
instance (Data.Aeson.Types.Class.FromJSON a, Data.Aeson.Types.Class.FromJSON b) => Data.Aeson.Types.Class.FromJSON (a Data.PrimitiveArray.Index.Class.:. b)
instance (Data.Hashable.Class.Hashable a, Data.Hashable.Class.Hashable b) => Data.Hashable.Class.Hashable (a Data.PrimitiveArray.Index.Class.:. b)
instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (a Data.PrimitiveArray.Index.Class.:. b)
instance (Test.QuickCheck.Arbitrary.Arbitrary a, Test.QuickCheck.Arbitrary.Arbitrary b) => Test.QuickCheck.Arbitrary.Arbitrary (a Data.PrimitiveArray.Index.Class.:. b)
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.Class.C1_0:.
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.Class.D1:.
instance GHC.Generics.Generic (a Data.PrimitiveArray.Index.Class.:. b)
instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (a Data.PrimitiveArray.Index.Class.:. b)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (a Data.PrimitiveArray.Index.Class.:. b)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (a Data.PrimitiveArray.Index.Class.:. b)


-- | Unit indices admit a single element to be memoized. We can't use
--   <tt>()</tt> because we want to attach phantom types.
module Data.PrimitiveArray.Index.Unit
data Unit t
Unit :: Unit t
instance Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.Unit.Unit t0)
instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Data.PrimitiveArray.Index.Unit.Unit t0)
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Data.PrimitiveArray.Index.Unit.Unit t0)
instance Data.Binary.Class.Binary (Data.PrimitiveArray.Index.Unit.Unit t)
instance Data.Serialize.Serialize (Data.PrimitiveArray.Index.Unit.Unit t)
instance Data.Aeson.Types.Class.FromJSON (Data.PrimitiveArray.Index.Unit.Unit t)
instance Data.Aeson.Types.Class.ToJSON (Data.PrimitiveArray.Index.Unit.Unit t)
instance Data.Hashable.Class.Hashable (Data.PrimitiveArray.Index.Unit.Unit t)
instance Control.DeepSeq.NFData (Data.PrimitiveArray.Index.Unit.Unit t)
instance Data.PrimitiveArray.Index.Class.Index (Data.PrimitiveArray.Index.Unit.Unit t)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Unit.Unit t)
instance Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Class.Z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Unit.Unit t) => Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Unit.Unit t)
instance Test.QuickCheck.Arbitrary.Arbitrary (Data.PrimitiveArray.Index.Unit.Unit t)
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.Unit.C1_0Unit
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.Unit.D1Unit
instance GHC.Read.Read (Data.PrimitiveArray.Index.Unit.Unit t)
instance GHC.Generics.Generic (Data.PrimitiveArray.Index.Unit.Unit t)
instance GHC.Show.Show (Data.PrimitiveArray.Index.Unit.Unit t)
instance GHC.Classes.Ord (Data.PrimitiveArray.Index.Unit.Unit t)
instance GHC.Classes.Eq (Data.PrimitiveArray.Index.Unit.Unit t)

module Data.PrimitiveArray.Vector.Compat
flatten :: Monad m => (a -> m s) -> (s -> m (Step s b)) -> Stream m a -> Stream m b

-- | Size hint
data Size :: *

-- | Exact size
Exact :: Int -> Size

-- | Upper bound on the size
Max :: Int -> Size

-- | Unknown size
Unknown :: Size

module Data.PrimitiveArray.Index.Int
instance Data.PrimitiveArray.Index.Class.Index GHC.Types.Int
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. GHC.Types.Int)
instance Data.PrimitiveArray.Index.Class.IndexStream GHC.Types.Int


-- | A linear 0-based int-index with a phantom type.
module Data.PrimitiveArray.Index.PhantomInt

-- | A <a>PInt</a> behaves exactly like an <tt>Int</tt>, but has an
--   attached phantom type <tt>p</tt>. In particular, the <tt>Index</tt>
--   and <tt>IndexStream</tt> instances are the same as for raw
--   <tt>Int</tt>s.
newtype PInt t p
PInt :: Int -> PInt t p
[getPInt] :: PInt t p -> Int
pIntI :: Int -> PInt I p
pIntO :: Int -> PInt O p
pIntC :: Int -> PInt C p
streamUpMk :: Monad m => t2 -> t -> t1 -> m (t1, t2)
streamUpStep :: (Monad m, Num t2, Ord t2) => t -> t2 -> (t1, t2) -> m (Step (t1, t2) ((:.) t1 t2))
streamDownMk :: Monad m => t -> t2 -> t1 -> m (t1, t2)
streamDownStep :: (Monad m, Num t2, Ord t2) => t2 -> t -> (t1, t2) -> m (Step (t1, t2) ((:.) t1 t2))
instance Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.PhantomInt.PInt t0 p0)
instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Data.PrimitiveArray.Index.PhantomInt.PInt t0 p0)
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Data.PrimitiveArray.Index.PhantomInt.PInt t0 p0)
instance Data.Binary.Class.Binary (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance Data.Serialize.Serialize (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance Data.Aeson.Types.Class.FromJSON (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance Data.Aeson.Types.Class.ToJSON (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance Data.Hashable.Class.Hashable (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance Control.DeepSeq.NFData (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance Data.PrimitiveArray.Index.Class.Index (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.PhantomInt.PInt Data.PrimitiveArray.Index.IOC.I p)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.PhantomInt.PInt Data.PrimitiveArray.Index.IOC.O p)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.PhantomInt.PInt Data.PrimitiveArray.Index.IOC.C p)
instance Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.PhantomInt.PInt Data.PrimitiveArray.Index.IOC.I p)
instance Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.PhantomInt.PInt Data.PrimitiveArray.Index.IOC.O p)
instance Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.PhantomInt.PInt Data.PrimitiveArray.Index.IOC.C p)
instance GHC.Generics.Selector Data.PrimitiveArray.Index.PhantomInt.S1_0_0PInt
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.PhantomInt.C1_0PInt
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.PhantomInt.D1PInt
instance GHC.Arr.Ix (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance (Data.Data.Data t, Data.Data.Data p) => Data.Data.Data (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance GHC.Generics.Generic (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance GHC.Real.Real (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance GHC.Real.Integral (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance GHC.Num.Num (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance GHC.Enum.Enum (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance GHC.Classes.Ord (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance GHC.Classes.Eq (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance GHC.Show.Show (Data.PrimitiveArray.Index.PhantomInt.PInt t p)
instance GHC.Read.Read (Data.PrimitiveArray.Index.PhantomInt.PInt t p)


-- | <tt>Point</tt> index structures are used for left- and right-linear
--   grammars. Such grammars have at most one syntactic symbol on each
--   r.h.s. of a rule. The syntactic symbol needs to be in an outermost
--   position.
module Data.PrimitiveArray.Index.Point

-- | A point in a left-linear grammar. The syntactic symbol is in left-most
--   position.
newtype PointL t
PointL :: Int -> PointL t
[fromPointL] :: PointL t -> Int
pointLI :: Int -> PointL I
pointLO :: Int -> PointL O
pointLC :: Int -> PointL C

-- | A point in a right-linear grammars.
newtype PointR t
PointR :: Int -> PointR t
[fromPointR] :: PointR t -> Int
streamUpMk :: Monad m => t1 -> t -> m (t, t1)
streamUpStep :: Monad m => Int -> (t1, Int) -> m (Step (t1, Int) ((:.) t1 (PointL t)))
streamDownMk :: Monad m => t1 -> t -> m (t, t1)
streamDownStep :: Monad m => Int -> (t1, Int) -> m (Step (t1, Int) ((:.) t1 (PointL t)))
instance Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.Point.PointR t0)
instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Data.PrimitiveArray.Index.Point.PointR t0)
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Data.PrimitiveArray.Index.Point.PointR t0)
instance Data.Binary.Class.Binary (Data.PrimitiveArray.Index.Point.PointR t)
instance Data.Serialize.Serialize (Data.PrimitiveArray.Index.Point.PointR t)
instance Data.Aeson.Types.Class.FromJSON (Data.PrimitiveArray.Index.Point.PointR t)
instance Data.Aeson.Types.Class.ToJSON (Data.PrimitiveArray.Index.Point.PointR t)
instance Data.Hashable.Class.Hashable (Data.PrimitiveArray.Index.Point.PointR t)
instance Control.DeepSeq.NFData (Data.PrimitiveArray.Index.Point.PointR t)
instance Data.PrimitiveArray.Index.Class.Index (Data.PrimitiveArray.Index.Point.PointR t)
instance Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.Point.PointL t0)
instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Data.PrimitiveArray.Index.Point.PointL t0)
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Data.PrimitiveArray.Index.Point.PointL t0)
instance Data.Binary.Class.Binary (Data.PrimitiveArray.Index.Point.PointL t)
instance Data.Serialize.Serialize (Data.PrimitiveArray.Index.Point.PointL t)
instance Data.Aeson.Types.Class.FromJSON (Data.PrimitiveArray.Index.Point.PointL t)
instance Data.Aeson.Types.Class.ToJSON (Data.PrimitiveArray.Index.Point.PointL t)
instance Data.Hashable.Class.Hashable (Data.PrimitiveArray.Index.Point.PointL t)
instance Control.DeepSeq.NFData (Data.PrimitiveArray.Index.Point.PointL t)
instance Data.PrimitiveArray.Index.Class.Index (Data.PrimitiveArray.Index.Point.PointL t)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Point.PointL Data.PrimitiveArray.Index.IOC.I)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Point.PointL Data.PrimitiveArray.Index.IOC.O)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Point.PointL Data.PrimitiveArray.Index.IOC.C)
instance Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Class.Z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Point.PointL t) => Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Point.PointL t)
instance Test.QuickCheck.Arbitrary.Arbitrary (Data.PrimitiveArray.Index.Point.PointL t)
instance GHC.Generics.Selector Data.PrimitiveArray.Index.Point.S1_0_0PointR
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.Point.C1_0PointR
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.Point.D1PointR
instance GHC.Generics.Selector Data.PrimitiveArray.Index.Point.S1_0_0PointL
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.Point.C1_0PointL
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.Point.D1PointL
instance GHC.Generics.Generic (Data.PrimitiveArray.Index.Point.PointR t)
instance GHC.Show.Show (Data.PrimitiveArray.Index.Point.PointR t)
instance GHC.Read.Read (Data.PrimitiveArray.Index.Point.PointR t)
instance GHC.Classes.Eq (Data.PrimitiveArray.Index.Point.PointR t)
instance GHC.Generics.Generic (Data.PrimitiveArray.Index.Point.PointL t)
instance GHC.Show.Show (Data.PrimitiveArray.Index.Point.PointL t)
instance GHC.Read.Read (Data.PrimitiveArray.Index.Point.PointL t)
instance GHC.Classes.Eq (Data.PrimitiveArray.Index.Point.PointL t)


-- | Set with and without interfaces. We provide instances for sets, and
--   sets with one or two interfaces. The <tt>First</tt> and <tt>Last</tt>
--   annotation is purely cosmetical (apart from introducing type safety).
module Data.PrimitiveArray.Index.Set

-- | Certain sets have an interface, a particular element with special
--   meaning. In this module, certain `<tt>meanings'</tt> are already
--   provided. These include a <tt>First</tt> element and a <tt>Last</tt>
--   element. We phantom-type these to reduce programming overhead.
newtype Interface t
Iter :: Int -> Interface t
[getIter] :: Interface t -> Int

-- | Declare the interface to be the start of a path.
data First

-- | Declare the interface to be the end of a path.
data Last

-- | Declare the interface to match anything.
--   
--   TODO needed? want to use later in ADPfusion
data Any

-- | Newtype for a bitset. We'd use <tt>Word</tt>s but that requires more
--   shape instances.
--   
--   TODO can we use <tt>Word</tt>s now?
newtype BitSet t
BitSet :: Int -> BitSet t
[getBitSet] :: BitSet t -> Int
bitSetI :: Int -> BitSet I
bitSetO :: Int -> BitSet O
bitSetC :: Int -> BitSet C

-- | A bitset with one interface.
data BS1 i t
BS1 :: !(BitSet t) -> !(Interface i) -> BS1 i t

-- | A bitset with two interfaces.
data BS2 i j t
BS2 :: !(BitSet t) -> !(Interface i) -> !(Interface j) -> BS2 i j t

-- | Successor and Predecessor for sets. Designed as a class to accomodate
--   sets with interfaces and without interfaces with one function.
--   
--   The functions are not written recursively, as we currently only have
--   three cases, and we do not want to "reset" while generating successors
--   and predecessors.
--   
--   Note that sets have a partial order. Within the group of element with
--   the same <tt>popCount</tt>, we use <tt>popPermutation</tt> which has
--   the same stepping order for both, <tt>setSucc</tt> and
--   <tt>setPred</tt>.
class SetPredSucc s

-- | Set successor. The first argument is the lower set limit, the second
--   the upper set limit, the third the current set.
setSucc :: SetPredSucc s => s -> s -> s -> Maybe s

-- | Set predecessor. The first argument is the lower set limit, the second
--   the upper set limit, the third the current set.
setPred :: SetPredSucc s => s -> s -> s -> Maybe s

-- | Masks are used quite often for different types of bitsets. We liberate
--   them as a type family.

-- | <tt>Fixed</tt> allows us to fix some or all bits of a bitset, thereby
--   providing <tt>succ/pred</tt> operations which are only partially free.
--   
--   The mask is lazy, this allows us to have <tt>undefined</tt> for
--   <tt>l</tt> and <tt>h</tt>.
--   
--   <tt>f = getFixedMask .&amp;. getFixed</tt> are the fixed bits. <tt>n =
--   getFixed .&amp;. complement getFixedMask</tt> are the free bits.
--   <tt>to = complement getFixed</tt> is the to move mask <tt>n' =
--   popShiftR to n</tt> yields the population after the move <tt>p =
--   popPermutation undefined n'</tt> yields the new population permutation
--   <tt>p' = popShiftL to p</tt> yields the population moved back
--   <tt>final = p' .|. f</tt>
data Fixed t
Fixed :: (Mask t) -> !t -> Fixed t
[getFixedMask] :: Fixed t -> (Mask t)
[getFixed] :: Fixed t -> !t

-- | Assuming a bitset on bits <tt>[0 .. highbit]</tt>, we can apply a mask
--   that stretches out those bits over <tt>[0 .. higherBit]</tt> with
--   <tt>highbit &lt;= higherBit</tt>. Any active interfaces are correctly
--   set as well.
class ApplyMask s
applyMask :: ApplyMask s => Mask s -> s -> s
streamUpBsMk :: (Monad m, Ord a) => a -> a -> t -> m (t, Maybe a)
streamUpBsStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))
streamDownBsMk :: (Monad m, Ord a) => a -> a -> t -> m (t, Maybe a)
streamDownBsStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))
streamUpBsIMk :: (Monad m) => BS1 a i -> BS1 b i -> z -> m (z, Maybe (BS1 c i))
streamUpBsIStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))
streamDownBsIMk :: (Monad m) => BS1 a i -> BS1 b i -> z -> m (z, Maybe (BS1 c i))
streamDownBsIStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))
streamUpBsIiMk :: (Monad m) => BS2 a b i -> BS2 c d i -> z -> m (z, Maybe (BS2 e f i))
streamUpBsIiStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))
streamDownBsIiMk :: (Monad m) => BS2 a b i -> BS2 c d i -> z -> m (z, Maybe (BS2 e f i))
streamDownBsIiStep :: (Monad m, SetPredSucc s) => s -> s -> (t, Maybe s) -> m (Step (t, Maybe s) (t :. s))
testBsS :: BitSet t -> Maybe (Fixed (BitSet t))
arbitraryBitSetMax :: Integer
instance GHC.Generics.Selector Data.PrimitiveArray.Index.Set.S1_0_1Fixed
instance GHC.Generics.Selector Data.PrimitiveArray.Index.Set.S1_0_0Fixed
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.Set.C1_0Fixed
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.Set.D1Fixed
instance (GHC.Classes.Eq t, GHC.Classes.Eq (Data.PrimitiveArray.Index.Set.Mask t)) => GHC.Classes.Eq (Data.PrimitiveArray.Index.Set.Fixed t)
instance (GHC.Classes.Ord t, GHC.Classes.Ord (Data.PrimitiveArray.Index.Set.Mask t)) => GHC.Classes.Ord (Data.PrimitiveArray.Index.Set.Fixed t)
instance (GHC.Read.Read t, GHC.Read.Read (Data.PrimitiveArray.Index.Set.Mask t)) => GHC.Read.Read (Data.PrimitiveArray.Index.Set.Fixed t)
instance (GHC.Show.Show t, GHC.Show.Show (Data.PrimitiveArray.Index.Set.Mask t)) => GHC.Show.Show (Data.PrimitiveArray.Index.Set.Fixed t)
instance (GHC.Generics.Generic t, GHC.Generics.Generic (Data.PrimitiveArray.Index.Set.Mask t)) => GHC.Generics.Generic (Data.PrimitiveArray.Index.Set.Fixed t)
instance (Data.Vector.Unboxed.Base.Unbox t0, Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.Set.Mask t0)) => Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.Set.Fixed t0)
instance (Data.Vector.Unboxed.Base.Unbox t0, Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.Set.Mask t0)) => Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Data.PrimitiveArray.Index.Set.Fixed t0)
instance (Data.Vector.Unboxed.Base.Unbox t0, Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.Set.Mask t0)) => Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Data.PrimitiveArray.Index.Set.Fixed t0)
instance (GHC.Generics.Generic t, GHC.Generics.Generic (Data.PrimitiveArray.Index.Set.Mask t), Data.Hashable.Class.Hashable t, Data.Hashable.Class.Hashable (Data.PrimitiveArray.Index.Set.Mask t)) => Data.Hashable.Class.Hashable (Data.PrimitiveArray.Index.Set.Fixed t)
instance (GHC.Generics.Generic t, GHC.Generics.Generic (Data.PrimitiveArray.Index.Set.Mask t), Data.Binary.Class.Binary t, Data.Binary.Class.Binary (Data.PrimitiveArray.Index.Set.Mask t)) => Data.Binary.Class.Binary (Data.PrimitiveArray.Index.Set.Fixed t)
instance (GHC.Generics.Generic t, GHC.Generics.Generic (Data.PrimitiveArray.Index.Set.Mask t), Data.Serialize.Serialize t, Data.Serialize.Serialize (Data.PrimitiveArray.Index.Set.Mask t)) => Data.Serialize.Serialize (Data.PrimitiveArray.Index.Set.Fixed t)
instance Control.DeepSeq.NFData (Data.PrimitiveArray.Index.Set.Fixed t)
instance Data.PrimitiveArray.Index.Set.SetPredSucc (Data.PrimitiveArray.Index.Set.Fixed (Data.PrimitiveArray.Index.Set.BitSet t))
instance Data.PrimitiveArray.Index.Set.SetPredSucc (Data.PrimitiveArray.Index.Set.Fixed (Data.PrimitiveArray.Index.Set.BS1 i t))
instance Data.PrimitiveArray.Index.Set.SetPredSucc (Data.PrimitiveArray.Index.Set.Fixed (Data.PrimitiveArray.Index.Set.BS2 i j t))
instance Data.PrimitiveArray.Index.Set.ApplyMask (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.PrimitiveArray.Index.Set.ApplyMask (Data.PrimitiveArray.Index.Set.BS1 i t)
instance Data.PrimitiveArray.Index.Set.ApplyMask (Data.PrimitiveArray.Index.Set.BS2 i j t)
instance (Test.QuickCheck.Arbitrary.Arbitrary t, Test.QuickCheck.Arbitrary.Arbitrary (Data.PrimitiveArray.Index.Set.Mask t)) => Test.QuickCheck.Arbitrary.Arbitrary (Data.PrimitiveArray.Index.Set.Fixed t)
instance Test.QuickCheck.Arbitrary.Arbitrary (Data.PrimitiveArray.Index.Set.BitSet t)
instance Test.QuickCheck.Arbitrary.Arbitrary (Data.PrimitiveArray.Index.Set.BS1 i t)
instance Test.QuickCheck.Arbitrary.Arbitrary (Data.PrimitiveArray.Index.Set.BS2 i j t)
instance Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.Set.BitSet t0)
instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Data.PrimitiveArray.Index.Set.BitSet t0)
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Data.PrimitiveArray.Index.Set.BitSet t0)
instance GHC.Show.Show (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.Binary.Class.Binary (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.Serialize.Serialize (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.Aeson.Types.Class.ToJSON (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.Aeson.Types.Class.FromJSON (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.Hashable.Class.Hashable (Data.PrimitiveArray.Index.Set.BitSet t)
instance Control.DeepSeq.NFData (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.PrimitiveArray.Index.Class.Index (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BitSet Data.PrimitiveArray.Index.IOC.I)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BitSet Data.PrimitiveArray.Index.IOC.O)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BitSet Data.PrimitiveArray.Index.IOC.C)
instance Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Class.Z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BitSet t) => Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.PrimitiveArray.Index.Class.Index (Data.PrimitiveArray.Index.Set.BS1 i t)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BS1 i Data.PrimitiveArray.Index.IOC.I)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BS1 i Data.PrimitiveArray.Index.IOC.O)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BS1 i Data.PrimitiveArray.Index.IOC.C)
instance Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Class.Z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BS1 i t) => Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Set.BS1 i t)
instance Data.PrimitiveArray.Index.Class.Index (Data.PrimitiveArray.Index.Set.BS2 i j t)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BS2 i j Data.PrimitiveArray.Index.IOC.I)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BS2 i j Data.PrimitiveArray.Index.IOC.O)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BS2 i j Data.PrimitiveArray.Index.IOC.C)
instance Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Class.Z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Set.BS2 i j t) => Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Set.BS2 i j t)
instance Data.PrimitiveArray.Index.Set.SetPredSucc (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.PrimitiveArray.Index.Set.SetPredSucc (Data.PrimitiveArray.Index.Set.BS1 i t)
instance Data.PrimitiveArray.Index.Set.SetPredSucc (Data.PrimitiveArray.Index.Set.BS2 i j t)
instance Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.Set.Interface t0)
instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Data.PrimitiveArray.Index.Set.Interface t0)
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Data.PrimitiveArray.Index.Set.Interface t0)
instance Data.Binary.Class.Binary (Data.PrimitiveArray.Index.Set.Interface t)
instance Data.Serialize.Serialize (Data.PrimitiveArray.Index.Set.Interface t)
instance Data.Aeson.Types.Class.ToJSON (Data.PrimitiveArray.Index.Set.Interface t)
instance Data.Aeson.Types.Class.FromJSON (Data.PrimitiveArray.Index.Set.Interface t)
instance Data.Hashable.Class.Hashable (Data.PrimitiveArray.Index.Set.Interface t)
instance Control.DeepSeq.NFData (Data.PrimitiveArray.Index.Set.Interface t)
instance Data.PrimitiveArray.Index.Class.Index (Data.PrimitiveArray.Index.Set.Interface i)
instance GHC.Generics.Selector Data.PrimitiveArray.Index.Set.S1_0_0BitSet
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.Set.C1_0BitSet
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.Set.D1BitSet
instance GHC.Generics.Selector Data.PrimitiveArray.Index.Set.S1_0_0Interface
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.Set.C1_0Interface
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.Set.D1Interface
instance Data.Bits.Bits (Data.PrimitiveArray.Index.Set.BitSet t)
instance GHC.Num.Num (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.Bits.Extras.Ranked (Data.PrimitiveArray.Index.Set.BitSet t)
instance Data.Bits.FiniteBits (Data.PrimitiveArray.Index.Set.BitSet t)
instance GHC.Generics.Generic (Data.PrimitiveArray.Index.Set.BitSet t)
instance GHC.Read.Read (Data.PrimitiveArray.Index.Set.BitSet t)
instance GHC.Classes.Ord (Data.PrimitiveArray.Index.Set.BitSet t)
instance GHC.Classes.Eq (Data.PrimitiveArray.Index.Set.BitSet t)
instance GHC.Num.Num (Data.PrimitiveArray.Index.Set.Interface t)
instance GHC.Generics.Generic (Data.PrimitiveArray.Index.Set.Interface t)
instance GHC.Classes.Ord (Data.PrimitiveArray.Index.Set.Interface t)
instance GHC.Classes.Eq (Data.PrimitiveArray.Index.Set.Interface t)
instance GHC.Show.Show (Data.PrimitiveArray.Index.Set.BS1 i t)
instance GHC.Show.Show (Data.PrimitiveArray.Index.Set.BS2 i j t)
instance GHC.Show.Show (Data.PrimitiveArray.Index.Set.Interface t)

module Data.PrimitiveArray.QuickCheck.Index.Set
prop_Fixed_BitSet_setSucc :: (Word, Fixed (BitSet I)) -> Bool


-- | Index structure for context-free grammars on strings. A
--   <tt>Subword</tt> captures a pair <tt>(i,j)</tt> with <tt>i&lt;=j</tt>.
module Data.PrimitiveArray.Index.Subword

-- | A subword wraps a pair of <tt>Int</tt> indices <tt>i,j</tt> with
--   <tt>i&lt;=j</tt>.
--   
--   Subwords always yield the upper-triangular part of a rect-angular
--   array. This gives the quite curious effect that <tt>(0,N)</tt> points
--   to the `<tt>largest'</tt> index, while <tt>(0,0) ... (1,1) ... (k,k)
--   ... (N,N)</tt> point to the smallest. We do, however, use (0,0) as the
--   smallest as (0,k) gives successively smaller upper triangular parts.
newtype Subword t
Subword :: (Int :. Int) -> Subword t
[fromSubword] :: Subword t -> (Int :. Int)

-- | Create a <tt>Subword t</tt> where <tt>t</tt> is inferred.
subword :: Int -> Int -> Subword t
subwordI :: Int -> Int -> Subword I
subwordO :: Int -> Int -> Subword O
subwordC :: Int -> Int -> Subword C

-- | triangular numbers
--   
--   A000217
triangularNumber :: Int -> Int

-- | Size of an upper triangle starting at <tt>i</tt> and ending at
--   <tt>j</tt>. "(0,N)" what be the normal thing to use.
upperTri :: Subword t -> Int

-- | Subword indexing. Given the longest subword and the current subword,
--   calculate a linear index "[0,..]". "(l,n)" in this case means "l"ower
--   bound, length "n". And "(i,j)" is the normal index.
--   
--   TODO probably doesn't work right with non-zero base ?!
subwordIndex :: Subword s -> Subword t -> Int
subwordFromIndex :: Subword s -> Int -> Subword t

-- | <tt>Subword I</tt> (inside)

-- | <tt>Subword O</tt> (outside).
--   
--   Note: <tt>streamUp</tt> really needs to use <tt>streamDownMk</tt> /
--   <tt>streamDownStep</tt> for the right order of indices!

-- | generic <tt>mk</tt> for <tt>streamUp</tt> / <tt>streamDown</tt>
streamUpMk :: Monad m => t1 -> t -> m (t, t1, t1)
streamUpStep :: Monad m => Int -> Int -> (t1, Int, Int) -> m (Step (t1, Int, Int) ((:.) t1 (Subword t)))
streamDownMk :: Monad m => t1 -> t2 -> t -> m (t, t1, t2)
streamDownStep :: Monad m => Int -> (t1, Int, Int) -> m (Step (t1, Int, Int) ((:.) t1 (Subword t)))
instance Data.Vector.Unboxed.Base.Unbox (Data.PrimitiveArray.Index.Subword.Subword t0)
instance Data.Vector.Generic.Mutable.Base.MVector Data.Vector.Unboxed.Base.MVector (Data.PrimitiveArray.Index.Subword.Subword t0)
instance Data.Vector.Generic.Base.Vector Data.Vector.Unboxed.Base.Vector (Data.PrimitiveArray.Index.Subword.Subword t0)
instance Data.Binary.Class.Binary (Data.PrimitiveArray.Index.Subword.Subword t)
instance Data.Serialize.Serialize (Data.PrimitiveArray.Index.Subword.Subword t)
instance Data.Aeson.Types.Class.FromJSON (Data.PrimitiveArray.Index.Subword.Subword t)
instance Data.Aeson.Types.Class.ToJSON (Data.PrimitiveArray.Index.Subword.Subword t)
instance Data.Hashable.Class.Hashable (Data.PrimitiveArray.Index.Subword.Subword t)
instance Control.DeepSeq.NFData (Data.PrimitiveArray.Index.Subword.Subword t)
instance Data.PrimitiveArray.Index.Class.Index (Data.PrimitiveArray.Index.Subword.Subword t)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Subword.Subword Data.PrimitiveArray.Index.IOC.I)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Subword.Subword Data.PrimitiveArray.Index.IOC.O)
instance Data.PrimitiveArray.Index.Class.IndexStream z => Data.PrimitiveArray.Index.Class.IndexStream (z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Subword.Subword Data.PrimitiveArray.Index.IOC.C)
instance Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Class.Z Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Index.Subword.Subword t) => Data.PrimitiveArray.Index.Class.IndexStream (Data.PrimitiveArray.Index.Subword.Subword t)
instance Test.QuickCheck.Arbitrary.Arbitrary (Data.PrimitiveArray.Index.Subword.Subword t)
instance GHC.Generics.Selector Data.PrimitiveArray.Index.Subword.S1_0_0Subword
instance GHC.Generics.Constructor Data.PrimitiveArray.Index.Subword.C1_0Subword
instance GHC.Generics.Datatype Data.PrimitiveArray.Index.Subword.D1Subword
instance GHC.Read.Read (Data.PrimitiveArray.Index.Subword.Subword t)
instance GHC.Generics.Generic (Data.PrimitiveArray.Index.Subword.Subword t)
instance GHC.Show.Show (Data.PrimitiveArray.Index.Subword.Subword t)
instance GHC.Classes.Ord (Data.PrimitiveArray.Index.Subword.Subword t)
instance GHC.Classes.Eq (Data.PrimitiveArray.Index.Subword.Subword t)

module Data.PrimitiveArray.Index


-- | Vastly extended primitive arrays. Some basic ideas are now modeled
--   after the vector package, especially the monadic mutable / pure
--   immutable array system.
--   
--   NOTE all operations in MPrimArrayOps and PrimArrayOps are highly
--   unsafe. No bounds-checking is performed at all.
module Data.PrimitiveArray.Class

-- | Mutable version of an array.

-- | The core set of operations for monadic arrays.
class (Index sh) => MPrimArrayOps arr sh elm

-- | Return the bounds of the array. All bounds are inclusive, as in
--   <tt>[lb..ub]</tt>
boundsM :: MPrimArrayOps arr sh elm => MutArr m (arr sh elm) -> (sh, sh)

-- | Given lower and upper bounds and a list of <i>all</i> elements,
--   produce a mutable array.
fromListM :: (MPrimArrayOps arr sh elm, PrimMonad m) => sh -> sh -> [elm] -> m (MutArr m (arr sh elm))

-- | Creates a new array with the given bounds with each element within the
--   array being in an undefined state.
newM :: (MPrimArrayOps arr sh elm, PrimMonad m) => sh -> sh -> m (MutArr m (arr sh elm))

-- | Creates a new array with all elements being equal to <tt>elm</tt>.
newWithM :: (MPrimArrayOps arr sh elm, PrimMonad m) => sh -> sh -> elm -> m (MutArr m (arr sh elm))

-- | Reads a single element in the array.
readM :: (MPrimArrayOps arr sh elm, PrimMonad m) => MutArr m (arr sh elm) -> sh -> m elm

-- | Writes a single element in the array.
writeM :: (MPrimArrayOps arr sh elm, PrimMonad m) => MutArr m (arr sh elm) -> sh -> elm -> m ()

-- | The core set of functions on immutable arrays.
class (Index sh) => PrimArrayOps arr sh elm

-- | Returns the bounds of an immutable array, again inclusive bounds: <tt>
--   [lb..ub] </tt>.
bounds :: PrimArrayOps arr sh elm => arr sh elm -> (sh, sh)

-- | Freezes a mutable array an returns its immutable version. This
--   operation is <i>O(1)</i> and both arrays share the same memory. Do not
--   use the mutable array afterwards.
unsafeFreeze :: (PrimArrayOps arr sh elm, PrimMonad m) => MutArr m (arr sh elm) -> m (arr sh elm)

-- | Thaw an immutable array into a mutable one. Both versions share
--   memory.
unsafeThaw :: (PrimArrayOps arr sh elm, PrimMonad m) => arr sh elm -> m (MutArr m (arr sh elm))

-- | Extract a single element from the array. Generally unsafe as not
--   bounds-checking is performed.
unsafeIndex :: PrimArrayOps arr sh elm => arr sh elm -> sh -> elm

-- | Savely transform the shape space of a table.
transformShape :: (PrimArrayOps arr sh elm, Index sh') => (sh -> sh') -> arr sh elm -> arr sh' elm
class (Index sh) => PrimArrayMap arr sh e e'

-- | Map a function over each element, keeping the shape intact.
map :: PrimArrayMap arr sh e e' => (e -> e') -> arr sh e -> arr sh e'

-- | Infix index operator. Performs minimal bounds-checking using assert in
--   non-optimized code.
(!) :: PrimArrayOps arr sh elm => arr sh elm -> sh -> elm

-- | Returns true if the index is valid for the array.
inBoundsM :: (Monad m, MPrimArrayOps arr sh elm) => MutArr m (arr sh elm) -> sh -> Bool

-- | Construct a mutable primitive array from a lower and an upper bound, a
--   default element, and a list of associations.
fromAssocsM :: (PrimMonad m, MPrimArrayOps arr sh elm) => sh -> sh -> elm -> [(sh, elm)] -> m (MutArr m (arr sh elm))

-- | Return all associations from an array.
assocs :: (IndexStream sh, PrimArrayOps arr sh elm) => arr sh elm -> [(sh, elm)]

-- | Creates an immutable array from lower and upper bounds and a complete
--   list of elements.
fromList :: (PrimArrayOps arr sh elm, MPrimArrayOps arr sh elm) => sh -> sh -> [elm] -> arr sh elm

-- | Creates an immutable array from lower and upper bounds, a default
--   element, and a list of associations.
fromAssocs :: (PrimArrayOps arr sh elm, MPrimArrayOps arr sh elm) => sh -> sh -> elm -> [(sh, elm)] -> arr sh elm

-- | Returns all elements of an immutable array as a list.
toList :: (IndexStream sh, PrimArrayOps arr sh elm) => arr sh elm -> [elm]

-- | <a>freezeTables</a> freezes a stack of tables.
class FreezeTables m t where type family Frozen t :: *
freezeTables :: FreezeTables m t => t -> m (Frozen t)
instance GHC.Base.Applicative m => Data.PrimitiveArray.Class.FreezeTables m Data.PrimitiveArray.Index.Class.Z
instance (GHC.Base.Functor m, GHC.Base.Applicative m, GHC.Base.Monad m, Control.Monad.Primitive.PrimMonad m, Data.PrimitiveArray.Class.FreezeTables m ts, Data.PrimitiveArray.Class.PrimArrayOps arr sh elm) => Data.PrimitiveArray.Class.FreezeTables m (ts Data.PrimitiveArray.Index.Class.:. Data.PrimitiveArray.Class.MutArr m (arr sh elm))


-- | Dense primitive arrays where the lower index is zero (or the
--   equivalent of zero for newtypes and enumerations).
--   
--   Actual <tt>write</tt>s to data structures use a more safe
--   <tt>write</tt> instead of the unsafe <tt>unsafeWrite</tt>. Writes also
--   tend to occur much less in DP algorithms (say, N^2 writes for an N^3
--   time algorithm -- mostly reads are being executed).
--   
--   TODO consider if we want to force the lower index to be zero, or allow
--   non-zero lower indices. Will have to be considered together with the
--   <tt>Index.Class</tt> module!
--   
--   TODO while <tt>Unboxed</tt> is, in princile, <tt>Hashable</tt>, we'd
--   need the corresponding <tt>VU.Vector</tt> instances ...
module Data.PrimitiveArray.Dense
data Unboxed sh e
Unboxed :: !sh -> !sh -> !(Vector e) -> Unboxed sh e
data Boxed sh e
Boxed :: !sh -> !sh -> !(Vector e) -> Boxed sh e
instance GHC.Generics.Constructor Data.PrimitiveArray.Dense.C1_0Boxed
instance GHC.Generics.Datatype Data.PrimitiveArray.Dense.D1Boxed
instance GHC.Generics.Constructor Data.PrimitiveArray.Dense.C1_0Unboxed
instance GHC.Generics.Datatype Data.PrimitiveArray.Dense.D1Unboxed
instance GHC.Generics.Generic (Data.PrimitiveArray.Dense.Boxed sh e)
instance (GHC.Classes.Eq sh, GHC.Classes.Eq e) => GHC.Classes.Eq (Data.PrimitiveArray.Dense.Boxed sh e)
instance (GHC.Show.Show sh, GHC.Show.Show e) => GHC.Show.Show (Data.PrimitiveArray.Dense.Boxed sh e)
instance (GHC.Read.Read sh, GHC.Read.Read e) => GHC.Read.Read (Data.PrimitiveArray.Dense.Boxed sh e)
instance GHC.Generics.Generic (Data.PrimitiveArray.Dense.Unboxed sh e)
instance (GHC.Classes.Eq sh, GHC.Classes.Eq e, Data.Vector.Unboxed.Base.Unbox e) => GHC.Classes.Eq (Data.PrimitiveArray.Dense.Unboxed sh e)
instance (GHC.Show.Show sh, GHC.Show.Show e, Data.Vector.Unboxed.Base.Unbox e) => GHC.Show.Show (Data.PrimitiveArray.Dense.Unboxed sh e)
instance (GHC.Read.Read sh, GHC.Read.Read e, Data.Vector.Unboxed.Base.Unbox e) => GHC.Read.Read (Data.PrimitiveArray.Dense.Unboxed sh e)
instance (Data.Binary.Class.Binary sh, Data.Binary.Class.Binary e, Data.Vector.Unboxed.Base.Unbox e) => Data.Binary.Class.Binary (Data.PrimitiveArray.Dense.Unboxed sh e)
instance (Data.Serialize.Serialize sh, Data.Serialize.Serialize e, Data.Vector.Unboxed.Base.Unbox e) => Data.Serialize.Serialize (Data.PrimitiveArray.Dense.Unboxed sh e)
instance (Data.Aeson.Types.Class.ToJSON sh, Data.Aeson.Types.Class.ToJSON e, Data.Vector.Unboxed.Base.Unbox e) => Data.Aeson.Types.Class.ToJSON (Data.PrimitiveArray.Dense.Unboxed sh e)
instance (Data.Aeson.Types.Class.FromJSON sh, Data.Aeson.Types.Class.FromJSON e, Data.Vector.Unboxed.Base.Unbox e) => Data.Aeson.Types.Class.FromJSON (Data.PrimitiveArray.Dense.Unboxed sh e)
instance (Data.Hashable.Class.Hashable sh, Data.Hashable.Class.Hashable e, Data.Hashable.Class.Hashable (Data.Vector.Unboxed.Base.Vector e), Data.Vector.Unboxed.Base.Unbox e) => Data.Hashable.Class.Hashable (Data.PrimitiveArray.Dense.Unboxed sh e)
instance Control.DeepSeq.NFData sh => Control.DeepSeq.NFData (Data.PrimitiveArray.Dense.Unboxed sh e)
instance Control.DeepSeq.NFData sh => Control.DeepSeq.NFData (Data.PrimitiveArray.Class.MutArr m (Data.PrimitiveArray.Dense.Unboxed sh e))
instance (Data.PrimitiveArray.Index.Class.Index sh, Data.Vector.Unboxed.Base.Unbox elm) => Data.PrimitiveArray.Class.MPrimArrayOps Data.PrimitiveArray.Dense.Unboxed sh elm
instance (Data.PrimitiveArray.Index.Class.Index sh, Data.Vector.Unboxed.Base.Unbox elm) => Data.PrimitiveArray.Class.PrimArrayOps Data.PrimitiveArray.Dense.Unboxed sh elm
instance (Data.PrimitiveArray.Index.Class.Index sh, Data.Vector.Unboxed.Base.Unbox e, Data.Vector.Unboxed.Base.Unbox e') => Data.PrimitiveArray.Class.PrimArrayMap Data.PrimitiveArray.Dense.Unboxed sh e e'
instance (Data.Binary.Class.Binary sh, Data.Binary.Class.Binary e) => Data.Binary.Class.Binary (Data.PrimitiveArray.Dense.Boxed sh e)
instance (Data.Serialize.Serialize sh, Data.Serialize.Serialize e) => Data.Serialize.Serialize (Data.PrimitiveArray.Dense.Boxed sh e)
instance (Data.Aeson.Types.Class.ToJSON sh, Data.Aeson.Types.Class.ToJSON e) => Data.Aeson.Types.Class.ToJSON (Data.PrimitiveArray.Dense.Boxed sh e)
instance (Data.Aeson.Types.Class.FromJSON sh, Data.Aeson.Types.Class.FromJSON e) => Data.Aeson.Types.Class.FromJSON (Data.PrimitiveArray.Dense.Boxed sh e)
instance (Data.Hashable.Class.Hashable sh, Data.Hashable.Class.Hashable e, Data.Hashable.Class.Hashable (Data.Vector.Vector e)) => Data.Hashable.Class.Hashable (Data.PrimitiveArray.Dense.Boxed sh e)
instance (Control.DeepSeq.NFData sh, Control.DeepSeq.NFData e) => Control.DeepSeq.NFData (Data.PrimitiveArray.Dense.Boxed sh e)
instance Control.DeepSeq.NFData sh => Control.DeepSeq.NFData (Data.PrimitiveArray.Class.MutArr m (Data.PrimitiveArray.Dense.Boxed sh e))
instance Data.PrimitiveArray.Index.Class.Index sh => Data.PrimitiveArray.Class.MPrimArrayOps Data.PrimitiveArray.Dense.Boxed sh elm
instance Data.PrimitiveArray.Index.Class.Index sh => Data.PrimitiveArray.Class.PrimArrayOps Data.PrimitiveArray.Dense.Boxed sh elm
instance Data.PrimitiveArray.Index.Class.Index sh => Data.PrimitiveArray.Class.PrimArrayMap Data.PrimitiveArray.Dense.Boxed sh e e'


-- | Operations to fill primitive arrays. Arrays are combined just like
--   indices using <a>Z</a> and '(:.)'. This allows filling an unlimited
--   number of tables. <tt>ExtShape</tt> provides the <tt>rangeStream</tt>
--   function with generates a stream of indices in (generally) the right
--   order.
module Data.PrimitiveArray.FillTables

-- | Run the forward phase of algorithms. Is *really* unsafe for now if
--   tables have different sizes, as in its broken.
--   
--   TODO Need to run min/max on the bounds for all tables, not just the
--   last table. Otherwise we don't really need the distinction between
--   save and unsafe. This will have to be in <tt>runFillTables</tt>.
unsafeRunFillTables :: (Index sh, IndexStream sh, WriteCell m (tail :. (MutArr m (arr sh elm), t)) sh, MPrimArrayOps arr sh elm, Monad m, PrimMonad m) => (tail :. (MutArr m (arr sh elm), t)) -> m ()

-- | <a>WriteCell</a> provides methods to fill all cells with a specific
--   index <tt>sh</tt> in a stack of non-terminal tables <tt>c</tt>.
class (Monad m) => WriteCell m c sh
unsafeWriteCell :: WriteCell m c sh => c -> sh -> m ()
writeCell :: WriteCell m c sh => c -> sh -> m ()
instance GHC.Base.Monad m => Data.PrimitiveArray.FillTables.WriteCell m Data.PrimitiveArray.Index.Class.Z sh
instance (Data.PrimitiveArray.FillTables.WriteCell m cs sh, GHC.Base.Monad m, Data.PrimitiveArray.Class.MPrimArrayOps arr sh a, Control.Monad.Primitive.PrimMonad m) => Data.PrimitiveArray.FillTables.WriteCell m (cs Data.PrimitiveArray.Index.Class.:. (Data.PrimitiveArray.Class.MutArr m (arr sh a), sh -> m a)) sh

module Data.PrimitiveArray