Safe Haskell	Safe-Inferred
Language	GHC2021

NumHask.Data.Positive

Description

A positive number type, defined as existing on [zero, +infinity)

Synopsis

newtype Positive a = UnsafePositive {
- unPositive :: a
}
positive :: (Additive a, MeetSemiLattice a) => a -> Positive a
maybePositive :: (Additive a, MeetSemiLattice a) => a -> Maybe (Positive a)
positive_ :: a -> Positive a
class Monus a where
- (∸) :: a -> a -> a
class Addus a where
- (∔) :: a -> a -> a
type MonusSemiField a = (Monus a, Distributive a, Divisive a)

Documentation

newtype Positive a Source #

A positive number is a number that is contained in [zero,+infinity).

>>> 1 :: Positive Int
UnsafePositive {unPositive = 1}

>>> -1 :: Positive Int
...
    • No instance for ‘Subtractive (Positive Int)’
        arising from a use of syntactic negation
...

zero is positive

>>> positive 0 == zero
True

The main constructors:

>>> positive (-1)
UnsafePositive {unPositive = 0}

>>> maybePositive (-1)
Nothing

>>> UnsafePositive (-1)
UnsafePositive {unPositive = -1}

Constructors

UnsafePositive
Fields unPositive :: a

Instances

Instances details

