{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeFamilies #-}

{-|

Class of statically-sized text-like types.

-}

module Data.StaticText.Class
       ( IsStaticText(..)
       )

where

import           Prelude
import qualified Prelude as P

#ifdef WITH_BS
import qualified Data.ByteString as B
import           GHC.Word
import qualified Data.ByteString.Short as BS
#endif

#ifdef WITH_TEXT
import qualified Data.Text as T
#endif

#ifdef WITH_VECTOR
import qualified Data.Vector as V
#endif

#if MIN_VERSION_base(4,9,0)
import           GHC.TypeLits hiding (Text)
#else
import           GHC.TypeLits
#endif


-- | Class of types which can be assigned a type-level length.
class IsStaticText a where
  -- | Data family which wraps values of the underlying type giving
  -- them a type-level length. @Static t 6@ means a value of type @t@ of
  -- length 6.
  data Static a (i :: Nat)

  -- | Basic element type. For @IsStaticText [a]@, this is @a@.
  type Elem a

  -- | Simply wrap a value in a Static as is, assuming any length.
  --
  -- When implementing new "IsStaticText" instances, make this simply
  -- apply the constructor of "Static".
  --
  -- This should only be used to implement "IsStaticText".
  --
  -- For example, an expression like
  --
  -- >>> unsafeCreate "somestring" :: Static String 50
  -- "somestring"
  --
  -- will typecheck, although the stored length information will not
  -- match actual string size. This may result in wrong behaviour of
  -- all functions defined for "IsStaticText".
  unsafeCreate :: a -> Static a i

  -- | Forget type-level length, obtaining the underlying value.
  unwrap :: Static a i -> a

  length :: a -> Int
  append :: a -> a -> a
  replicate :: Int -> Elem a -> a
  map :: (Elem a -> Elem a) -> a -> a
  take :: Int -> a -> a
  drop :: Int -> a -> a


instance (Show a, IsStaticText a) => Show (Static a i) where
  show :: Static a i -> String
show = a -> String
forall a. Show a => a -> String
show (a -> String) -> (Static a i -> a) -> Static a i -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Static a i -> a
forall a (i :: Nat). IsStaticText a => Static a i -> a
unwrap
  showsPrec :: Int -> Static a i -> ShowS
showsPrec Int
p = Int -> a -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
p (a -> ShowS) -> (Static a i -> a) -> Static a i -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Static a i -> a
forall a (i :: Nat). IsStaticText a => Static a i -> a
unwrap


instance IsStaticText [a] where
  type Elem [a] = a

  data Static [a] i = List [a]
    deriving (Static [a] i -> Static [a] i -> Bool
(Static [a] i -> Static [a] i -> Bool)
-> (Static [a] i -> Static [a] i -> Bool) -> Eq (Static [a] i)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a (i :: Nat). Eq a => Static [a] i -> Static [a] i -> Bool
/= :: Static [a] i -> Static [a] i -> Bool
$c/= :: forall a (i :: Nat). Eq a => Static [a] i -> Static [a] i -> Bool
== :: Static [a] i -> Static [a] i -> Bool
$c== :: forall a (i :: Nat). Eq a => Static [a] i -> Static [a] i -> Bool
Eq, Eq (Static [a] i)
Eq (Static [a] i)
-> (Static [a] i -> Static [a] i -> Ordering)
-> (Static [a] i -> Static [a] i -> Bool)
-> (Static [a] i -> Static [a] i -> Bool)
-> (Static [a] i -> Static [a] i -> Bool)
-> (Static [a] i -> Static [a] i -> Bool)
-> (Static [a] i -> Static [a] i -> Static [a] i)
-> (Static [a] i -> Static [a] i -> Static [a] i)
-> Ord (Static [a] i)
Static [a] i -> Static [a] i -> Bool
Static [a] i -> Static [a] i -> Ordering
Static [a] i -> Static [a] i -> Static [a] i
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a (i :: Nat). Ord a => Eq (Static [a] i)
forall a (i :: Nat). Ord a => Static [a] i -> Static [a] i -> Bool
forall a (i :: Nat).
Ord a =>
Static [a] i -> Static [a] i -> Ordering
forall a (i :: Nat).
Ord a =>
Static [a] i -> Static [a] i -> Static [a] i
min :: Static [a] i -> Static [a] i -> Static [a] i
$cmin :: forall a (i :: Nat).
Ord a =>
Static [a] i -> Static [a] i -> Static [a] i
max :: Static [a] i -> Static [a] i -> Static [a] i
$cmax :: forall a (i :: Nat).
Ord a =>
Static [a] i -> Static [a] i -> Static [a] i
>= :: Static [a] i -> Static [a] i -> Bool
$c>= :: forall a (i :: Nat). Ord a => Static [a] i -> Static [a] i -> Bool
> :: Static [a] i -> Static [a] i -> Bool
$c> :: forall a (i :: Nat). Ord a => Static [a] i -> Static [a] i -> Bool
<= :: Static [a] i -> Static [a] i -> Bool
$c<= :: forall a (i :: Nat). Ord a => Static [a] i -> Static [a] i -> Bool
< :: Static [a] i -> Static [a] i -> Bool
$c< :: forall a (i :: Nat). Ord a => Static [a] i -> Static [a] i -> Bool
compare :: Static [a] i -> Static [a] i -> Ordering
$ccompare :: forall a (i :: Nat).
Ord a =>
Static [a] i -> Static [a] i -> Ordering
$cp1Ord :: forall a (i :: Nat). Ord a => Eq (Static [a] i)
Ord)

  unsafeCreate :: [a] -> Static [a] i
unsafeCreate = [a] -> Static [a] i
forall a (i :: Nat). [a] -> Static [a] i
List
  unwrap :: Static [a] i -> [a]
unwrap (List l) = [a]
l

  length :: [a] -> Int
length = [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length
  append :: [a] -> [a] -> [a]
append = [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
(P.++)
  replicate :: Int -> Elem [a] -> [a]
replicate = Int -> Elem [a] -> [a]
forall a. Int -> a -> [a]
P.replicate
  map :: (Elem [a] -> Elem [a]) -> [a] -> [a]
map = (Elem [a] -> Elem [a]) -> [a] -> [a]
forall a b. (a -> b) -> [a] -> [b]
P.map
  take :: Int -> [a] -> [a]
take = Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
P.take
  drop :: Int -> [a] -> [a]
drop = Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
P.drop


#ifdef WITH_TEXT
instance IsStaticText T.Text where
  type Elem T.Text = Char

  data Static T.Text i = Text T.Text
    deriving (Static Text i -> Static Text i -> Bool
(Static Text i -> Static Text i -> Bool)
-> (Static Text i -> Static Text i -> Bool) -> Eq (Static Text i)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (i :: Nat). Static Text i -> Static Text i -> Bool
/= :: Static Text i -> Static Text i -> Bool
$c/= :: forall (i :: Nat). Static Text i -> Static Text i -> Bool
== :: Static Text i -> Static Text i -> Bool
$c== :: forall (i :: Nat). Static Text i -> Static Text i -> Bool
Eq, Eq (Static Text i)
Eq (Static Text i)
-> (Static Text i -> Static Text i -> Ordering)
-> (Static Text i -> Static Text i -> Bool)
-> (Static Text i -> Static Text i -> Bool)
-> (Static Text i -> Static Text i -> Bool)
-> (Static Text i -> Static Text i -> Bool)
-> (Static Text i -> Static Text i -> Static Text i)
-> (Static Text i -> Static Text i -> Static Text i)
-> Ord (Static Text i)
Static Text i -> Static Text i -> Bool
Static Text i -> Static Text i -> Ordering
Static Text i -> Static Text i -> Static Text i
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (i :: Nat). Eq (Static Text i)
forall (i :: Nat). Static Text i -> Static Text i -> Bool
forall (i :: Nat). Static Text i -> Static Text i -> Ordering
forall (i :: Nat). Static Text i -> Static Text i -> Static Text i
min :: Static Text i -> Static Text i -> Static Text i
$cmin :: forall (i :: Nat). Static Text i -> Static Text i -> Static Text i
max :: Static Text i -> Static Text i -> Static Text i
$cmax :: forall (i :: Nat). Static Text i -> Static Text i -> Static Text i
>= :: Static Text i -> Static Text i -> Bool
$c>= :: forall (i :: Nat). Static Text i -> Static Text i -> Bool
> :: Static Text i -> Static Text i -> Bool
$c> :: forall (i :: Nat). Static Text i -> Static Text i -> Bool
<= :: Static Text i -> Static Text i -> Bool
$c<= :: forall (i :: Nat). Static Text i -> Static Text i -> Bool
< :: Static Text i -> Static Text i -> Bool
$c< :: forall (i :: Nat). Static Text i -> Static Text i -> Bool
compare :: Static Text i -> Static Text i -> Ordering
$ccompare :: forall (i :: Nat). Static Text i -> Static Text i -> Ordering
$cp1Ord :: forall (i :: Nat). Eq (Static Text i)
Ord)

  unsafeCreate :: Text -> Static Text i
unsafeCreate = Text -> Static Text i
forall (i :: Nat). Text -> Static Text i
Text
  unwrap :: Static Text i -> Text
unwrap (Text t) = Text
t

  length :: Text -> Int
length = Text -> Int
T.length
  append :: Text -> Text -> Text
append = Text -> Text -> Text
T.append
  replicate :: Int -> Elem Text -> Text
replicate = \Int
n Elem Text
c -> Int -> Text -> Text
T.replicate Int
n (Char -> Text
T.singleton Char
Elem Text
c)
  map :: (Elem Text -> Elem Text) -> Text -> Text
map = (Char -> Char) -> Text -> Text
(Elem Text -> Elem Text) -> Text -> Text
T.map
  take :: Int -> Text -> Text
take = Int -> Text -> Text
T.take
  drop :: Int -> Text -> Text
drop = Int -> Text -> Text
T.drop
#endif


#ifdef WITH_BS
instance IsStaticText B.ByteString where
  type Elem B.ByteString = Word8

  data Static B.ByteString i = ByteString B.ByteString
    deriving (Static ByteString i -> Static ByteString i -> Bool
(Static ByteString i -> Static ByteString i -> Bool)
-> (Static ByteString i -> Static ByteString i -> Bool)
-> Eq (Static ByteString i)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Bool
/= :: Static ByteString i -> Static ByteString i -> Bool
$c/= :: forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Bool
== :: Static ByteString i -> Static ByteString i -> Bool
$c== :: forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Bool
Eq, Eq (Static ByteString i)
Eq (Static ByteString i)
-> (Static ByteString i -> Static ByteString i -> Ordering)
-> (Static ByteString i -> Static ByteString i -> Bool)
-> (Static ByteString i -> Static ByteString i -> Bool)
-> (Static ByteString i -> Static ByteString i -> Bool)
-> (Static ByteString i -> Static ByteString i -> Bool)
-> (Static ByteString i
    -> Static ByteString i -> Static ByteString i)
-> (Static ByteString i
    -> Static ByteString i -> Static ByteString i)
-> Ord (Static ByteString i)
Static ByteString i -> Static ByteString i -> Bool
Static ByteString i -> Static ByteString i -> Ordering
Static ByteString i -> Static ByteString i -> Static ByteString i
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (i :: Nat). Eq (Static ByteString i)
forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Bool
forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Ordering
forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Static ByteString i
min :: Static ByteString i -> Static ByteString i -> Static ByteString i
$cmin :: forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Static ByteString i
max :: Static ByteString i -> Static ByteString i -> Static ByteString i
$cmax :: forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Static ByteString i
>= :: Static ByteString i -> Static ByteString i -> Bool
$c>= :: forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Bool
> :: Static ByteString i -> Static ByteString i -> Bool
$c> :: forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Bool
<= :: Static ByteString i -> Static ByteString i -> Bool
$c<= :: forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Bool
< :: Static ByteString i -> Static ByteString i -> Bool
$c< :: forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Bool
compare :: Static ByteString i -> Static ByteString i -> Ordering
$ccompare :: forall (i :: Nat).
Static ByteString i -> Static ByteString i -> Ordering
$cp1Ord :: forall (i :: Nat). Eq (Static ByteString i)
Ord)

  unsafeCreate :: ByteString -> Static ByteString i
unsafeCreate = ByteString -> Static ByteString i
forall (i :: Nat). ByteString -> Static ByteString i
ByteString
  unwrap :: Static ByteString i -> ByteString
unwrap (ByteString t) = ByteString
t

  length :: ByteString -> Int
length = ByteString -> Int
B.length
  append :: ByteString -> ByteString -> ByteString
append = ByteString -> ByteString -> ByteString
B.append
  replicate :: Int -> Elem ByteString -> ByteString
replicate = Int -> Word8 -> ByteString
Int -> Elem ByteString -> ByteString
B.replicate
  map :: (Elem ByteString -> Elem ByteString) -> ByteString -> ByteString
map = (Word8 -> Word8) -> ByteString -> ByteString
(Elem ByteString -> Elem ByteString) -> ByteString -> ByteString
B.map
  take :: Int -> ByteString -> ByteString
take = Int -> ByteString -> ByteString
B.take
  drop :: Int -> ByteString -> ByteString
drop = Int -> ByteString -> ByteString
B.drop

-- | IsStaticText instance for 'BS.ShortByteString' uses intermediate
-- 'B.ByteString's (pinned) for all modification operations.
instance IsStaticText BS.ShortByteString where
  type Elem BS.ShortByteString = Word8

  data Static BS.ShortByteString i = ByteStringS BS.ShortByteString
    deriving (Static ShortByteString i -> Static ShortByteString i -> Bool
(Static ShortByteString i -> Static ShortByteString i -> Bool)
-> (Static ShortByteString i -> Static ShortByteString i -> Bool)
-> Eq (Static ShortByteString i)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (i :: Nat).
Static ShortByteString i -> Static ShortByteString i -> Bool
/= :: Static ShortByteString i -> Static ShortByteString i -> Bool
$c/= :: forall (i :: Nat).
Static ShortByteString i -> Static ShortByteString i -> Bool
== :: Static ShortByteString i -> Static ShortByteString i -> Bool
$c== :: forall (i :: Nat).
Static ShortByteString i -> Static ShortByteString i -> Bool
Eq, Eq (Static ShortByteString i)
Eq (Static ShortByteString i)
-> (Static ShortByteString i
    -> Static ShortByteString i -> Ordering)
-> (Static ShortByteString i -> Static ShortByteString i -> Bool)
-> (Static ShortByteString i -> Static ShortByteString i -> Bool)
-> (Static ShortByteString i -> Static ShortByteString i -> Bool)
-> (Static ShortByteString i -> Static ShortByteString i -> Bool)
-> (Static ShortByteString i
    -> Static ShortByteString i -> Static ShortByteString i)
-> (Static ShortByteString i
    -> Static ShortByteString i -> Static ShortByteString i)
-> Ord (Static ShortByteString i)
Static ShortByteString i -> Static ShortByteString i -> Bool
Static ShortByteString i -> Static ShortByteString i -> Ordering
Static ShortByteString i
-> Static ShortByteString i -> Static ShortByteString i
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall (i :: Nat). Eq (Static ShortByteString i)
forall (i :: Nat).
Static ShortByteString i -> Static ShortByteString i -> Bool
forall (i :: Nat).
Static ShortByteString i -> Static ShortByteString i -> Ordering
forall (i :: Nat).
Static ShortByteString i
-> Static ShortByteString i -> Static ShortByteString i
min :: Static ShortByteString i
-> Static ShortByteString i -> Static ShortByteString i
$cmin :: forall (i :: Nat).
Static ShortByteString i
-> Static ShortByteString i -> Static ShortByteString i
max :: Static ShortByteString i
-> Static ShortByteString i -> Static ShortByteString i
$cmax :: forall (i :: Nat).
Static ShortByteString i
-> Static ShortByteString i -> Static ShortByteString i
>= :: Static ShortByteString i -> Static ShortByteString i -> Bool
$c>= :: forall (i :: Nat).
Static ShortByteString i -> Static ShortByteString i -> Bool
> :: Static ShortByteString i -> Static ShortByteString i -> Bool
$c> :: forall (i :: Nat).
Static ShortByteString i -> Static ShortByteString i -> Bool
<= :: Static ShortByteString i -> Static ShortByteString i -> Bool
$c<= :: forall (i :: Nat).
Static ShortByteString i -> Static ShortByteString i -> Bool
< :: Static ShortByteString i -> Static ShortByteString i -> Bool
$c< :: forall (i :: Nat).
Static ShortByteString i -> Static ShortByteString i -> Bool
compare :: Static ShortByteString i -> Static ShortByteString i -> Ordering
$ccompare :: forall (i :: Nat).
Static ShortByteString i -> Static ShortByteString i -> Ordering
$cp1Ord :: forall (i :: Nat). Eq (Static ShortByteString i)
Ord)

  unsafeCreate :: ShortByteString -> Static ShortByteString i
unsafeCreate = ShortByteString -> Static ShortByteString i
forall (i :: Nat). ShortByteString -> Static ShortByteString i
ByteStringS
  unwrap :: Static ShortByteString i -> ShortByteString
unwrap (ByteStringS t) = ShortByteString
t

  length :: ShortByteString -> Int
length = ShortByteString -> Int
BS.length
  append :: ShortByteString -> ShortByteString -> ShortByteString
append ShortByteString
a ShortByteString
b = ByteString -> ShortByteString
BS.toShort (ByteString -> ShortByteString) -> ByteString -> ShortByteString
forall a b. (a -> b) -> a -> b
$ ByteString -> ByteString -> ByteString
B.append (ShortByteString -> ByteString
BS.fromShort ShortByteString
a) (ShortByteString -> ByteString
BS.fromShort ShortByteString
b)
  replicate :: Int -> Elem ShortByteString -> ShortByteString
replicate Int
n = ByteString -> ShortByteString
BS.toShort (ByteString -> ShortByteString)
-> (Word8 -> ByteString) -> Word8 -> ShortByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Word8 -> ByteString
B.replicate Int
n
  map :: (Elem ShortByteString -> Elem ShortByteString)
-> ShortByteString -> ShortByteString
map Elem ShortByteString -> Elem ShortByteString
f = ByteString -> ShortByteString
BS.toShort (ByteString -> ShortByteString)
-> (ShortByteString -> ByteString)
-> ShortByteString
-> ShortByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Word8) -> ByteString -> ByteString
B.map Word8 -> Word8
Elem ShortByteString -> Elem ShortByteString
f (ByteString -> ByteString)
-> (ShortByteString -> ByteString) -> ShortByteString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> ByteString
BS.fromShort
  take :: Int -> ShortByteString -> ShortByteString
take Int
n = ByteString -> ShortByteString
BS.toShort (ByteString -> ShortByteString)
-> (ShortByteString -> ByteString)
-> ShortByteString
-> ShortByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ByteString -> ByteString
B.take Int
n (ByteString -> ByteString)
-> (ShortByteString -> ByteString) -> ShortByteString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> ByteString
BS.fromShort
  drop :: Int -> ShortByteString -> ShortByteString
drop Int
n = ByteString -> ShortByteString
BS.toShort (ByteString -> ShortByteString)
-> (ShortByteString -> ByteString)
-> ShortByteString
-> ShortByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ByteString -> ByteString
B.drop Int
n (ByteString -> ByteString)
-> (ShortByteString -> ByteString) -> ShortByteString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShortByteString -> ByteString
BS.fromShort
#endif


#ifdef WITH_VECTOR
instance IsStaticText (V.Vector a) where
  type Elem (V.Vector a) = a

  data Static (V.Vector a) i = Vector (V.Vector a)
    deriving (Static (Vector a) i -> Static (Vector a) i -> Bool
(Static (Vector a) i -> Static (Vector a) i -> Bool)
-> (Static (Vector a) i -> Static (Vector a) i -> Bool)
-> Eq (Static (Vector a) i)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a (i :: Nat).
Eq a =>
Static (Vector a) i -> Static (Vector a) i -> Bool
/= :: Static (Vector a) i -> Static (Vector a) i -> Bool
$c/= :: forall a (i :: Nat).
Eq a =>
Static (Vector a) i -> Static (Vector a) i -> Bool
== :: Static (Vector a) i -> Static (Vector a) i -> Bool
$c== :: forall a (i :: Nat).
Eq a =>
Static (Vector a) i -> Static (Vector a) i -> Bool
Eq, Eq (Static (Vector a) i)
Eq (Static (Vector a) i)
-> (Static (Vector a) i -> Static (Vector a) i -> Ordering)
-> (Static (Vector a) i -> Static (Vector a) i -> Bool)
-> (Static (Vector a) i -> Static (Vector a) i -> Bool)
-> (Static (Vector a) i -> Static (Vector a) i -> Bool)
-> (Static (Vector a) i -> Static (Vector a) i -> Bool)
-> (Static (Vector a) i
    -> Static (Vector a) i -> Static (Vector a) i)
-> (Static (Vector a) i
    -> Static (Vector a) i -> Static (Vector a) i)
-> Ord (Static (Vector a) i)
Static (Vector a) i -> Static (Vector a) i -> Bool
Static (Vector a) i -> Static (Vector a) i -> Ordering
Static (Vector a) i -> Static (Vector a) i -> Static (Vector a) i
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a (i :: Nat). Ord a => Eq (Static (Vector a) i)
forall a (i :: Nat).
Ord a =>
Static (Vector a) i -> Static (Vector a) i -> Bool
forall a (i :: Nat).
Ord a =>
Static (Vector a) i -> Static (Vector a) i -> Ordering
forall a (i :: Nat).
Ord a =>
Static (Vector a) i -> Static (Vector a) i -> Static (Vector a) i
min :: Static (Vector a) i -> Static (Vector a) i -> Static (Vector a) i
$cmin :: forall a (i :: Nat).
Ord a =>
Static (Vector a) i -> Static (Vector a) i -> Static (Vector a) i
max :: Static (Vector a) i -> Static (Vector a) i -> Static (Vector a) i
$cmax :: forall a (i :: Nat).
Ord a =>
Static (Vector a) i -> Static (Vector a) i -> Static (Vector a) i
>= :: Static (Vector a) i -> Static (Vector a) i -> Bool
$c>= :: forall a (i :: Nat).
Ord a =>
Static (Vector a) i -> Static (Vector a) i -> Bool
> :: Static (Vector a) i -> Static (Vector a) i -> Bool
$c> :: forall a (i :: Nat).
Ord a =>
Static (Vector a) i -> Static (Vector a) i -> Bool
<= :: Static (Vector a) i -> Static (Vector a) i -> Bool
$c<= :: forall a (i :: Nat).
Ord a =>
Static (Vector a) i -> Static (Vector a) i -> Bool
< :: Static (Vector a) i -> Static (Vector a) i -> Bool
$c< :: forall a (i :: Nat).
Ord a =>
Static (Vector a) i -> Static (Vector a) i -> Bool
compare :: Static (Vector a) i -> Static (Vector a) i -> Ordering
$ccompare :: forall a (i :: Nat).
Ord a =>
Static (Vector a) i -> Static (Vector a) i -> Ordering
$cp1Ord :: forall a (i :: Nat). Ord a => Eq (Static (Vector a) i)
Ord)

  unsafeCreate :: Vector a -> Static (Vector a) i
unsafeCreate = Vector a -> Static (Vector a) i
forall a (i :: Nat). Vector a -> Static (Vector a) i
Vector
  unwrap :: Static (Vector a) i -> Vector a
unwrap (Vector t) = Vector a
t

  length :: Vector a -> Int
length = Vector a -> Int
forall a. Vector a -> Int
V.length
  append :: Vector a -> Vector a -> Vector a
append = Vector a -> Vector a -> Vector a
forall a. Vector a -> Vector a -> Vector a
(V.++)
  replicate :: Int -> Elem (Vector a) -> Vector a
replicate = Int -> Elem (Vector a) -> Vector a
forall a. Int -> a -> Vector a
V.replicate
  map :: (Elem (Vector a) -> Elem (Vector a)) -> Vector a -> Vector a
map = (Elem (Vector a) -> Elem (Vector a)) -> Vector a -> Vector a
forall a b. (a -> b) -> Vector a -> Vector b
V.map
  take :: Int -> Vector a -> Vector a
take = Int -> Vector a -> Vector a
forall a. Int -> Vector a -> Vector a
V.take
  drop :: Int -> Vector a -> Vector a
drop = Int -> Vector a -> Vector a
forall a. Int -> Vector a -> Vector a
V.drop
#endif