Numeric.MixedTypes.Literals

This module defines fixed-type integer and rational literals. This is useful when deriving the type of an expression bottom-up. Eg we would not be able to write 1 < x when the type of < does not force the two sides to be of the same type. We would need to write eg (1::Integer) < x with Prelude's generic literals.

Moreover, convenient conversion functions are provided for the most common numeric types. Thus one can say eg:

• take (int 1)

• integer (length list).

• double 0.5

To avoid integer overflow, no aritmetic operations return Int. Nevertheless, one can usually mix Int with other types in expressions.

Any approximate arithmetic, ie arithmetic involving Doubles, returns values of type Double. Double values cannot be easily converted to exact types such as Rational or Integer so that all such conversions are clearly visible as labelled as inexact.

Fixed-type literals

fromInteger :: Integer -> Integer

Replacement for fromInteger using the RebindableSyntax extension. This version of fromInteger arranges that integer literals are always of type Integer.

fromRational :: Rational -> Rational

Replacement for fromRational using the RebindableSyntax extension. This version of fromRational arranges that rational literals are always of type Rational.

Generalised if-then-else

class HasIfThenElse b t where

Restore if-then-else with RebindableSyntax

Minimal complete definition

ifThenElse

Methods

ifThenElse :: b -> t -> t -> t

Instances

HasIfThenElse Bool t

Methods

ifThenElse :: Bool -> t -> t -> t

Convenient conversions

type CanBeInteger t = ConvertibleExactly t Integer

integer :: CanBeInteger t => t -> Integer

integers :: CanBeInteger t => [t] -> [Integer]

type HasIntegers t = ConvertibleExactly Integer t

fromInteger_ :: HasIntegers t => Integer -> t

type CanBeInt t = ConvertibleExactly t Int

int :: CanBeInt t => t -> Int

ints :: CanBeInt t => [t] -> [Int]

type CanBeRational t = ConvertibleExactly t Rational

rational :: CanBeRational t => t -> Rational

rationals :: CanBeRational t => [t] -> [Rational]

type HasRationals t = ConvertibleExactly Rational t

fromRational_ :: HasRationals t => Rational -> t

type CanBeDouble t = Convertible t Double

double :: CanBeDouble t => t -> Double

doubles :: CanBeDouble t => [t] -> [Double]

class ConvertibleExactly t1 t2 where

Define our own ConvertibleExactly since convertible is too relaxed for us. For example, convertible allows conversion from Rational to Integer, rounding to nearest integer. We prefer to allow only exact conversions.

Methods

safeConvertExactly :: t1 -> ConvertResult t2

safeConvertExactly :: Convertible t1 t2 => t1 -> ConvertResult t2

Instances

ConvertibleExactly Double Double

Methods

safeConvertExactly :: Double -> ConvertResult Double

ConvertibleExactly Int Double

Methods

safeConvertExactly :: Int -> ConvertResult Double

ConvertibleExactly Int Int

Methods

safeConvertExactly :: Int -> ConvertResult Int

ConvertibleExactly Int Integer

Methods

safeConvertExactly :: Int -> ConvertResult Integer

ConvertibleExactly Int Rational

Methods

safeConvertExactly :: Int -> ConvertResult Rational

ConvertibleExactly Integer Double

Methods

safeConvertExactly :: Integer -> ConvertResult Double

ConvertibleExactly Integer Int

Methods

safeConvertExactly :: Integer -> ConvertResult Int

ConvertibleExactly Integer Integer

Methods

safeConvertExactly :: Integer -> ConvertResult Integer

ConvertibleExactly Integer Rational

Methods

safeConvertExactly :: Integer -> ConvertResult Rational

ConvertibleExactly Rational Rational

Methods

safeConvertExactly :: Rational -> ConvertResult Rational

(ConvertibleExactly Bool t0, Monoid es0) => ConvertibleExactly Bool (CollectErrors es0 t0)

Methods

safeConvertExactly :: Bool -> ConvertResult (CollectErrors es0 t0)

(ConvertibleExactly Double t0, Monoid es0) => ConvertibleExactly Double (CollectErrors es0 t0)

Methods

safeConvertExactly :: Double -> ConvertResult (CollectErrors es0 t0)

(ConvertibleExactly Int t0, Monoid es0) => ConvertibleExactly Int (CollectErrors es0 t0)

Methods

safeConvertExactly :: Int -> ConvertResult (CollectErrors es0 t0)

(ConvertibleExactly Integer t0, Monoid es0) => ConvertibleExactly Integer (CollectErrors es0 t0)

Methods

safeConvertExactly :: Integer -> ConvertResult (CollectErrors es0 t0)

(ConvertibleExactly Rational t0, Monoid es0) => ConvertibleExactly Rational (CollectErrors es0 t0)

Methods

safeConvertExactly :: Rational -> ConvertResult (CollectErrors es0 t0)

convertExactly :: ConvertibleExactly t1 t2 => t1 -> t2

convertExactlyTargetSample :: ConvertibleExactly t1 t2 => t2 -> t1 -> t2

type ConvertResult a = Either ConvertError a

The result of a safe conversion via safeConvert.

data ConvertError :: *

How we indicate that there was an error.

Instances

Eq ConvertError

Methods

(==) :: ConvertError -> ConvertError -> Bool

(/=) :: ConvertError -> ConvertError -> Bool

Read ConvertError

Methods

readsPrec :: Int -> ReadS ConvertError

readList :: ReadS [ConvertError]

readPrec :: ReadPrec ConvertError

readListPrec :: ReadPrec [ConvertError]

Show ConvertError

Methods

showsPrec :: Int -> ConvertError -> ShowS

show :: ConvertError -> String

showList :: [ConvertError] -> ShowS

Error ConvertError

Methods

noMsg :: ConvertError

strMsg :: String -> ConvertError

convError :: (Show a, Typeable * a, Typeable * b) => String -> a -> ConvertResult b

Generic list index

(!!) :: CanBeInteger t => [a] -> t -> a

specCanBeInteger :: (CanBeInteger t, Show t, Arbitrary t) => T t -> Spec

HSpec properties that each implementation of CanBeInteger should satisfy.

printArgsIfFails2 :: (Testable prop, Show a, Show b) => String -> (a -> b -> prop) -> a -> b -> Property

Testing support functions

data T t

A runtime representative of type t. Used for specialising polymorphic tests to concrete types.

Constructors

T String

tInt :: T Int

tInteger :: T Integer

tRational :: T Rational

tDouble :: T Double

tBool :: T Bool

tMaybe :: T t -> T (Maybe t)

tMaybeBool :: T (Maybe Bool)

tMaybeMaybeBool :: T (Maybe (Maybe Bool))

Helper functions

convertFirst

Arguments

:: ConvertibleExactly a b

=> (b -> b -> c)

same-type operation

-> a -> b -> c

mixed-type operation

convertSecond

Arguments

:: ConvertibleExactly b a

=> (a -> a -> c)

same-type operation

-> a -> b -> c

mixed-type operation

convertFirstUsing

Arguments

:: (a -> b -> b)

conversion function

-> (b -> b -> c)

same-type operation

-> a -> b -> c

mixed-type operation

convertSecondUsing

Arguments

:: (a -> b -> a)

conversion function

-> (a -> a -> c)

same-type operation

-> a -> b -> c

mixed-type operation