Safe Haskell	Safe
Language	Haskell98

Numeric.Decidable.Units

Documentation

class Unital r => DecidableUnits r where #

Minimal complete definition

recipUnit

Methods

recipUnit :: r -> Maybe r #

isUnit :: r -> Bool #

(^?) :: Integral n => r -> n -> Maybe r #

Instances

DecidableUnits Bool #
Methods recipUnit :: Bool -> Maybe Bool # isUnit :: Bool -> Bool # (^?) :: Integral n => Bool -> n -> Maybe Bool #
DecidableUnits Int #
Methods recipUnit :: Int -> Maybe Int # isUnit :: Int -> Bool # (^?) :: Integral n => Int -> n -> Maybe Int #
DecidableUnits Int8 #
Methods recipUnit :: Int8 -> Maybe Int8 # isUnit :: Int8 -> Bool # (^?) :: Integral n => Int8 -> n -> Maybe Int8 #
DecidableUnits Int16 #
Methods recipUnit :: Int16 -> Maybe Int16 # isUnit :: Int16 -> Bool # (^?) :: Integral n => Int16 -> n -> Maybe Int16 #
DecidableUnits Int32 #
Methods recipUnit :: Int32 -> Maybe Int32 # isUnit :: Int32 -> Bool # (^?) :: Integral n => Int32 -> n -> Maybe Int32 #
DecidableUnits Int64 #
Methods recipUnit :: Int64 -> Maybe Int64 # isUnit :: Int64 -> Bool # (^?) :: Integral n => Int64 -> n -> Maybe Int64 #
DecidableUnits Integer #
Methods recipUnit :: Integer -> Maybe Integer # isUnit :: Integer -> Bool # (^?) :: Integral n => Integer -> n -> Maybe Integer #
DecidableUnits Natural #
Methods recipUnit :: Natural -> Maybe Natural # isUnit :: Natural -> Bool # (^?) :: Integral n => Natural -> n -> Maybe Natural #
DecidableUnits Word #
Methods recipUnit :: Word -> Maybe Word # isUnit :: Word -> Bool # (^?) :: Integral n => Word -> n -> Maybe Word #
DecidableUnits Word8 #
Methods recipUnit :: Word8 -> Maybe Word8 # isUnit :: Word8 -> Bool # (^?) :: Integral n => Word8 -> n -> Maybe Word8 #
DecidableUnits Word16 #
Methods recipUnit :: Word16 -> Maybe Word16 # isUnit :: Word16 -> Bool # (^?) :: Integral n => Word16 -> n -> Maybe Word16 #
DecidableUnits Word32 #
Methods recipUnit :: Word32 -> Maybe Word32 # isUnit :: Word32 -> Bool # (^?) :: Integral n => Word32 -> n -> Maybe Word32 #
DecidableUnits Word64 #
Methods recipUnit :: Word64 -> Maybe Word64 # isUnit :: Word64 -> Bool # (^?) :: Integral n => Word64 -> n -> Maybe Word64 #
DecidableUnits () #
Methods recipUnit :: () -> Maybe () # isUnit :: () -> Bool # (^?) :: Integral n => () -> n -> Maybe () #
DecidableUnits r => DecidableUnits (Opposite r) #
Methods recipUnit :: Opposite r -> Maybe (Opposite r) # isUnit :: Opposite r -> Bool # (^?) :: Integral n => Opposite r -> n -> Maybe (Opposite r) #
DecidableUnits (BasisCoblade m) #
Methods recipUnit :: BasisCoblade m -> Maybe (BasisCoblade m) # isUnit :: BasisCoblade m -> Bool # (^?) :: Integral n => BasisCoblade m -> n -> Maybe (BasisCoblade m) #
GCDDomain d => DecidableUnits (Fraction d) #
Methods recipUnit :: Fraction d -> Maybe (Fraction d) # isUnit :: Fraction d -> Bool # (^?) :: Integral n => Fraction d -> n -> Maybe (Fraction d) #
(DecidableUnits a, DecidableUnits b) => DecidableUnits (a, b) #
Methods recipUnit :: (a, b) -> Maybe (a, b) # isUnit :: (a, b) -> Bool # (^?) :: Integral n => (a, b) -> n -> Maybe (a, b) #
(DecidableUnits a, DecidableUnits b, DecidableUnits c) => DecidableUnits (a, b, c) #
Methods recipUnit :: (a, b, c) -> Maybe (a, b, c) # isUnit :: (a, b, c) -> Bool # (^?) :: Integral n => (a, b, c) -> n -> Maybe (a, b, c) #
(DecidableUnits a, DecidableUnits b, DecidableUnits c, DecidableUnits d) => DecidableUnits (a, b, c, d) #
Methods recipUnit :: (a, b, c, d) -> Maybe (a, b, c, d) # isUnit :: (a, b, c, d) -> Bool # (^?) :: Integral n => (a, b, c, d) -> n -> Maybe (a, b, c, d) #
(DecidableUnits a, DecidableUnits b, DecidableUnits c, DecidableUnits d, DecidableUnits e) => DecidableUnits (a, b, c, d, e) #
Methods recipUnit :: (a, b, c, d, e) -> Maybe (a, b, c, d, e) # isUnit :: (a, b, c, d, e) -> Bool # (^?) :: Integral n => (a, b, c, d, e) -> n -> Maybe (a, b, c, d, e) #

recipUnitIntegral :: Integral r => r -> Maybe r #

recipUnitWhole :: Integral r => r -> Maybe r #