{-# language MagicHash #-}
{-# language RankNTypes #-}
{-# language TypeApplications #-}
{-# language TypeFamilies #-}
{-# language TypeInType #-}
{-# language StandaloneKindSignatures #-}
{-# language UnboxedTuples #-}

module Int8
  ( R
  , A#
  , M#
  , empty#
  , index#
  , write#
  , read#
  , unsafeFreeze#
  , initialized#
  , set#
  , unsafeShrinkFreeze#
  , thaw#
  , freeze#
  , copy#
    -- Comparison
  , lt
  , gt
  , eq
  , lt#
  , gt#
  , eq#
  , max
    -- Metadata
  , size
  ) where

import Prelude hiding (max)

import GHC.Exts
import Data.Kind (Type)
import Data.Unlifted (PrimArray#(..),MutablePrimArray#(..))
import EmptyPrimArray (emptyPrimArray#)

import qualified GHC.Exts as Exts

type A# = PrimArray# @'Int8Rep
type M# = MutablePrimArray# @'Int8Rep
type R = 'Int8Rep

unsafeFromI8 :: forall (a :: TYPE 'Int8Rep). Int8# -> a
unsafeFromI8 :: forall (a :: TYPE 'Int8Rep). Int8# -> a
unsafeFromI8 Int8#
x = Int8# -> a
forall a b. a -> b
unsafeCoerce# Int8#
x

unsafeToI8 :: forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 :: forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
x = a -> Int8#
forall a b. a -> b
unsafeCoerce# a
x

index# :: forall (a :: TYPE R). A# a -> Int# -> a
index# :: forall (a :: TYPE 'Int8Rep). A# a -> Int# -> a
index# (PrimArray# ByteArray#
a) Int#
i = Int8# -> a
forall (a :: TYPE 'Int8Rep). Int8# -> a
unsafeFromI8 (ByteArray# -> Int# -> Int8#
indexInt8Array# ByteArray#
a Int#
i)

write# :: forall (s :: Type) (a :: TYPE R).
  M# s a -> Int# -> a -> State# s -> State# s
write# :: forall s (a :: TYPE 'Int8Rep).
M# s a -> Int# -> a -> State# s -> State# s
write# (MutablePrimArray# MutableByteArray# s
m) Int#
ix a
a State# s
s = MutableByteArray# s -> Int# -> Int8# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Int8# -> State# d -> State# d
writeInt8Array# MutableByteArray# s
m Int#
ix (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
a) State# s
s

read# :: forall (s :: Type) (a :: TYPE R).
  M# s a -> Int# -> State# s -> (# State# s, a #)
read# :: forall s (a :: TYPE 'Int8Rep).
M# s a -> Int# -> State# s -> (# State# s, a #)
read# (MutablePrimArray# MutableByteArray# s
m) Int#
ix State# s
s = case MutableByteArray# s -> Int# -> State# s -> (# State# s, Int8# #)
forall d.
MutableByteArray# d -> Int# -> State# d -> (# State# d, Int8# #)
readInt8Array# MutableByteArray# s
m Int#
ix State# s
s of
  (# State# s
s', Int8#
r #) -> case Int8# -> a
forall (a :: TYPE 'Int8Rep). Int8# -> a
unsafeFromI8 Int8#
r of
    a
r' -> (# State# s
s', a
r' #)

unsafeFreeze# :: forall (s :: Type) (a :: TYPE R).
     M# s a
  -> State# s
  -> (# State# s, A# a #)
unsafeFreeze# :: forall s (a :: TYPE 'Int8Rep).
M# s a -> State# s -> (# State# s, A# a #)
unsafeFreeze# (MutablePrimArray# MutableByteArray# s
m) State# s
s0 = case MutableByteArray# s -> State# s -> (# State# s, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
unsafeFreezeByteArray# MutableByteArray# s
m State# s
s0 of
  (# State# s
s1, ByteArray#
v #) -> (# State# s
s1, ByteArray# -> A# a
forall a. ByteArray# -> PrimArray# a
PrimArray# ByteArray#
v #)

empty# :: forall (a :: TYPE R). (# #) -> A# a
empty# :: forall (a :: TYPE 'Int8Rep). (# #) -> A# a
empty# = (# #) -> PrimArray# a
forall a. (# #) -> PrimArray# a
emptyPrimArray#

initialized# :: forall (s :: Type) (a :: TYPE R).
     Int#
  -> a
  -> State# s
  -> (# State# s, M# s a #)
initialized# :: forall s (a :: TYPE 'Int8Rep).
Int# -> a -> State# s -> (# State# s, M# s a #)
initialized# Int#
n a
a State# s
s0 = case Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
newByteArray# Int#
n State# s
s0 of
  (# State# s
s1, MutableByteArray# s
m #) -> case MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d
Exts.setByteArray# MutableByteArray# s
m Int#
0# Int#
n (Int8# -> Int#
Exts.int8ToInt# (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
a)) State# s
s1 of
    State# s
s2 -> (# State# s
s2, MutableByteArray# s -> M# s a
forall a b. MutableByteArray# a -> MutablePrimArray# a b
MutablePrimArray# MutableByteArray# s
m #)

set# :: forall (s :: Type) (a :: TYPE R).
     M# s a
  -> Int#
  -> Int#
  -> a
  -> State# s
  -> State# s
set# :: forall s (a :: TYPE 'Int8Rep).
M# s a -> Int# -> Int# -> a -> State# s -> State# s
set# (MutablePrimArray# MutableByteArray# s
m) Int#
off0 Int#
len0 a
a State# s
s0 = MutableByteArray# s -> Int# -> Int# -> Int# -> State# s -> State# s
forall d.
MutableByteArray# d -> Int# -> Int# -> Int# -> State# d -> State# d
Exts.setByteArray# MutableByteArray# s
m Int#
off0 Int#
len0 (Int8# -> Int#
Exts.int8ToInt# (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
a)) State# s
s0

-- shrink and freeze, all at once
unsafeShrinkFreeze# ::
     M# s a
  -> Int#
  -> State# s
  -> (# State# s, A# a #)
unsafeShrinkFreeze# :: forall s (a :: TYPE 'Int8Rep).
M# s a -> Int# -> State# s -> (# State# s, A# a #)
unsafeShrinkFreeze# (MutablePrimArray# MutableByteArray# s
m) Int#
i State# s
s0Alpha = case MutableByteArray# s -> State# s -> (# State# s, Int# #)
forall d. MutableByteArray# d -> State# d -> (# State# d, Int# #)
getSizeofMutableByteArray# MutableByteArray# s
m State# s
s0Alpha of
  (# State# s
s0, Int#
sz #) -> case Int#
sz Int# -> Int# -> Int#
==# Int#
i of
    Int#
1# -> case MutableByteArray# s -> State# s -> (# State# s, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
Exts.unsafeFreezeByteArray# MutableByteArray# s
m State# s
s0 of
      (# State# s
s1, ByteArray#
v #) -> (# State# s
s1, ByteArray# -> A# a
forall a. ByteArray# -> PrimArray# a
PrimArray# ByteArray#
v #)
    Int#
_ -> case MutableByteArray# s -> Int# -> State# s -> State# s
forall d. MutableByteArray# d -> Int# -> State# d -> State# d
Exts.shrinkMutableByteArray# MutableByteArray# s
m Int#
i State# s
s0 of
      State# s
s1 -> case MutableByteArray# s -> State# s -> (# State# s, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
Exts.unsafeFreezeByteArray# MutableByteArray# s
m State# s
s1 of
        (# State# s
s2, ByteArray#
v #) -> (# State# s
s2, ByteArray# -> A# a
forall a. ByteArray# -> PrimArray# a
PrimArray# ByteArray#
v #)

thaw# :: forall (s :: Type) (a :: TYPE R).
     A# a
  -> Int#
  -> Int#
  -> State# s
  -> (# State# s, M# s a #)
thaw# :: forall s (a :: TYPE 'Int8Rep).
A# a -> Int# -> Int# -> State# s -> (# State# s, M# s a #)
thaw# (PrimArray# ByteArray#
v) Int#
off Int#
len State# s
s0 = case Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
Exts.newByteArray# Int#
len State# s
s0 of
  (# State# s
s1, MutableByteArray# s
m #) -> case ByteArray#
-> Int#
-> MutableByteArray# s
-> Int#
-> Int#
-> State# s
-> State# s
forall d.
ByteArray#
-> Int#
-> MutableByteArray# d
-> Int#
-> Int#
-> State# d
-> State# d
Exts.copyByteArray# ByteArray#
v Int#
off MutableByteArray# s
m Int#
0# Int#
len State# s
s1 of
    State# s
s2 -> (# State# s
s2, MutableByteArray# s -> M# s a
forall a b. MutableByteArray# a -> MutablePrimArray# a b
MutablePrimArray# MutableByteArray# s
m #)

freeze# :: forall (s :: Type) (a :: TYPE R).
     M# s a
  -> Int#
  -> Int#
  -> State# s
  -> (# State# s, A# a #)
freeze# :: forall s (a :: TYPE 'Int8Rep).
M# s a -> Int# -> Int# -> State# s -> (# State# s, A# a #)
freeze# (MutablePrimArray# MutableByteArray# s
v) Int#
off Int#
len State# s
s0 = case Int# -> State# s -> (# State# s, MutableByteArray# s #)
forall d. Int# -> State# d -> (# State# d, MutableByteArray# d #)
Exts.newByteArray# Int#
len State# s
s0 of
  (# State# s
s1, MutableByteArray# s
m #) -> case MutableByteArray# s
-> Int#
-> MutableByteArray# s
-> Int#
-> Int#
-> State# s
-> State# s
forall d.
MutableByteArray# d
-> Int#
-> MutableByteArray# d
-> Int#
-> Int#
-> State# d
-> State# d
Exts.copyMutableByteArray# MutableByteArray# s
v Int#
off MutableByteArray# s
m Int#
0# Int#
len State# s
s1 of
    State# s
s2 -> case MutableByteArray# s -> State# s -> (# State# s, ByteArray# #)
forall d.
MutableByteArray# d -> State# d -> (# State# d, ByteArray# #)
Exts.unsafeFreezeByteArray# MutableByteArray# s
m State# s
s2 of
      (# State# s
s3, ByteArray#
x #) -> (# State# s
s3, ByteArray# -> A# a
forall a. ByteArray# -> PrimArray# a
PrimArray# ByteArray#
x #)

copy# :: forall (s :: Type) (a :: TYPE R).
     M# s a
  -> Int#
  -> A# a
  -> Int#
  -> Int#
  -> State# s
  -> State# s
copy# :: forall s (a :: TYPE 'Int8Rep).
M# s a -> Int# -> A# a -> Int# -> Int# -> State# s -> State# s
copy# (MutablePrimArray# MutableByteArray# s
m) Int#
doff (PrimArray# ByteArray#
v) Int#
soff Int#
len State# s
s0 =
  ByteArray#
-> Int#
-> MutableByteArray# s
-> Int#
-> Int#
-> State# s
-> State# s
forall d.
ByteArray#
-> Int#
-> MutableByteArray# d
-> Int#
-> Int#
-> State# d
-> State# d
Exts.copyByteArray# ByteArray#
v Int#
soff MutableByteArray# s
m Int#
doff Int#
len State# s
s0

max :: forall (a :: TYPE R). a -> a -> a
{-# inline max #-}
max :: forall (a :: TYPE 'Int8Rep). a -> a -> a
max a
x a
y = if a -> a -> Bool
forall (a :: TYPE 'Int8Rep). a -> a -> Bool
gt a
x a
y then a
x else a
y

lt :: forall (a :: TYPE R). a -> a -> Bool
{-# inline lt #-}
lt :: forall (a :: TYPE 'Int8Rep). a -> a -> Bool
lt a
x a
y = Int# -> Bool
isTrue# (Int8# -> Int8# -> Int#
ltInt8# (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
x) (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
y))

gt :: forall (a :: TYPE R). a -> a -> Bool
{-# inline gt #-}
gt :: forall (a :: TYPE 'Int8Rep). a -> a -> Bool
gt a
x a
y = Int# -> Bool
isTrue# (Int8# -> Int8# -> Int#
gtInt8# (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
x) (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
y))

eq :: forall (a :: TYPE R). a -> a -> Bool
{-# inline eq #-}
eq :: forall (a :: TYPE 'Int8Rep). a -> a -> Bool
eq a
x a
y = Int# -> Bool
isTrue# (Int8# -> Int8# -> Int#
eqInt8# (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
x) (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
y))

lt# :: forall (a :: TYPE R). a -> a -> Int#
{-# inline lt# #-}
lt# :: forall (a :: TYPE 'Int8Rep). a -> a -> Int#
lt# a
x a
y = Int8# -> Int8# -> Int#
ltInt8# (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
x) (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
y)

gt# :: forall (a :: TYPE R). a -> a -> Int#
{-# inline gt# #-}
gt# :: forall (a :: TYPE 'Int8Rep). a -> a -> Int#
gt# a
x a
y = Int8# -> Int8# -> Int#
gtInt8# (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
x) (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
y)

eq# :: forall (a :: TYPE R). a -> a -> Int#
{-# inline eq# #-}
eq# :: forall (a :: TYPE 'Int8Rep). a -> a -> Int#
eq# a
x a
y = Int8# -> Int8# -> Int#
eqInt8# (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
x) (a -> Int8#
forall (a :: TYPE 'Int8Rep). a -> Int8#
unsafeToI8 a
y)

size :: Int
{-# inline size #-}
size :: Int
size = Int
1