{-# LANGUAGE TypeFamilies, TypeOperators #-}
module NoSlow.Backend.Uvector (
  UA, UArr,

  length, replicate, map, zip, zipWith, sum, enumFromTo_Int, filter,
  pair, fst, snd
) where

import NoSlow.Util.Computation

import Data.Array.Vector
import qualified Prelude
import Prelude ( Int, Num, Bool )

instance DeepSeq (UArr a)

instance (TestData a, UA a) => TestData (UArr a) where
  testData n = toU (testData n)

instance Computation (UArr a) where
  type Arg (UArr a) = Nil
  type Res (UArr a) = UArr a
  apply x _ = x

length :: UA a => UArr a -> Int
{-# INLINE length #-}
length = lengthU

replicate :: UA a => Int -> a -> UArr a
{-# INLINE replicate #-}
replicate = replicateU

map :: (UA a, UA b) => (a -> b) -> UArr a -> UArr b
{-# INLINE map #-}
map = mapU

zip :: (UA a, UA b) => UArr a -> UArr b -> UArr (a :*: b)
{-# INLINE zip #-}
zip = zipU

zipWith :: (UA a, UA b, UA c) => (a -> b -> c) -> UArr a -> UArr b -> UArr c
{-# INLINE zipWith #-}
zipWith = zipWithU

sum :: (Num a, UA a) => UArr a -> a
{-# INLINE sum #-}
sum = sumU

enumFromTo_Int :: Int -> Int -> UArr Int
{-# INLINE enumFromTo_Int #-}
enumFromTo_Int = enumFromToU

filter :: UA a => (a -> Bool) -> UArr a -> UArr a
{-# INLINE filter #-}
filter = filterU

pair :: a -> b -> a :*: b
{-# INLINE pair #-}
pair = (:*:)

fst :: a :*: b -> a
{-# INLINE fst #-}
fst = fstS

snd :: a :*: b -> b
{-# INLINE snd #-}
snd = sndS