Show a => Show (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods showsPrec :: Int -> Positive a -> ShowS # show :: Positive a -> String # showList :: [Positive a] -> ShowS #
Eq a => Eq (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (==) :: Positive a -> Positive a -> Bool # (/=) :: Positive a -> Positive a -> Bool #
Ord a => Ord (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods compare :: Positive a -> Positive a -> Ordering # (<) :: Positive a -> Positive a -> Bool # (<=) :: Positive a -> Positive a -> Bool # (>) :: Positive a -> Positive a -> Bool # (>=) :: Positive a -> Positive a -> Bool # max :: Positive a -> Positive a -> Positive a # min :: Positive a -> Positive a -> Positive a #
AdditiveAction a => AdditiveAction (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Associated Types type AdditiveScalar (Positive a) Source # Methods (\|+) :: Positive a -> AdditiveScalar (Positive a) -> Positive a Source #
DivisiveAction a => DivisiveAction (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (\|/) :: Positive a -> Scalar (Positive a) -> Positive a Source #
MultiplicativeAction a => MultiplicativeAction (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Associated Types type Scalar (Positive a) Source # Methods (\|*) :: Positive a -> Scalar (Positive a) -> Positive a Source #
SubtractiveAction a => SubtractiveAction (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (\|-) :: Positive a -> AdditiveScalar (Positive a) -> Positive a Source #
Additive a => Additive (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (+) :: Positive a -> Positive a -> Positive a Source # zero :: Positive a Source #
QuotientField (Positive Double) Source #
Instance details Defined in NumHask.Data.Positive Associated Types type Whole (Positive Double) Source # Methods properFraction :: Positive Double -> (Whole (Positive Double), Positive Double) Source # round :: Positive Double -> Whole (Positive Double) Source # ceiling :: Positive Double -> Whole (Positive Double) Source # floor :: Positive Double -> Whole (Positive Double) Source # truncate :: Positive Double -> Whole (Positive Double) Source #
(Additive a, JoinSemiLattice a) => BoundedJoinSemiLattice (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods bottom :: Positive a Source #
BoundedMeetSemiLattice a => BoundedMeetSemiLattice (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods top :: Positive a Source #
JoinSemiLattice a => JoinSemiLattice (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (\/) :: Positive a -> Positive a -> Positive a Source #
MeetSemiLattice a => MeetSemiLattice (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (/\) :: Positive a -> Positive a -> Positive a Source #
Basis a => Basis (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Associated Types type Mag (Positive a) Source # type Base (Positive a) Source # Methods magnitude :: Positive a -> Mag (Positive a) Source # basis :: Positive a -> Base (Positive a) Source #
Direction a => Direction (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Associated Types type Dir (Positive a) Source # Methods angle :: Positive a -> Dir (Positive a) Source # ray :: Dir (Positive a) -> Positive a Source #
Epsilon a => Epsilon (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods epsilon :: Positive a Source #
Divisive a => Divisive (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods recip :: Positive a -> Positive a Source # (/) :: Positive a -> Positive a -> Positive a Source #
Multiplicative a => Multiplicative (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (*) :: Positive a -> Positive a -> Positive a Source # one :: Positive a Source #
FromInteger a => FromInteger (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods fromInteger :: Integer -> Positive a Source #
Integral a => Integral (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods div :: Positive a -> Positive a -> Positive a Source # mod :: Positive a -> Positive a -> Positive a Source # divMod :: Positive a -> Positive a -> (Positive a, Positive a) Source # quot :: Positive a -> Positive a -> Positive a Source # rem :: Positive a -> Positive a -> Positive a Source # quotRem :: Positive a -> Positive a -> (Positive a, Positive a) Source #
(Subtractive a, MeetSemiLattice a) => Monus (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (∸) :: Positive a -> Positive a -> Positive a Source #
FromRational a => FromRational (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods fromRational :: Rational -> Positive a Source #
(MeetSemiLattice a, Integral a) => FromIntegral (Positive a) a Source #
Instance details Defined in NumHask.Data.Positive Methods fromIntegral :: a -> Positive a Source #
FromIntegral a b => FromIntegral (Positive a) b Source #
Instance details Defined in NumHask.Data.Positive Methods fromIntegral :: b -> Positive a Source #
ToIntegral a b => ToIntegral (Positive a) b Source #
Instance details Defined in NumHask.Data.Positive Methods toIntegral :: Positive a -> b Source #
FromRatio a b => FromRatio (Positive a) b Source #
Instance details Defined in NumHask.Data.Positive Methods fromRatio :: Ratio b -> Positive a Source #
ToRatio a b => ToRatio (Positive a) b Source #
Instance details Defined in NumHask.Data.Positive Methods toRatio :: Positive a -> Ratio b Source #
type AdditiveScalar (Positive a) Source #
Instance details Defined in NumHask.Data.Positive type AdditiveScalar (Positive a) = AdditiveScalar (Wrapped a)
type Scalar (Positive a) Source #
Instance details Defined in NumHask.Data.Positive type Scalar (Positive a) = Scalar (Wrapped a)
type Whole (Positive Double) Source #
Instance details Defined in NumHask.Data.Positive type Whole (Positive Double) = Positive Int
type Base (Positive a) Source #
Instance details Defined in NumHask.Data.Positive type Base (Positive a) = Base (Wrapped a)
type Dir (Positive a) Source #
Instance details Defined in NumHask.Data.Positive type Dir (Positive a) = Dir (Wrapped a)
type Mag (Positive a) Source #
Instance details Defined in NumHask.Data.Positive type Mag (Positive a) = Mag (Wrapped a)

positive :: (Additive a, MeetSemiLattice a) => a -> Positive a Source #

Constructor which returns zero for a negative number.

>>> positive (-1)
UnsafePositive {unPositive = 0}

maybePositive :: (Additive a, MeetSemiLattice a) => a -> Maybe (Positive a) Source #

Constructor which returns Nothing if a negative number is supplied.

>>> maybePositive (-one)
Nothing

positive_ :: a -> Positive a Source #

Unsafe constructor.

>>> positive_ (-one)
UnsafePositive {unPositive = -1}

class Monus a where Source #

Monus or truncated subtraction.

>>> positive 4 ∸ positive 7
UnsafePositive {unPositive = 0}

>>> 4 ∸ 7 :: Positive Int
UnsafePositive {unPositive = 0}

Since: 0.12

Minimal complete definition

(∸)

Methods

(∸) :: a -> a -> a infixl 6 Source #

default (∸) :: (BoundedJoinSemiLattice a, MeetSemiLattice a, Subtractive a) => a -> a -> a Source #

Instances

Instances details

(Subtractive a, MeetSemiLattice a) => Monus (Positive a) Source #
Instance details Defined in NumHask.Data.Positive Methods (∸) :: Positive a -> Positive a -> Positive a Source #

class Addus a where Source #

Truncated addition

Since: 0.12

Minimal complete definition

(∔)

Methods

(∔) :: a -> a -> a infixl 6 Source #

default (∔) :: (BoundedMeetSemiLattice a, JoinSemiLattice a, Additive a) => a -> a -> a Source #

type MonusSemiField a = (Monus a, Distributive a, Divisive a) Source #

A field but with truncated subtraction.