{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeFamilies          #-}

module HaskellWorks.Data.Take
    ( Container(..)
    , Take(..)
    ) where

import Data.Int
import Data.Word
import HaskellWorks.Data.Container
import HaskellWorks.Data.Positioning

import qualified Data.ByteString      as BS
import qualified Data.List            as L
import qualified Data.Vector          as DV
import qualified Data.Vector.Storable as DVS

class Container v => Take v where
  take :: Count -> v -> v

instance Take [a] where
  take :: Count -> [a] -> [a]
take = forall a. Int -> [a] -> [a]
L.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take BS.ByteString where
  take :: Count -> ByteString -> ByteString
take = Int -> ByteString -> ByteString
BS.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DV.Vector Word8) where
  take :: Count -> Vector Word8 -> Vector Word8
take = forall a. Int -> Vector a -> Vector a
DV.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DV.Vector Word16) where
  take :: Count -> Vector Word16 -> Vector Word16
take = forall a. Int -> Vector a -> Vector a
DV.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DV.Vector Word32) where
  take :: Count -> Vector Word32 -> Vector Word32
take = forall a. Int -> Vector a -> Vector a
DV.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DV.Vector Word64) where
  take :: Count -> Vector Count -> Vector Count
take = forall a. Int -> Vector a -> Vector a
DV.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DVS.Vector Word8) where
  take :: Count -> Vector Word8 -> Vector Word8
take = forall a. Storable a => Int -> Vector a -> Vector a
DVS.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DVS.Vector Word16) where
  take :: Count -> Vector Word16 -> Vector Word16
take = forall a. Storable a => Int -> Vector a -> Vector a
DVS.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DVS.Vector Word32) where
  take :: Count -> Vector Word32 -> Vector Word32
take = forall a. Storable a => Int -> Vector a -> Vector a
DVS.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DVS.Vector Word64) where
  take :: Count -> Vector Count -> Vector Count
take = forall a. Storable a => Int -> Vector a -> Vector a
DVS.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DV.Vector Int8) where
  take :: Count -> Vector Int8 -> Vector Int8
take = forall a. Int -> Vector a -> Vector a
DV.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DV.Vector Int16) where
  take :: Count -> Vector Int16 -> Vector Int16
take = forall a. Int -> Vector a -> Vector a
DV.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DV.Vector Int32) where
  take :: Count -> Vector Int32 -> Vector Int32
take = forall a. Int -> Vector a -> Vector a
DV.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DV.Vector Int64) where
  take :: Count -> Vector Int64 -> Vector Int64
take = forall a. Int -> Vector a -> Vector a
DV.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DVS.Vector Int8) where
  take :: Count -> Vector Int8 -> Vector Int8
take = forall a. Storable a => Int -> Vector a -> Vector a
DVS.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DVS.Vector Int16) where
  take :: Count -> Vector Int16 -> Vector Int16
take = forall a. Storable a => Int -> Vector a -> Vector a
DVS.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DVS.Vector Int32) where
  take :: Count -> Vector Int32 -> Vector Int32
take = forall a. Storable a => Int -> Vector a -> Vector a
DVS.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DVS.Vector Int64) where
  take :: Count -> Vector Int64 -> Vector Int64
take = forall a. Storable a => Int -> Vector a -> Vector a
DVS.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}

instance Take (DVS.Vector Int) where
  take :: Count -> Vector Int -> Vector Int
take = forall a. Storable a => Int -> Vector a -> Vector a
DVS.take forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral
  {-# INLINE take #-}