    {- |
       Module     : Data.Convertible.Instances.Num
       Copyright  : Copyright (C) 2009-2011 John Goerzen
       License    : BSD3

       Maintainer : John Goerzen <jgoerzen@complete.org>
       Stability  : provisional
       Portability: portable

    Numeric instances for Convertible.

    Copyright (C) 2009-2011 John Goerzen <jgoerzen@complete.org>

    All rights reserved.

    For license and copyright information, see the file LICENSE

    These instances perform conversion between numeric types such as Double, Int, Integer,
    Rational, and the like.  Here are some notes about the conversion process:

    Conversions from floating-point types such as Double to integral types are done via the
    'truncate' function.  This is a somewhat arbitrary decision; if you need different
    behavior, you will have to write your own instance or manually perform the conversion.

    All conversions perform bounds checking.  If a value is too large for its destination
    type, you will get a 'ConvertError' informing you of this.  Note that this behavior
    differs from functions in the Haskell standard libraries, which will perform the
    conversion without error, but give you garbage in the end.

    Conversions do not perform precision checking; loss of precision is implied with certain
    conversions (for instance, Double to Float) and this is not an error.
    -}

    module Data.Convertible.Instances.Num()
    where

    import Data.Convertible.Base
    import Data.Convertible.Utils
    import Data.Int
    import Data.Word

    ------------------------------------------------------------

    {- The following instances generated by this code:

    fp = ["Double", "Float", "Rational"]
    int = ["Int", "Int8", "Int16", "Int32", "Int64", "Word", "Word8", "Word16", "Word32",
           "Word64"]
    allItems l1 l2 = concatMap (\x -> map (\y -> (x, y)) int) fp
    work = allItems fp int
    printIt (f, i) =
        "instance Convertible " ++ f ++ " " ++ i ++ " where \n\
        \    safeConvert = boundedConversion (return . truncate)\n\
        \instance Convertible " ++ i ++ " " ++ f ++ " where \n\
        \    safeConvert = return . fromIntegral\n"

    main = mapM_ (putStrLn . printIt) work
    -}

    instance Convertible Double Int where
        safeConvert :: Double -> ConvertResult Int
    safeConvert = (Double -> ConvertResult Int) -> Double -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Double -> Int) -> Double -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Int
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int Double where
        safeConvert :: Int -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Int -> Double) -> Int -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Double Int8 where
        safeConvert :: Double -> ConvertResult Int8
    safeConvert = (Double -> ConvertResult Int8) -> Double -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Double -> Int8) -> Double -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Int8
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int8 Double where
        safeConvert :: Int8 -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Int8 -> Double) -> Int8 -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Double Int16 where
        safeConvert :: Double -> ConvertResult Int16
    safeConvert = (Double -> ConvertResult Int16) -> Double -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Double -> Int16) -> Double -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Int16
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int16 Double where
        safeConvert :: Int16 -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Int16 -> Double) -> Int16 -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Double Int32 where
        safeConvert :: Double -> ConvertResult Int32
    safeConvert = (Double -> ConvertResult Int32) -> Double -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Double -> Int32) -> Double -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Int32
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int32 Double where
        safeConvert :: Int32 -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Int32 -> Double) -> Int32 -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Double Int64 where
        safeConvert :: Double -> ConvertResult Int64
    safeConvert = (Double -> ConvertResult Int64) -> Double -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Double -> Int64) -> Double -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Int64
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int64 Double where
        safeConvert :: Int64 -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Int64 -> Double) -> Int64 -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Double Word where
        safeConvert :: Double -> ConvertResult Word
    safeConvert = (Double -> ConvertResult Word) -> Double -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Double -> Word) -> Double -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Word
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word Double where
        safeConvert :: Word -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Word -> Double) -> Word -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Double Word8 where
        safeConvert :: Double -> ConvertResult Word8
    safeConvert = (Double -> ConvertResult Word8) -> Double -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Double -> Word8) -> Double -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Word8
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word8 Double where
        safeConvert :: Word8 -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Word8 -> Double) -> Word8 -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Double Word16 where
        safeConvert :: Double -> ConvertResult Word16
    safeConvert = (Double -> ConvertResult Word16) -> Double -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Double -> Word16) -> Double -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Word16
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word16 Double where
        safeConvert :: Word16 -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Word16 -> Double) -> Word16 -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Double Word32 where
        safeConvert :: Double -> ConvertResult Word32
    safeConvert = (Double -> ConvertResult Word32) -> Double -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Double -> Word32) -> Double -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Word32
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word32 Double where
        safeConvert :: Word32 -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Word32 -> Double) -> Word32 -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Double Word64 where
        safeConvert :: Double -> ConvertResult Word64
    safeConvert = (Double -> ConvertResult Word64) -> Double -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Double -> Word64) -> Double -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Word64
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word64 Double where
        safeConvert :: Word64 -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Word64 -> Double) -> Word64 -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Float Int where
        safeConvert :: Float -> ConvertResult Int
    safeConvert = (Float -> ConvertResult Int) -> Float -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Float -> Int) -> Float -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Int
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int Float where
        safeConvert :: Int -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Int -> Float) -> Int -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Float Int8 where
        safeConvert :: Float -> ConvertResult Int8
    safeConvert = (Float -> ConvertResult Int8) -> Float -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Float -> Int8) -> Float -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Int8
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int8 Float where
        safeConvert :: Int8 -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Int8 -> Float) -> Int8 -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Float Int16 where
        safeConvert :: Float -> ConvertResult Int16
    safeConvert = (Float -> ConvertResult Int16) -> Float -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Float -> Int16) -> Float -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Int16
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int16 Float where
        safeConvert :: Int16 -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Int16 -> Float) -> Int16 -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Float Int32 where
        safeConvert :: Float -> ConvertResult Int32
    safeConvert = (Float -> ConvertResult Int32) -> Float -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Float -> Int32) -> Float -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Int32
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int32 Float where
        safeConvert :: Int32 -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Int32 -> Float) -> Int32 -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Float Int64 where
        safeConvert :: Float -> ConvertResult Int64
    safeConvert = (Float -> ConvertResult Int64) -> Float -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Float -> Int64) -> Float -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Int64
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int64 Float where
        safeConvert :: Int64 -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Int64 -> Float) -> Int64 -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Float Word where
        safeConvert :: Float -> ConvertResult Word
    safeConvert = (Float -> ConvertResult Word) -> Float -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Float -> Word) -> Float -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Word
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word Float where
        safeConvert :: Word -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Word -> Float) -> Word -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Float Word8 where
        safeConvert :: Float -> ConvertResult Word8
    safeConvert = (Float -> ConvertResult Word8) -> Float -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Float -> Word8) -> Float -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Word8
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word8 Float where
        safeConvert :: Word8 -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Word8 -> Float) -> Word8 -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Float Word16 where
        safeConvert :: Float -> ConvertResult Word16
    safeConvert = (Float -> ConvertResult Word16) -> Float -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Float -> Word16) -> Float -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Word16
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word16 Float where
        safeConvert :: Word16 -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Word16 -> Float) -> Word16 -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Float Word32 where
        safeConvert :: Float -> ConvertResult Word32
    safeConvert = (Float -> ConvertResult Word32) -> Float -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Float -> Word32) -> Float -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Word32
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word32 Float where
        safeConvert :: Word32 -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Word32 -> Float) -> Word32 -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Float Word64 where
        safeConvert :: Float -> ConvertResult Word64
    safeConvert = (Float -> ConvertResult Word64) -> Float -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Float -> Word64) -> Float -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Word64
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word64 Float where
        safeConvert :: Word64 -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Word64 -> Float) -> Word64 -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Rational Int where
        safeConvert :: Rational -> ConvertResult Int
    safeConvert = (Rational -> ConvertResult Int) -> Rational -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Rational -> Int) -> Rational -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Int
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int Rational where
        safeConvert :: Int -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Int -> Rational) -> Int -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Rational Int8 where
        safeConvert :: Rational -> ConvertResult Int8
    safeConvert = (Rational -> ConvertResult Int8) -> Rational -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Rational -> Int8) -> Rational -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Int8
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int8 Rational where
        safeConvert :: Int8 -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Int8 -> Rational) -> Int8 -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Rational Int16 where
        safeConvert :: Rational -> ConvertResult Int16
    safeConvert = (Rational -> ConvertResult Int16)
    -> Rational -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Rational -> Int16) -> Rational -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Int16
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int16 Rational where
        safeConvert :: Int16 -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Int16 -> Rational) -> Int16 -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Rational Int32 where
        safeConvert :: Rational -> ConvertResult Int32
    safeConvert = (Rational -> ConvertResult Int32)
    -> Rational -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Rational -> Int32) -> Rational -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Int32
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int32 Rational where
        safeConvert :: Int32 -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Int32 -> Rational) -> Int32 -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Rational Int64 where
        safeConvert :: Rational -> ConvertResult Int64
    safeConvert = (Rational -> ConvertResult Int64)
    -> Rational -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Rational -> Int64) -> Rational -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Int64
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Int64 Rational where
        safeConvert :: Int64 -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Int64 -> Rational) -> Int64 -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Rational Word where
        safeConvert :: Rational -> ConvertResult Word
    safeConvert = (Rational -> ConvertResult Word) -> Rational -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Rational -> Word) -> Rational -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Word
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word Rational where
        safeConvert :: Word -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Word -> Rational) -> Word -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Rational Word8 where
        safeConvert :: Rational -> ConvertResult Word8
    safeConvert = (Rational -> ConvertResult Word8)
    -> Rational -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Rational -> Word8) -> Rational -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Word8
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word8 Rational where
        safeConvert :: Word8 -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Word8 -> Rational) -> Word8 -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Rational Word16 where
        safeConvert :: Rational -> ConvertResult Word16
    safeConvert = (Rational -> ConvertResult Word16)
    -> Rational -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Rational -> Word16) -> Rational -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Word16
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word16 Rational where
        safeConvert :: Word16 -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Word16 -> Rational) -> Word16 -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Rational Word32 where
        safeConvert :: Rational -> ConvertResult Word32
    safeConvert = (Rational -> ConvertResult Word32)
    -> Rational -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Rational -> Word32) -> Rational -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Word32
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word32 Rational where
        safeConvert :: Word32 -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Word32 -> Rational) -> Word32 -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Rational Word64 where
        safeConvert :: Rational -> ConvertResult Word64
    safeConvert = (Rational -> ConvertResult Word64)
    -> Rational -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Rational -> Word64) -> Rational -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Word64
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate)
    instance Convertible Word64 Rational where
        safeConvert :: Word64 -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Word64 -> Rational) -> Word64 -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    ------------------------------------------------------------
    {- The following instances generated by this code:

    int = ["Int", "Int8", "Int16", "Int32", "Int64", "Word", "Word8", "Word16", "Word32",
           "Word64"]
    allItems l1 l2 = concatMap (\x -> map (\y -> (x, y)) l1) l2
    work = filter (\(a, b) -> a /= b) (allItems int int)
    printIt (f, i) =
        "instance Convertible " ++ f ++ " " ++ i ++ " where \n\
        \    safeConvert = boundedConversion (return . fromIntegral)\n"

    printInteger i =
        "instance Convertible Integer " ++ i ++ " where \n\
        \    safeConvert = boundedConversion (return . fromIntegral)\n\
        \instance Convertible " ++ i ++ " Integer where \n\
        \    safeConvert = return . fromIntegral\n\n"

    main = do mapM_ (putStrLn . printIt) work
              mapM_ (putStrLn . printInteger) int
    -}

    instance Convertible Int Int8 where
        safeConvert :: Int -> ConvertResult Int8
    safeConvert = (Int -> ConvertResult Int8) -> Int -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Int -> Int8) -> Int -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int Int16 where
        safeConvert :: Int -> ConvertResult Int16
    safeConvert = (Int -> ConvertResult Int16) -> Int -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Int -> Int16) -> Int -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int Int32 where
        safeConvert :: Int -> ConvertResult Int32
    safeConvert = (Int -> ConvertResult Int32) -> Int -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Int -> Int32) -> Int -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int Int64 where
        safeConvert :: Int -> ConvertResult Int64
    safeConvert = (Int -> ConvertResult Int64) -> Int -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Int -> Int64) -> Int -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int Word where
        safeConvert :: Int -> ConvertResult Word
    safeConvert = (Int -> ConvertResult Word) -> Int -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Int -> Word) -> Int -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int Word8 where
        safeConvert :: Int -> ConvertResult Word8
    safeConvert = (Int -> ConvertResult Word8) -> Int -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Int -> Word8) -> Int -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int Word16 where
        safeConvert :: Int -> ConvertResult Word16
    safeConvert = (Int -> ConvertResult Word16) -> Int -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Int -> Word16) -> Int -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int Word32 where
        safeConvert :: Int -> ConvertResult Word32
    safeConvert = (Int -> ConvertResult Word32) -> Int -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Int -> Word32) -> Int -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int Word64 where
        safeConvert :: Int -> ConvertResult Word64
    safeConvert = (Int -> ConvertResult Word64) -> Int -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Int -> Word64) -> Int -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int8 Int where
        safeConvert :: Int8 -> ConvertResult Int
    safeConvert = (Int8 -> ConvertResult Int) -> Int8 -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Int8 -> Int) -> Int8 -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int8 Int16 where
        safeConvert :: Int8 -> ConvertResult Int16
    safeConvert = (Int8 -> ConvertResult Int16) -> Int8 -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Int8 -> Int16) -> Int8 -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int8 Int32 where
        safeConvert :: Int8 -> ConvertResult Int32
    safeConvert = (Int8 -> ConvertResult Int32) -> Int8 -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Int8 -> Int32) -> Int8 -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int8 Int64 where
        safeConvert :: Int8 -> ConvertResult Int64
    safeConvert = (Int8 -> ConvertResult Int64) -> Int8 -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Int8 -> Int64) -> Int8 -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int8 Word where
        safeConvert :: Int8 -> ConvertResult Word
    safeConvert = (Int8 -> ConvertResult Word) -> Int8 -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Int8 -> Word) -> Int8 -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int8 Word8 where
        safeConvert :: Int8 -> ConvertResult Word8
    safeConvert = (Int8 -> ConvertResult Word8) -> Int8 -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Int8 -> Word8) -> Int8 -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int8 Word16 where
        safeConvert :: Int8 -> ConvertResult Word16
    safeConvert = (Int8 -> ConvertResult Word16) -> Int8 -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Int8 -> Word16) -> Int8 -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int8 Word32 where
        safeConvert :: Int8 -> ConvertResult Word32
    safeConvert = (Int8 -> ConvertResult Word32) -> Int8 -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Int8 -> Word32) -> Int8 -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int8 Word64 where
        safeConvert :: Int8 -> ConvertResult Word64
    safeConvert = (Int8 -> ConvertResult Word64) -> Int8 -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Int8 -> Word64) -> Int8 -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int16 Int where
        safeConvert :: Int16 -> ConvertResult Int
    safeConvert = (Int16 -> ConvertResult Int) -> Int16 -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Int16 -> Int) -> Int16 -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int16 Int8 where
        safeConvert :: Int16 -> ConvertResult Int8
    safeConvert = (Int16 -> ConvertResult Int8) -> Int16 -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Int16 -> Int8) -> Int16 -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int16 Int32 where
        safeConvert :: Int16 -> ConvertResult Int32
    safeConvert = (Int16 -> ConvertResult Int32) -> Int16 -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Int16 -> Int32) -> Int16 -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int16 Int64 where
        safeConvert :: Int16 -> ConvertResult Int64
    safeConvert = (Int16 -> ConvertResult Int64) -> Int16 -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Int16 -> Int64) -> Int16 -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int16 Word where
        safeConvert :: Int16 -> ConvertResult Word
    safeConvert = (Int16 -> ConvertResult Word) -> Int16 -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Int16 -> Word) -> Int16 -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int16 Word8 where
        safeConvert :: Int16 -> ConvertResult Word8
    safeConvert = (Int16 -> ConvertResult Word8) -> Int16 -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Int16 -> Word8) -> Int16 -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int16 Word16 where
        safeConvert :: Int16 -> ConvertResult Word16
    safeConvert = (Int16 -> ConvertResult Word16) -> Int16 -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Int16 -> Word16) -> Int16 -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int16 Word32 where
        safeConvert :: Int16 -> ConvertResult Word32
    safeConvert = (Int16 -> ConvertResult Word32) -> Int16 -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Int16 -> Word32) -> Int16 -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int16 Word64 where
        safeConvert :: Int16 -> ConvertResult Word64
    safeConvert = (Int16 -> ConvertResult Word64) -> Int16 -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Int16 -> Word64) -> Int16 -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int32 Int where
        safeConvert :: Int32 -> ConvertResult Int
    safeConvert = (Int32 -> ConvertResult Int) -> Int32 -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Int32 -> Int) -> Int32 -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int32 Int8 where
        safeConvert :: Int32 -> ConvertResult Int8
    safeConvert = (Int32 -> ConvertResult Int8) -> Int32 -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Int32 -> Int8) -> Int32 -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int32 Int16 where
        safeConvert :: Int32 -> ConvertResult Int16
    safeConvert = (Int32 -> ConvertResult Int16) -> Int32 -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Int32 -> Int16) -> Int32 -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int32 Int64 where
        safeConvert :: Int32 -> ConvertResult Int64
    safeConvert = (Int32 -> ConvertResult Int64) -> Int32 -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Int32 -> Int64) -> Int32 -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int32 Word where
        safeConvert :: Int32 -> ConvertResult Word
    safeConvert = (Int32 -> ConvertResult Word) -> Int32 -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Int32 -> Word) -> Int32 -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int32 Word8 where
        safeConvert :: Int32 -> ConvertResult Word8
    safeConvert = (Int32 -> ConvertResult Word8) -> Int32 -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Int32 -> Word8) -> Int32 -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int32 Word16 where
        safeConvert :: Int32 -> ConvertResult Word16
    safeConvert = (Int32 -> ConvertResult Word16) -> Int32 -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Int32 -> Word16) -> Int32 -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int32 Word32 where
        safeConvert :: Int32 -> ConvertResult Word32
    safeConvert = (Int32 -> ConvertResult Word32) -> Int32 -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Int32 -> Word32) -> Int32 -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int32 Word64 where
        safeConvert :: Int32 -> ConvertResult Word64
    safeConvert = (Int32 -> ConvertResult Word64) -> Int32 -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Int32 -> Word64) -> Int32 -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int64 Int where
        safeConvert :: Int64 -> ConvertResult Int
    safeConvert = (Int64 -> ConvertResult Int) -> Int64 -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Int64 -> Int) -> Int64 -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int64 Int8 where
        safeConvert :: Int64 -> ConvertResult Int8
    safeConvert = (Int64 -> ConvertResult Int8) -> Int64 -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Int64 -> Int8) -> Int64 -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int64 Int16 where
        safeConvert :: Int64 -> ConvertResult Int16
    safeConvert = (Int64 -> ConvertResult Int16) -> Int64 -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Int64 -> Int16) -> Int64 -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int64 Int32 where
        safeConvert :: Int64 -> ConvertResult Int32
    safeConvert = (Int64 -> ConvertResult Int32) -> Int64 -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Int64 -> Int32) -> Int64 -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int64 Word where
        safeConvert :: Int64 -> ConvertResult Word
    safeConvert = (Int64 -> ConvertResult Word) -> Int64 -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Int64 -> Word) -> Int64 -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int64 Word8 where
        safeConvert :: Int64 -> ConvertResult Word8
    safeConvert = (Int64 -> ConvertResult Word8) -> Int64 -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Int64 -> Word8) -> Int64 -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int64 Word16 where
        safeConvert :: Int64 -> ConvertResult Word16
    safeConvert = (Int64 -> ConvertResult Word16) -> Int64 -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Int64 -> Word16) -> Int64 -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int64 Word32 where
        safeConvert :: Int64 -> ConvertResult Word32
    safeConvert = (Int64 -> ConvertResult Word32) -> Int64 -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Int64 -> Word32) -> Int64 -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Int64 Word64 where
        safeConvert :: Int64 -> ConvertResult Word64
    safeConvert = (Int64 -> ConvertResult Word64) -> Int64 -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Int64 -> Word64) -> Int64 -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word Int where
        safeConvert :: Word -> ConvertResult Int
    safeConvert = (Word -> ConvertResult Int) -> Word -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Word -> Int) -> Word -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word Int8 where
        safeConvert :: Word -> ConvertResult Int8
    safeConvert = (Word -> ConvertResult Int8) -> Word -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Word -> Int8) -> Word -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word Int16 where
        safeConvert :: Word -> ConvertResult Int16
    safeConvert = (Word -> ConvertResult Int16) -> Word -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Word -> Int16) -> Word -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word Int32 where
        safeConvert :: Word -> ConvertResult Int32
    safeConvert = (Word -> ConvertResult Int32) -> Word -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Word -> Int32) -> Word -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word Int64 where
        safeConvert :: Word -> ConvertResult Int64
    safeConvert = (Word -> ConvertResult Int64) -> Word -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Word -> Int64) -> Word -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word Word8 where
        safeConvert :: Word -> ConvertResult Word8
    safeConvert = (Word -> ConvertResult Word8) -> Word -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Word -> Word8) -> Word -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word Word16 where
        safeConvert :: Word -> ConvertResult Word16
    safeConvert = (Word -> ConvertResult Word16) -> Word -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Word -> Word16) -> Word -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word Word32 where
        safeConvert :: Word -> ConvertResult Word32
    safeConvert = (Word -> ConvertResult Word32) -> Word -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Word -> Word32) -> Word -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word Word64 where
        safeConvert :: Word -> ConvertResult Word64
    safeConvert = (Word -> ConvertResult Word64) -> Word -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Word -> Word64) -> Word -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word8 Int where
        safeConvert :: Word8 -> ConvertResult Int
    safeConvert = (Word8 -> ConvertResult Int) -> Word8 -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Word8 -> Int) -> Word8 -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word8 Int8 where
        safeConvert :: Word8 -> ConvertResult Int8
    safeConvert = (Word8 -> ConvertResult Int8) -> Word8 -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Word8 -> Int8) -> Word8 -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word8 Int16 where
        safeConvert :: Word8 -> ConvertResult Int16
    safeConvert = (Word8 -> ConvertResult Int16) -> Word8 -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Word8 -> Int16) -> Word8 -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word8 Int32 where
        safeConvert :: Word8 -> ConvertResult Int32
    safeConvert = (Word8 -> ConvertResult Int32) -> Word8 -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Word8 -> Int32) -> Word8 -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word8 Int64 where
        safeConvert :: Word8 -> ConvertResult Int64
    safeConvert = (Word8 -> ConvertResult Int64) -> Word8 -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Word8 -> Int64) -> Word8 -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word8 Word where
        safeConvert :: Word8 -> ConvertResult Word
    safeConvert = (Word8 -> ConvertResult Word) -> Word8 -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Word8 -> Word) -> Word8 -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word8 Word16 where
        safeConvert :: Word8 -> ConvertResult Word16
    safeConvert = (Word8 -> ConvertResult Word16) -> Word8 -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Word8 -> Word16) -> Word8 -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word8 Word32 where
        safeConvert :: Word8 -> ConvertResult Word32
    safeConvert = (Word8 -> ConvertResult Word32) -> Word8 -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Word8 -> Word32) -> Word8 -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word8 Word64 where
        safeConvert :: Word8 -> ConvertResult Word64
    safeConvert = (Word8 -> ConvertResult Word64) -> Word8 -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Word8 -> Word64) -> Word8 -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word16 Int where
        safeConvert :: Word16 -> ConvertResult Int
    safeConvert = (Word16 -> ConvertResult Int) -> Word16 -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Word16 -> Int) -> Word16 -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word16 Int8 where
        safeConvert :: Word16 -> ConvertResult Int8
    safeConvert = (Word16 -> ConvertResult Int8) -> Word16 -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Word16 -> Int8) -> Word16 -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word16 Int16 where
        safeConvert :: Word16 -> ConvertResult Int16
    safeConvert = (Word16 -> ConvertResult Int16) -> Word16 -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Word16 -> Int16) -> Word16 -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word16 Int32 where
        safeConvert :: Word16 -> ConvertResult Int32
    safeConvert = (Word16 -> ConvertResult Int32) -> Word16 -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Word16 -> Int32) -> Word16 -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word16 Int64 where
        safeConvert :: Word16 -> ConvertResult Int64
    safeConvert = (Word16 -> ConvertResult Int64) -> Word16 -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Word16 -> Int64) -> Word16 -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word16 Word where
        safeConvert :: Word16 -> ConvertResult Word
    safeConvert = (Word16 -> ConvertResult Word) -> Word16 -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Word16 -> Word) -> Word16 -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word16 Word8 where
        safeConvert :: Word16 -> ConvertResult Word8
    safeConvert = (Word16 -> ConvertResult Word8) -> Word16 -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Word16 -> Word8) -> Word16 -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word16 Word32 where
        safeConvert :: Word16 -> ConvertResult Word32
    safeConvert = (Word16 -> ConvertResult Word32) -> Word16 -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Word16 -> Word32) -> Word16 -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word16 Word64 where
        safeConvert :: Word16 -> ConvertResult Word64
    safeConvert = (Word16 -> ConvertResult Word64) -> Word16 -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Word16 -> Word64) -> Word16 -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word32 Int where
        safeConvert :: Word32 -> ConvertResult Int
    safeConvert = (Word32 -> ConvertResult Int) -> Word32 -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Word32 -> Int) -> Word32 -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word32 Int8 where
        safeConvert :: Word32 -> ConvertResult Int8
    safeConvert = (Word32 -> ConvertResult Int8) -> Word32 -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Word32 -> Int8) -> Word32 -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word32 Int16 where
        safeConvert :: Word32 -> ConvertResult Int16
    safeConvert = (Word32 -> ConvertResult Int16) -> Word32 -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Word32 -> Int16) -> Word32 -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word32 Int32 where
        safeConvert :: Word32 -> ConvertResult Int32
    safeConvert = (Word32 -> ConvertResult Int32) -> Word32 -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Word32 -> Int32) -> Word32 -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word32 Int64 where
        safeConvert :: Word32 -> ConvertResult Int64
    safeConvert = (Word32 -> ConvertResult Int64) -> Word32 -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Word32 -> Int64) -> Word32 -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word32 Word where
        safeConvert :: Word32 -> ConvertResult Word
    safeConvert = (Word32 -> ConvertResult Word) -> Word32 -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Word32 -> Word) -> Word32 -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word32 Word8 where
        safeConvert :: Word32 -> ConvertResult Word8
    safeConvert = (Word32 -> ConvertResult Word8) -> Word32 -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Word32 -> Word8) -> Word32 -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word32 Word16 where
        safeConvert :: Word32 -> ConvertResult Word16
    safeConvert = (Word32 -> ConvertResult Word16) -> Word32 -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Word32 -> Word16) -> Word32 -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word32 Word64 where
        safeConvert :: Word32 -> ConvertResult Word64
    safeConvert = (Word32 -> ConvertResult Word64) -> Word32 -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Word32 -> Word64) -> Word32 -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word64 Int where
        safeConvert :: Word64 -> ConvertResult Int
    safeConvert = (Word64 -> ConvertResult Int) -> Word64 -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Word64 -> Int) -> Word64 -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word64 Int8 where
        safeConvert :: Word64 -> ConvertResult Int8
    safeConvert = (Word64 -> ConvertResult Int8) -> Word64 -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Word64 -> Int8) -> Word64 -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word64 Int16 where
        safeConvert :: Word64 -> ConvertResult Int16
    safeConvert = (Word64 -> ConvertResult Int16) -> Word64 -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Word64 -> Int16) -> Word64 -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word64 Int32 where
        safeConvert :: Word64 -> ConvertResult Int32
    safeConvert = (Word64 -> ConvertResult Int32) -> Word64 -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Word64 -> Int32) -> Word64 -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word64 Int64 where
        safeConvert :: Word64 -> ConvertResult Int64
    safeConvert = (Word64 -> ConvertResult Int64) -> Word64 -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Word64 -> Int64) -> Word64 -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word64 Word where
        safeConvert :: Word64 -> ConvertResult Word
    safeConvert = (Word64 -> ConvertResult Word) -> Word64 -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Word64 -> Word) -> Word64 -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word64 Word8 where
        safeConvert :: Word64 -> ConvertResult Word8
    safeConvert = (Word64 -> ConvertResult Word8) -> Word64 -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Word64 -> Word8) -> Word64 -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word64 Word16 where
        safeConvert :: Word64 -> ConvertResult Word16
    safeConvert = (Word64 -> ConvertResult Word16) -> Word64 -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Word64 -> Word16) -> Word64 -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Word64 Word32 where
        safeConvert :: Word64 -> ConvertResult Word32
    safeConvert = (Word64 -> ConvertResult Word32) -> Word64 -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Word64 -> Word32) -> Word64 -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Integer Int where
        safeConvert :: Integer -> ConvertResult Int
    safeConvert = (Integer -> ConvertResult Int) -> Integer -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Integer -> Int) -> Integer -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
    instance Convertible Int Integer where
        safeConvert :: Int -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Int -> Integer) -> Int -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Integer Int8 where
        safeConvert :: Integer -> ConvertResult Int8
    safeConvert = (Integer -> ConvertResult Int8) -> Integer -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Integer -> Int8) -> Integer -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
    instance Convertible Int8 Integer where
        safeConvert :: Int8 -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Int8 -> Integer) -> Int8 -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Integer Int16 where
        safeConvert :: Integer -> ConvertResult Int16
    safeConvert = (Integer -> ConvertResult Int16) -> Integer -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Integer -> Int16) -> Integer -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
    instance Convertible Int16 Integer where
        safeConvert :: Int16 -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Int16 -> Integer) -> Int16 -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Integer Int32 where
        safeConvert :: Integer -> ConvertResult Int32
    safeConvert = (Integer -> ConvertResult Int32) -> Integer -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Integer -> Int32) -> Integer -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
    instance Convertible Int32 Integer where
        safeConvert :: Int32 -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Int32 -> Integer) -> Int32 -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Integer Int64 where
        safeConvert :: Integer -> ConvertResult Int64
    safeConvert = (Integer -> ConvertResult Int64) -> Integer -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Integer -> Int64) -> Integer -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
    instance Convertible Int64 Integer where
        safeConvert :: Int64 -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Int64 -> Integer) -> Int64 -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Integer Word where
        safeConvert :: Integer -> ConvertResult Word
    safeConvert = (Integer -> ConvertResult Word) -> Integer -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Integer -> Word) -> Integer -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
    instance Convertible Word Integer where
        safeConvert :: Word -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Word -> Integer) -> Word -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Integer Word8 where
        safeConvert :: Integer -> ConvertResult Word8
    safeConvert = (Integer -> ConvertResult Word8) -> Integer -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Integer -> Word8) -> Integer -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
    instance Convertible Word8 Integer where
        safeConvert :: Word8 -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Word8 -> Integer) -> Word8 -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Integer Word16 where
        safeConvert :: Integer -> ConvertResult Word16
    safeConvert = (Integer -> ConvertResult Word16)
    -> Integer -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Integer -> Word16) -> Integer -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
    instance Convertible Word16 Integer where
        safeConvert :: Word16 -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Word16 -> Integer) -> Word16 -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Integer Word32 where
        safeConvert :: Integer -> ConvertResult Word32
    safeConvert = (Integer -> ConvertResult Word32)
    -> Integer -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Integer -> Word32) -> Integer -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
    instance Convertible Word32 Integer where
        safeConvert :: Word32 -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Word32 -> Integer) -> Word32 -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    instance Convertible Integer Word64 where
        safeConvert :: Integer -> ConvertResult Word64
    safeConvert = (Integer -> ConvertResult Word64)
    -> Integer -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Integer -> Word64) -> Integer -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)
    instance Convertible Word64 Integer where
        safeConvert :: Word64 -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Word64 -> Integer) -> Word64 -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral

    ------------------------------------------------------------

    instance Convertible Integer Double where
        safeConvert :: Integer -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Integer -> Double) -> Integer -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Double
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral
    instance Convertible Integer Float where
        safeConvert :: Integer -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Integer -> Float) -> Integer -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Float
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral
    instance Convertible Integer Rational where
        safeConvert :: Integer -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Integer -> Rational) -> Integer -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Rational
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral
    instance Convertible Double Integer where
        safeConvert :: Double -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Double -> Integer) -> Double -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Integer
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate
    instance Convertible Float Integer where
        safeConvert :: Float -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Float -> Integer) -> Float -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Integer
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate
    instance Convertible Rational Integer where
        safeConvert :: Rational -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Rational -> Integer) -> Rational -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Integer
    forall a b. (RealFrac a, Integral b) => a -> b
    truncate

    instance Convertible Float Double where
        safeConvert :: Float -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Float -> Double) -> Float -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Double
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac
    instance Convertible Double Float where
        safeConvert :: Double -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Double -> Float) -> Double -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Float
    forall a b. (Real a, Fractional b) => a -> b
    realToFrac
    instance Convertible Float Rational where
        safeConvert :: Float -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Float -> Rational) -> Float -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Float -> Rational
    forall a. Real a => a -> Rational
    toRational
    instance Convertible Rational Float where
        safeConvert :: Rational -> ConvertResult Float
    safeConvert = Float -> ConvertResult Float
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Float -> ConvertResult Float)
    -> (Rational -> Float) -> Rational -> ConvertResult Float
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Float
    forall a. Fractional a => Rational -> a
    fromRational
    instance Convertible Double Rational where
        safeConvert :: Double -> ConvertResult Rational
    safeConvert = Rational -> ConvertResult Rational
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Rational -> ConvertResult Rational)
    -> (Double -> Rational) -> Double -> ConvertResult Rational
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Double -> Rational
    forall a. Real a => a -> Rational
    toRational
    instance Convertible Rational Double where
        safeConvert :: Rational -> ConvertResult Double
    safeConvert = Double -> ConvertResult Double
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Double -> ConvertResult Double)
    -> (Rational -> Double) -> Rational -> ConvertResult Double
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Rational -> Double
    forall a. Fractional a => Rational -> a
    fromRational

    ------------------------------------------------------------
    instance Convertible Char Integer where
        safeConvert :: Char -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Char -> Integer) -> Char -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Integer
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Integer) -> (Char -> Int) -> Char -> Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum
    instance Convertible Integer Char where
        safeConvert :: Integer -> ConvertResult Char
    safeConvert = (Integer -> ConvertResult Char) -> Integer -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Integer -> Char) -> Integer -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Integer -> Int) -> Integer -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    ------------------------------------------------------------
    {- These instances generated by:

    int = ["Int", "Int8", "Int16", "Int32", "Int64", "Word", "Word8", "Word16", "Word32",
           "Word64"]
    printIt i =
        "instance Convertible Char " ++ i ++ " where \n\
        \    safeConvert = boundedConversion (return . fromIntegral . fromEnum)\n\
        \instance Convertible " ++ i ++ " Char where \n\
        \    safeConvert = boundedConversion (return . toEnum . fromIntegral)\n\n"

    main = do mapM_ (putStrLn . printIt) int
    -}

    instance Convertible Char Int where
        safeConvert :: Char -> ConvertResult Int
    safeConvert = (Char -> ConvertResult Int) -> Char -> ConvertResult Int
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int -> ConvertResult Int
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ConvertResult Int)
    -> (Char -> Int) -> Char -> ConvertResult Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int) -> (Char -> Int) -> Char -> Int
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum)
    instance Convertible Int Char where
        safeConvert :: Int -> ConvertResult Char
    safeConvert = (Int -> ConvertResult Char) -> Int -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Int -> Char) -> Int -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Int -> Int) -> Int -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Char Int8 where
        safeConvert :: Char -> ConvertResult Int8
    safeConvert = (Char -> ConvertResult Int8) -> Char -> ConvertResult Int8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int8 -> ConvertResult Int8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int8 -> ConvertResult Int8)
    -> (Char -> Int8) -> Char -> ConvertResult Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Int8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int8) -> (Char -> Int) -> Char -> Int8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum)
    instance Convertible Int8 Char where
        safeConvert :: Int8 -> ConvertResult Char
    safeConvert = (Int8 -> ConvertResult Char) -> Int8 -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Int8 -> Char) -> Int8 -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Int8 -> Int) -> Int8 -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Char Int16 where
        safeConvert :: Char -> ConvertResult Int16
    safeConvert = (Char -> ConvertResult Int16) -> Char -> ConvertResult Int16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int16 -> ConvertResult Int16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int16 -> ConvertResult Int16)
    -> (Char -> Int16) -> Char -> ConvertResult Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Int16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int16) -> (Char -> Int) -> Char -> Int16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum)
    instance Convertible Int16 Char where
        safeConvert :: Int16 -> ConvertResult Char
    safeConvert = (Int16 -> ConvertResult Char) -> Int16 -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Int16 -> Char) -> Int16 -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Int16 -> Int) -> Int16 -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int16 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Char Int32 where
        safeConvert :: Char -> ConvertResult Int32
    safeConvert = (Char -> ConvertResult Int32) -> Char -> ConvertResult Int32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int32 -> ConvertResult Int32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int32 -> ConvertResult Int32)
    -> (Char -> Int32) -> Char -> ConvertResult Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Int32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int32) -> (Char -> Int) -> Char -> Int32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum)
    instance Convertible Int32 Char where
        safeConvert :: Int32 -> ConvertResult Char
    safeConvert = (Int32 -> ConvertResult Char) -> Int32 -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Int32 -> Char) -> Int32 -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Int32 -> Int) -> Int32 -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Char Int64 where
        safeConvert :: Char -> ConvertResult Int64
    safeConvert = (Char -> ConvertResult Int64) -> Char -> ConvertResult Int64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Int64 -> ConvertResult Int64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int64 -> ConvertResult Int64)
    -> (Char -> Int64) -> Char -> ConvertResult Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Int64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Int64) -> (Char -> Int) -> Char -> Int64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum)
    instance Convertible Int64 Char where
        safeConvert :: Int64 -> ConvertResult Char
    safeConvert = (Int64 -> ConvertResult Char) -> Int64 -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Int64 -> Char) -> Int64 -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Int64 -> Int) -> Int64 -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int64 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Char Word where
        safeConvert :: Char -> ConvertResult Word
    safeConvert = (Char -> ConvertResult Word) -> Char -> ConvertResult Word
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word -> ConvertResult Word
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word -> ConvertResult Word)
    -> (Char -> Word) -> Char -> ConvertResult Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Word
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word) -> (Char -> Int) -> Char -> Word
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum)
    instance Convertible Word Char where
        safeConvert :: Word -> ConvertResult Char
    safeConvert = (Word -> ConvertResult Char) -> Word -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Word -> Char) -> Word -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Word -> Int) -> Word -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Char Word8 where
        safeConvert :: Char -> ConvertResult Word8
    safeConvert = (Char -> ConvertResult Word8) -> Char -> ConvertResult Word8
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word8 -> ConvertResult Word8
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word8 -> ConvertResult Word8)
    -> (Char -> Word8) -> Char -> ConvertResult Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Word8
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word8) -> (Char -> Int) -> Char -> Word8
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum)
    instance Convertible Word8 Char where
        safeConvert :: Word8 -> ConvertResult Char
    safeConvert = (Word8 -> ConvertResult Char) -> Word8 -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Word8 -> Char) -> Word8 -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Word8 -> Int) -> Word8 -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word8 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Char Word16 where
        safeConvert :: Char -> ConvertResult Word16
    safeConvert = (Char -> ConvertResult Word16) -> Char -> ConvertResult Word16
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word16 -> ConvertResult Word16
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word16 -> ConvertResult Word16)
    -> (Char -> Word16) -> Char -> ConvertResult Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Word16
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word16) -> (Char -> Int) -> Char -> Word16
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum)
    instance Convertible Word16 Char where
        safeConvert :: Word16 -> ConvertResult Char
    safeConvert = (Word16 -> ConvertResult Char) -> Word16 -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Word16 -> Char) -> Word16 -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Word16 -> Int) -> Word16 -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word16 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Char Word32 where
        safeConvert :: Char -> ConvertResult Word32
    safeConvert = (Char -> ConvertResult Word32) -> Char -> ConvertResult Word32
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word32 -> ConvertResult Word32
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word32 -> ConvertResult Word32)
    -> (Char -> Word32) -> Char -> ConvertResult Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Word32
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word32) -> (Char -> Int) -> Char -> Word32
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum)
    instance Convertible Word32 Char where
        safeConvert :: Word32 -> ConvertResult Char
    safeConvert = (Word32 -> ConvertResult Char) -> Word32 -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Word32 -> Char) -> Word32 -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Word32 -> Int) -> Word32 -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word32 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Char Word64 where
        safeConvert :: Char -> ConvertResult Word64
    safeConvert = (Char -> ConvertResult Word64) -> Char -> ConvertResult Word64
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Word64 -> ConvertResult Word64
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Word64 -> ConvertResult Word64)
    -> (Char -> Word64) -> Char -> ConvertResult Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Word64
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral (Int -> Word64) -> (Char -> Int) -> Char -> Word64
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Int
    forall a. Enum a => a -> Int
    fromEnum)
    instance Convertible Word64 Char where
        safeConvert :: Word64 -> ConvertResult Char
    safeConvert = (Word64 -> ConvertResult Char) -> Word64 -> ConvertResult Char
    forall a b.
    (Ord a, Bounded b, Show a, Show b, Convertible a Integer,
     Convertible b Integer, Typeable a, Typeable b) =>
    (a -> ConvertResult b) -> a -> ConvertResult b
    boundedConversion (Char -> ConvertResult Char
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Char -> ConvertResult Char)
    -> (Word64 -> Char) -> Word64 -> ConvertResult Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> Char
    forall a. Enum a => Int -> a
    toEnum (Int -> Char) -> (Word64 -> Int) -> Word64 -> Char
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Word64 -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral)

    instance Convertible Integer Integer where
        safeConvert :: Integer -> ConvertResult Integer
    safeConvert = Integer -> ConvertResult Integer
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Integer -> ConvertResult Integer)
    -> (Integer -> Integer) -> Integer -> ConvertResult Integer
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Integer -> Integer
    forall a. a -> a
    id