{-# LANGUAGE Safe #-}

module Data.Connection.Word (
    -- * Word8
    i08w08,

    -- * Word16
    w08w16,
    i08w16,
    i16w16,

    -- * Word32
    w08w32,
    w16w32,
    i08w32,
    i16w32,
    i32w32,

    -- * Word64
    w08w64,
    w16w64,
    w32w64,
    i08w64,
    i16w64,
    i32w64,
    i64w64,
    ixxw64,

    -- * Word
    w08wxx,
    w16wxx,
    w32wxx,
    w64wxx,
    i08wxx,
    i16wxx,
    i32wxx,
    i64wxx,
    ixxwxx,

    -- * Natural
    w08nat,
    w16nat,
    w32nat,
    w64nat,
    wxxnat,
    i08nat,
    i16nat,
    i32nat,
    i64nat,
    ixxnat,
    intnat,
) where

import safe Data.Connection.Conn
import safe Data.Int
import safe Data.Word
import safe Numeric.Natural

-- Word8
i08w08 :: ConnL Int8 Word8
i08w08 :: ConnL Int8 Word8
i08w08 = ConnL Int8 Word8
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

-- Word16
w08w16 :: ConnL Word8 Word16
w08w16 :: ConnL Word8 Word16
w08w16 = ConnL Word8 Word16
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i08w16 :: ConnL Int8 Word16
i08w16 :: ConnL Int8 Word16
i08w16 = ConnL Int8 Word16
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i16w16 :: ConnL Int16 Word16
i16w16 :: ConnL Int16 Word16
i16w16 = ConnL Int16 Word16
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

-- Word32
w08w32 :: ConnL Word8 Word32
w08w32 :: ConnL Word8 Word32
w08w32 = ConnL Word8 Word32
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

w16w32 :: ConnL Word16 Word32
w16w32 :: ConnL Word16 Word32
w16w32 = ConnL Word16 Word32
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i08w32 :: ConnL Int8 Word32
i08w32 :: ConnL Int8 Word32
i08w32 = ConnL Int8 Word32
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i16w32 :: ConnL Int16 Word32
i16w32 :: ConnL Int16 Word32
i16w32 = ConnL Int16 Word32
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i32w32 :: ConnL Int32 Word32
i32w32 :: ConnL Int32 Word32
i32w32 = ConnL Int32 Word32
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

-- Word64
w08w64 :: ConnL Word8 Word64
w08w64 :: ConnL Word8 Word64
w08w64 = ConnL Word8 Word64
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

w16w64 :: ConnL Word16 Word64
w16w64 :: ConnL Word16 Word64
w16w64 = ConnL Word16 Word64
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

w32w64 :: ConnL Word32 Word64
w32w64 :: ConnL Word32 Word64
w32w64 = ConnL Word32 Word64
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i08w64 :: ConnL Int8 Word64
i08w64 :: ConnL Int8 Word64
i08w64 = ConnL Int8 Word64
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i16w64 :: ConnL Int16 Word64
i16w64 :: ConnL Int16 Word64
i16w64 = ConnL Int16 Word64
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i32w64 :: ConnL Int32 Word64
i32w64 :: ConnL Int32 Word64
i32w64 = ConnL Int32 Word64
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i64w64 :: ConnL Int64 Word64
i64w64 :: ConnL Int64 Word64
i64w64 = ConnL Int64 Word64
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

ixxw64 :: ConnL Int Word64
ixxw64 :: ConnL Int Word64
ixxw64 = ConnL Int Word64
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

-- Word
w08wxx :: ConnL Word8 Word
w08wxx :: ConnL Word8 Word
w08wxx = ConnL Word8 Word
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

w16wxx :: ConnL Word16 Word
w16wxx :: ConnL Word16 Word
w16wxx = ConnL Word16 Word
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

w32wxx :: ConnL Word32 Word
w32wxx :: ConnL Word32 Word
w32wxx = ConnL Word32 Word
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

-- | /Caution/: This assumes that 'Word' on your system is 64 bits.
w64wxx :: Conn k Word64 Word
w64wxx :: Conn k Word64 Word
w64wxx = (Word64 -> Word)
-> (Word -> Word64) -> (Word64 -> Word) -> Conn k Word64 Word
forall a b (k :: Kan).
(a -> b) -> (b -> a) -> (a -> b) -> Conn k a b
Conn Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64 -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral

i08wxx :: ConnL Int8 Word
i08wxx :: ConnL Int8 Word
i08wxx = ConnL Int8 Word
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i16wxx :: ConnL Int16 Word
i16wxx :: ConnL Int16 Word
i16wxx = ConnL Int16 Word
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i32wxx :: ConnL Int32 Word
i32wxx :: ConnL Int32 Word
i32wxx = ConnL Int32 Word
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i64wxx :: ConnL Int64 Word
i64wxx :: ConnL Int64 Word
i64wxx = ConnL Int64 Word
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

ixxwxx :: ConnL Int Word
ixxwxx :: ConnL Int Word
ixxwxx = ConnL Int Word
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

-- Natural
w08nat :: ConnL Word8 Natural
w08nat :: ConnL Word8 Natural
w08nat = ConnL Word8 Natural
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

w16nat :: ConnL Word16 Natural
w16nat :: ConnL Word16 Natural
w16nat = ConnL Word16 Natural
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

w32nat :: ConnL Word32 Natural
w32nat :: ConnL Word32 Natural
w32nat = ConnL Word32 Natural
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

w64nat :: ConnL Word64 Natural
w64nat :: ConnL Word64 Natural
w64nat = ConnL Word64 Natural
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

wxxnat :: ConnL Word Natural
wxxnat :: ConnL Word Natural
wxxnat = ConnL Word Natural
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i08nat :: ConnL Int8 Natural
i08nat :: ConnL Int8 Natural
i08nat = ConnL Int8 Natural
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i16nat :: ConnL Int16 Natural
i16nat :: ConnL Int16 Natural
i16nat = ConnL Int16 Natural
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i32nat :: ConnL Int32 Natural
i32nat :: ConnL Int32 Natural
i32nat = ConnL Int32 Natural
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

i64nat :: ConnL Int64 Natural
i64nat :: ConnL Int64 Natural
i64nat = ConnL Int64 Natural
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

ixxnat :: ConnL Int Natural
ixxnat :: ConnL Int Natural
ixxnat = ConnL Int Natural
forall a b. (Bounded a, Integral a, Integral b) => ConnL a b
unsigned

intnat :: ConnL Integer Natural
intnat :: ConnL Integer Natural
intnat = (Integer -> Natural)
-> (Natural -> Integer) -> ConnL Integer Natural
forall a b. (a -> b) -> (b -> a) -> ConnL a b
ConnL (Integer -> Natural
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Natural) -> (Integer -> Integer) -> Integer -> Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer -> Integer
forall a. Ord a => a -> a -> a
max Integer
0) Natural -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral

---------------------------------------------------------------------
-- Internal
---------------------------------------------------------------------

unsigned :: (Bounded a, Integral a, Integral b) => ConnL a b
unsigned :: ConnL a b
unsigned = (a -> b) -> (b -> a) -> ConnL a b
forall a b. (a -> b) -> (b -> a) -> ConnL a b
ConnL a -> b
f b -> a
g
  where
    f :: a -> b
f = a -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a -> b) -> (a -> a) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> a -> a
forall a. Ord a => a -> a -> a
max a
0
    g :: b -> a
g = b -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (b -> a) -> (b -> b) -> b -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> b -> b
forall a. Ord a => a -> a -> a
min (a -> b
f a
forall a. Bounded a => a
maxBound)