{-# LANGUAGE CPP, DeriveDataTypeable, FlexibleInstances, GADTs        #-}
{-# LANGUAGE GeneralizedNewtypeDeriving, KindSignatures               #-}
{-# LANGUAGE MultiParamTypeClasses, ScopedTypeVariables, TypeFamilies #-}
{-# LANGUAGE TypeOperators                                            #-}
{-# LANGUAGE UndecidableInstances                                     #-}

#ifndef MIN_VERSION_base
#define MIN_VERSION_base(x,y,z) 1
#endif

#ifndef MIN_VERSION_vector
#define MIN_VERSION_vector(x,y,z) 1
#endif

module Data.Vector.Hybrid.Internal
  ( MVector(..)
  , Vector(..)
  ) where

import           Control.Monad
import qualified Data.Foldable               as F
import           Data.Monoid
import           Data.Semigroup
import qualified Data.Vector.Generic         as G
import qualified Data.Vector.Generic.Mutable as GM


#if MIN_VERSION_vector(0,11,0)
import Data.Vector.Fusion.Bundle as Stream
#else
import Data.Vector.Fusion.Stream as Stream
#endif

import Data.Data
import Prelude   hiding (drop, init, length, map, null, read, replicate,
                  reverse, tail, take)
import Text.Read

data MVector :: (* -> * -> *) -> (* -> * -> *) -> * -> * -> * where
  MV :: !(u s a) -> !(v s b) -> MVector u v s (a, b)

#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 707
 deriving Typeable

#define Typeable1 Typeable

#else

-- custom Typeable
instance (Typeable2 u, Typeable2 v) => Typeable2 (MVector u v) where
  typeOf2 (_ :: MVector u v s ab) = mkTyConApp mvectorTyCon [typeOf2 (undefined :: u s a), typeOf2 (undefined :: v s b)]

mvectorTyCon :: TyCon
#if MIN_VERSION_base(4,4,0)
mvectorTyCon = mkTyCon3 "hybrid-vectors" "Data.Vector.Hybrid.Internal" "MVector"
#else
mvectorTyCon = mkTyCon "Data.Vector.Hybrid.Internal.MVector"
#endif

#endif

instance (GM.MVector u a, GM.MVector v b) => GM.MVector (MVector u v) (a, b) where
  basicLength :: MVector u v s (a, b) -> Int
basicLength (MV u s a
ks v s b
_) = u s a -> Int
forall (v :: * -> * -> *) a s. MVector v a => v s a -> Int
GM.basicLength u s a
ks
  {-# INLINE basicLength #-}
  basicUnsafeSlice :: Int -> Int -> MVector u v s (a, b) -> MVector u v s (a, b)
basicUnsafeSlice Int
s Int
e (MV u s a
ks v s b
vs) = u s a -> v s b -> MVector u v s (a, b)
forall (u :: * -> * -> *) s a (v :: * -> * -> *) b.
u s a -> v s b -> MVector u v s (a, b)
MV (Int -> Int -> u s a -> u s a
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
GM.basicUnsafeSlice Int
s Int
e u s a
ks) (Int -> Int -> v s b -> v s b
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> Int -> v s a -> v s a
GM.basicUnsafeSlice Int
s Int
e v s b
vs)
  {-# INLINE basicUnsafeSlice #-}
  basicOverlaps :: MVector u v s (a, b) -> MVector u v s (a, b) -> Bool
basicOverlaps (MV u s a
ks v s b
vs) (MV u s a
ks' v s b
vs') = u s a -> u s a -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
GM.basicOverlaps u s a
ks u s a
u s a
ks' Bool -> Bool -> Bool
|| v s b -> v s b -> Bool
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> Bool
GM.basicOverlaps v s b
vs v s b
v s b
vs'
  {-# INLINE basicOverlaps #-}
  basicUnsafeNew :: Int -> ST s (MVector u v s (a, b))
basicUnsafeNew Int
n = (u s a -> v s b -> MVector u v s (a, b))
-> ST s (u s a) -> ST s (v s b) -> ST s (MVector u v s (a, b))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 u s a -> v s b -> MVector u v s (a, b)
forall (u :: * -> * -> *) s a (v :: * -> * -> *) b.
u s a -> v s b -> MVector u v s (a, b)
MV (Int -> ST s (u s a)
forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a)
GM.basicUnsafeNew Int
n) (Int -> ST s (v s b)
forall (v :: * -> * -> *) a s. MVector v a => Int -> ST s (v s a)
GM.basicUnsafeNew Int
n)
  {-# INLINE basicUnsafeNew #-}
  basicUnsafeReplicate :: Int -> (a, b) -> ST s (MVector u v s (a, b))
basicUnsafeReplicate Int
n (a
k,b
v) = (u s a -> v s b -> MVector u v s (a, b))
-> ST s (u s a) -> ST s (v s b) -> ST s (MVector u v s (a, b))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 u s a -> v s b -> MVector u v s (a, b)
forall (u :: * -> * -> *) s a (v :: * -> * -> *) b.
u s a -> v s b -> MVector u v s (a, b)
MV (Int -> a -> ST s (u s a)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> a -> ST s (v s a)
GM.basicUnsafeReplicate Int
n a
k) (Int -> b -> ST s (v s b)
forall (v :: * -> * -> *) a s.
MVector v a =>
Int -> a -> ST s (v s a)
GM.basicUnsafeReplicate Int
n b
v)
  {-# INLINE basicUnsafeReplicate #-}
  basicUnsafeRead :: MVector u v s (a, b) -> Int -> ST s (a, b)
basicUnsafeRead (MV u s a
ks v s b
vs) Int
n = (a -> b -> (a, b)) -> ST s a -> ST s b -> ST s (a, b)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) (u s a -> Int -> ST s a
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s a
GM.basicUnsafeRead u s a
ks Int
n) (v s b -> Int -> ST s b
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s a
GM.basicUnsafeRead v s b
vs Int
n)
  {-# INLINE basicUnsafeRead #-}
  basicUnsafeWrite :: MVector u v s (a, b) -> Int -> (a, b) -> ST s ()
basicUnsafeWrite (MV u s a
ks v s b
vs) Int
n (a
k,b
v) = do
    u s a -> Int -> a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
GM.basicUnsafeWrite u s a
ks Int
n a
a
k
    v s b -> Int -> b -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> a -> ST s ()
GM.basicUnsafeWrite v s b
vs Int
n b
b
v
  {-# INLINE basicUnsafeWrite #-}
  basicClear :: MVector u v s (a, b) -> ST s ()
basicClear (MV u s a
ks v s b
vs) = do
    u s a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
GM.basicClear u s a
ks
    v s b -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
GM.basicClear v s b
vs
  {-# INLINE basicClear #-}
  basicSet :: MVector u v s (a, b) -> (a, b) -> ST s ()
basicSet (MV u s a
ks v s b
vs) (a
k,b
v) = do
    u s a -> a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> a -> ST s ()
GM.basicSet u s a
ks a
a
k
    v s b -> b -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> a -> ST s ()
GM.basicSet v s b
vs b
b
v
  {-# INLINE basicSet #-}
  basicUnsafeCopy :: MVector u v s (a, b) -> MVector u v s (a, b) -> ST s ()
basicUnsafeCopy (MV u s a
ks v s b
vs) (MV u s a
ks' v s b
vs') = do
    u s a -> u s a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
GM.basicUnsafeCopy u s a
ks u s a
u s a
ks'
    v s b -> v s b -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
GM.basicUnsafeCopy v s b
vs v s b
v s b
vs'
  {-# INLINE basicUnsafeCopy #-}
  basicUnsafeMove :: MVector u v s (a, b) -> MVector u v s (a, b) -> ST s ()
basicUnsafeMove (MV u s a
ks v s b
vs) (MV u s a
ks' v s b
vs') = do
    u s a -> u s a -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
GM.basicUnsafeMove u s a
ks u s a
u s a
ks'
    v s b -> v s b -> ST s ()
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> v s a -> ST s ()
GM.basicUnsafeMove v s b
vs v s b
v s b
vs'
  {-# INLINE basicUnsafeMove #-}
  basicUnsafeGrow :: MVector u v s (a, b) -> Int -> ST s (MVector u v s (a, b))
basicUnsafeGrow (MV u s a
ks v s b
vs) Int
n = (u s a -> v s b -> MVector u v s (a, b))
-> ST s (u s a) -> ST s (v s b) -> ST s (MVector u v s (a, b))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 u s a -> v s b -> MVector u v s (a, b)
forall (u :: * -> * -> *) s a (v :: * -> * -> *) b.
u s a -> v s b -> MVector u v s (a, b)
MV (u s a -> Int -> ST s (u s a)
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s (v s a)
GM.basicUnsafeGrow u s a
ks Int
n) (v s b -> Int -> ST s (v s b)
forall (v :: * -> * -> *) a s.
MVector v a =>
v s a -> Int -> ST s (v s a)
GM.basicUnsafeGrow v s b
vs Int
n)
  {-# INLINE basicUnsafeGrow #-}
#if MIN_VERSION_vector(0,11,0)
  basicInitialize :: MVector u v s (a, b) -> ST s ()
basicInitialize (MV u s a
ks v s b
vs) = u s a -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
GM.basicInitialize u s a
ks ST s () -> ST s () -> ST s ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> v s b -> ST s ()
forall (v :: * -> * -> *) a s. MVector v a => v s a -> ST s ()
GM.basicInitialize v s b
vs
  {-# INLINE basicInitialize #-}
#endif

-- hybrid vectors
data Vector :: (* -> *) -> (* -> *) -> * -> * where
  V :: !(u a) -> !(v b) -> Vector u v (a, b)

#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 707
 deriving Typeable
#else

-- custom Typeable
instance (Typeable1 u, Typeable1 v) => Typeable1 (Vector u v) where
  typeOf1 (_ :: Vector u v ab) = mkTyConApp vectorTyCon [typeOf1 (undefined :: u a), typeOf1 (undefined :: v b)]

vectorTyCon :: TyCon
#if MIN_VERSION_base(4,4,0)
vectorTyCon = mkTyCon3 "hybrid-vectors" "Data.Vector.Hybrid.Internal" "Vector"
#else
vectorTyCon = mkTyCon "Data.Vector.Hybrid.Internal.Vector"
#endif

#endif

type instance G.Mutable (Vector u v) = MVector (G.Mutable u) (G.Mutable v)

instance (G.Vector u a, G.Vector v b) => G.Vector (Vector u v) (a, b) where
  basicUnsafeFreeze :: Mutable (Vector u v) s (a, b) -> ST s (Vector u v (a, b))
basicUnsafeFreeze (MV ks vs) = (u a -> v b -> Vector u v (a, b))
-> ST s (u a) -> ST s (v b) -> ST s (Vector u v (a, b))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 u a -> v b -> Vector u v (a, b)
forall (u :: * -> *) a (v :: * -> *) b.
u a -> v b -> Vector u v (a, b)
V (Mutable u s a -> ST s (u a)
forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
G.basicUnsafeFreeze Mutable u s a
Mutable u s a
ks) (Mutable v s b -> ST s (v b)
forall (v :: * -> *) a s. Vector v a => Mutable v s a -> ST s (v a)
G.basicUnsafeFreeze Mutable v s b
Mutable v s b
vs)
  {-# INLINE basicUnsafeFreeze #-}
  basicUnsafeThaw :: Vector u v (a, b) -> ST s (Mutable (Vector u v) s (a, b))
basicUnsafeThaw (V u a
ks v b
vs) = (Mutable u s a
 -> Mutable v s b -> MVector (Mutable u) (Mutable v) s (a, b))
-> ST s (Mutable u s a)
-> ST s (Mutable v s b)
-> ST s (MVector (Mutable u) (Mutable v) s (a, b))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 Mutable u s a
-> Mutable v s b -> MVector (Mutable u) (Mutable v) s (a, b)
forall (u :: * -> * -> *) s a (v :: * -> * -> *) b.
u s a -> v s b -> MVector u v s (a, b)
MV (u a -> ST s (Mutable u s a)
forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
G.basicUnsafeThaw u a
ks) (v b -> ST s (Mutable v s b)
forall (v :: * -> *) a s. Vector v a => v a -> ST s (Mutable v s a)
G.basicUnsafeThaw v b
vs)
  {-# INLINE basicUnsafeThaw #-}
  basicLength :: Vector u v (a, b) -> Int
basicLength (V u a
ks v b
_) = u a -> Int
forall (v :: * -> *) a. Vector v a => v a -> Int
G.basicLength u a
ks
  {-# INLINE basicLength #-}
  basicUnsafeSlice :: Int -> Int -> Vector u v (a, b) -> Vector u v (a, b)
basicUnsafeSlice Int
i Int
j (V u a
ks v b
vs) = u a -> v b -> Vector u v (a, b)
forall (u :: * -> *) a (v :: * -> *) b.
u a -> v b -> Vector u v (a, b)
V (Int -> Int -> u a -> u a
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
i Int
j u a
ks) (Int -> Int -> v b -> v b
forall (v :: * -> *) a. Vector v a => Int -> Int -> v a -> v a
G.basicUnsafeSlice Int
i Int
j v b
vs)
  {-# INLINE basicUnsafeSlice #-}
  basicUnsafeIndexM :: Vector u v (a, b) -> Int -> Box (a, b)
basicUnsafeIndexM (V u a
ks v b
vs) Int
n = (a -> b -> (a, b)) -> Box a -> Box b -> Box (a, b)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,) (u a -> Int -> Box a
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
G.basicUnsafeIndexM u a
ks Int
n) (v b -> Int -> Box b
forall (v :: * -> *) a. Vector v a => v a -> Int -> Box a
G.basicUnsafeIndexM v b
vs Int
n)
  {-# INLINE basicUnsafeIndexM #-}
  basicUnsafeCopy :: Mutable (Vector u v) s (a, b) -> Vector u v (a, b) -> ST s ()
basicUnsafeCopy (MV ks vs) (V u a
ks' v b
vs') = do
    Mutable u s a -> u a -> ST s ()
forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
G.basicUnsafeCopy Mutable u s a
Mutable u s a
ks u a
ks'
    Mutable v s b -> v b -> ST s ()
forall (v :: * -> *) a s.
Vector v a =>
Mutable v s a -> v a -> ST s ()
G.basicUnsafeCopy Mutable v s b
Mutable v s b
vs v b
vs'
  {-# INLINE basicUnsafeCopy #-}
  elemseq :: Vector u v (a, b) -> (a, b) -> b -> b
elemseq (V u a
ks v b
vs) (a
k,b
v) b
b = u a -> a -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq u a
ks a
a
k (v b -> b -> b -> b
forall (v :: * -> *) a b. Vector v a => v a -> a -> b -> b
G.elemseq v b
vs b
b
v b
b)
  {-# INLINE elemseq #-}

instance (G.Vector u a, G.Vector v b, c ~ (a, b)) => Semigroup (Vector u v c) where
  <> :: Vector u v c -> Vector u v c -> Vector u v c
(<>) = Vector u v c -> Vector u v c -> Vector u v c
forall (v :: * -> *) a. Vector v a => v a -> v a -> v a
(G.++)
  sconcat :: NonEmpty (Vector u v c) -> Vector u v c
sconcat = [Vector u v c] -> Vector u v c
forall a. Monoid a => [a] -> a
mconcat ([Vector u v c] -> Vector u v c)
-> (NonEmpty (Vector u v c) -> [Vector u v c])
-> NonEmpty (Vector u v c)
-> Vector u v c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty (Vector u v c) -> [Vector u v c]
forall (t :: * -> *) a. Foldable t => t a -> [a]
F.toList

instance (G.Vector u a, G.Vector v b, c ~ (a, b)) => Monoid (Vector u v c) where
#if !(MIN_VERSION_base(4,11,0))
  mappend = (G.++)
  {-# INLINE mappend #-}
#endif
  mempty :: Vector u v c
mempty = Vector u v c
forall (v :: * -> *) a. Vector v a => v a
G.empty
  {-# INLINE mempty #-}
  mconcat :: [Vector u v c] -> Vector u v c
mconcat = [Vector u v c] -> Vector u v c
forall (v :: * -> *) a. Vector v a => [v a] -> v a
G.concat
  {-# INLINE mconcat #-}

instance (G.Vector u a, G.Vector v b, Show a, Show b, c ~ (a, b)) => Show (Vector u v c) where
  showsPrec :: Int -> Vector u v c -> ShowS
showsPrec = Int -> Vector u v c -> ShowS
forall (v :: * -> *) a. (Vector v a, Show a) => Int -> v a -> ShowS
G.showsPrec

instance (G.Vector u a, G.Vector v b, Read a, Read b, c ~ (a, b)) => Read (Vector u v c) where
  readPrec :: ReadPrec (Vector u v c)
readPrec = ReadPrec (Vector u v c)
forall (v :: * -> *) a. (Vector v a, Read a) => ReadPrec (v a)
G.readPrec
  readListPrec :: ReadPrec [Vector u v c]
readListPrec = ReadPrec [Vector u v c]
forall a. Read a => ReadPrec [a]
readListPrecDefault

instance (Data a, Data b, Typeable1 u, Typeable1 v, G.Vector u a, G.Vector v b, c ~ (a, b)) => Data (Vector u v c) where
  gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector u v c -> c (Vector u v c)
gfoldl       = (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Vector u v c -> c (Vector u v c)
forall (v :: * -> *) a (c :: * -> *).
(Vector v a, Data a) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> v a -> c (v a)
G.gfoldl
  toConstr :: Vector u v c -> Constr
toConstr Vector u v c
_   = String -> Constr
forall a. HasCallStack => String -> a
error String
"toConstr" -- TODO: virtual constructor
  gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Vector u v c)
gunfold forall b r. Data b => c (b -> r) -> c r
_ forall r. r -> c r
_  = String -> Constr -> c (Vector u v c)
forall a. HasCallStack => String -> a
error String
"gunfold"  -- TODO: virtual constructor
  dataTypeOf :: Vector u v c -> DataType
dataTypeOf Vector u v c
_ = String -> DataType
mkNoRepType String
"Data.Vector.Hybrid.Vector"
  dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Vector u v c))
dataCast1    = (forall d. Data d => c (t d)) -> Maybe (c (Vector u v c))
forall (v :: * -> *) a (t :: * -> *) (c :: * -> *).
(Vector v a, Data a, Typeable v, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (v a))
G.dataCast


instance (G.Vector u a, G.Vector v b, Eq a, Eq b, c ~ (a, b)) => Eq (Vector u v c) where
  Vector u v c
xs == :: Vector u v c -> Vector u v c -> Bool
== Vector u v c
ys = Bundle (Vector u v) c -> Bundle (Vector u v) c -> Bool
forall a (v :: * -> *). Eq a => Bundle v a -> Bundle v a -> Bool
Stream.eq (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
xs) (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
ys)
  {-# INLINE (==) #-}

  Vector u v c
xs /= :: Vector u v c -> Vector u v c -> Bool
/= Vector u v c
ys = Bool -> Bool
not (Bundle (Vector u v) c -> Bundle (Vector u v) c -> Bool
forall a (v :: * -> *). Eq a => Bundle v a -> Bundle v a -> Bool
Stream.eq (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
xs) (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
ys))
  {-# INLINE (/=) #-}


-- See http://trac.haskell.org/vector/ticket/12
instance (G.Vector u a, G.Vector v b, Ord a, Ord b, c ~ (a, b)) => Ord (Vector u v c) where
  {-# INLINE compare #-}
  compare :: Vector u v c -> Vector u v c -> Ordering
compare Vector u v c
xs Vector u v c
ys = Bundle (Vector u v) c -> Bundle (Vector u v) c -> Ordering
forall a (v :: * -> *).
Ord a =>
Bundle v a -> Bundle v a -> Ordering
Stream.cmp (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
xs) (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
ys)

  {-# INLINE (<) #-}
  Vector u v c
xs < :: Vector u v c -> Vector u v c -> Bool
< Vector u v c
ys = Bundle (Vector u v) c -> Bundle (Vector u v) c -> Ordering
forall a (v :: * -> *).
Ord a =>
Bundle v a -> Bundle v a -> Ordering
Stream.cmp (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
xs) (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
ys) Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
LT

  {-# INLINE (<=) #-}
  Vector u v c
xs <= :: Vector u v c -> Vector u v c -> Bool
<= Vector u v c
ys = Bundle (Vector u v) c -> Bundle (Vector u v) c -> Ordering
forall a (v :: * -> *).
Ord a =>
Bundle v a -> Bundle v a -> Ordering
Stream.cmp (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
xs) (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
ys) Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
GT

  {-# INLINE (>) #-}
  Vector u v c
xs > :: Vector u v c -> Vector u v c -> Bool
> Vector u v c
ys = Bundle (Vector u v) c -> Bundle (Vector u v) c -> Ordering
forall a (v :: * -> *).
Ord a =>
Bundle v a -> Bundle v a -> Ordering
Stream.cmp (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
xs) (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
ys) Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
GT

  {-# INLINE (>=) #-}
  Vector u v c
xs >= :: Vector u v c -> Vector u v c -> Bool
>= Vector u v c
ys = Bundle (Vector u v) c -> Bundle (Vector u v) c -> Ordering
forall a (v :: * -> *).
Ord a =>
Bundle v a -> Bundle v a -> Ordering
Stream.cmp (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
xs) (Vector u v c -> Bundle (Vector u v) c
forall (v :: * -> *) a. Vector v a => v a -> Bundle v a
G.stream Vector u v c
ys) Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
/= Ordering
LT