h$dN      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                    None;numhaskor )https://en.wikipedia.org/wiki/Subtraction Subtraction\a -> a - a == zero\a -> negate a == zero - a\a -> negate a + a == zero\a -> a + negate a == zeronegate 1-11 - 2-1numhaskor &https://en.wikipedia.org/wiki/AdditionAddition4For practical reasons, we begin the class tree with . Starting with  and  , or using  and  from base tends to confuse the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication.\a -> zero + a == a\a -> a + zero == a$\a b c -> (a + b) + c == a + (b + c)\a b -> a + b == b + aBy convention, (+) is regarded as commutative, but this is not universal, and the introduction of another symbol which means non-commutative addition seems a bit dogmatic.zero + 111 + 12numhaskCompute the sum of a .66 Safe-Inferred> numhaskAn  +https://en.wikipedia.org/wiki/Abelian_group Abelian Group is an Associative, Unital, Invertible and Commutative Magma . In other words, it is a Commutative Groupnumhask9An Idempotent Magma is a magma where every element is  )https://en.wikipedia.org/wiki/Idempotence Idempotent.  a E a = anumhask#An Absorbing is a Magma with an /https://en.wikipedia.org/wiki/Absorbing_elementAbsorbing Element a E absorb = absorbnumhaskA  1https://en.wikipedia.org/wiki/Group_(mathematics)Group2 is a Associative, Unital and Invertible Magma.numhaskAn Invertible Magma 0D a,b D T: inv a E (a E b) = b = (b E a) E inv anumhask>A Commutative Magma is a Magma where the binary operation is  2https://en.wikipedia.org/wiki/Commutative_property commutative.  a E b = b E anumhaskAn Associative Magma (a E b) E c = a E (b E c)numhask%A Unital Magma is a magma with an  .https://en.wikipedia.org/wiki/Identity_elementidentity element (the unit). unit E a = a a E unit = anumhaskA  -https://en.wikipedia.org/wiki/Magma_(algebra)Magma# is a tuple (T,magma) consisting of a type a, and!a function (magma) :: T -> T -> T&The mathematical laws for a magma are:6magma is defined for all possible pairs of type T, and;magma is closed in the set of all possible values of type Tor, more tersly, D a, b D T: a E b D TThese laws are true by construction in haskell: the type signature of . and the above mathematical laws are synonyms.  3Nonenumhaskor 4https://en.wikipedia.org/wiki/Division_(mathematics)DivisionThough unusual, the term Divisive usefully fits in with the grammer of other classes and avoids name clashes that occur with some popular libraries.+\(a :: Double) -> a / a ~= one || a == zero1\(a :: Double) -> recip a ~= one / a || a == zero1\(a :: Double) -> recip a * a ~= one || a == zero1\(a :: Double) -> a * recip a ~= one || a == zero recip 2.00.51 / 20.5numhaskor ,https://en.wikipedia.org/wiki/MultiplicationMultiplication4For practical reasons, we begin the class tree with  and . Starting with  and  , or using  and  from base tends to confuse the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication.\a -> one * a == a\a -> a * one == a$\a b c -> (a * b) * c == a * (b * c)By convention, (*) is regarded as not necessarily commutative, but this is not universal, and the introduction of another symbol which means commutative multiplication seems a bit dogmatic.one * 222 * 36numhaskCompute the product of a .77None>%numhaskInvolutive Ring adj (a + b) ==> adj a + adj b adj (a * b) ==> adj a * adj b adj one ==> one adj (adj a) ==> aNote: elements for which  adj a == a are called "self-adjoint".numhaskA  ,https://en.wikipedia.org/wiki/Kleene_algebraKleene Algebra- is a Star Semiring with idempotent addition. a * x + x = a ==> star a * x + x = x x * a + x = a ==> x * star a + x = xnumhaskA  5https://en.wikipedia.org/wiki/Semiring#Star_semirings StarSemiring is a semiring with an additional unary operator (star) satisfying: \a -> star a = one + a * star anumhaskA  0https://en.wikipedia.org/wiki/Ring_(mathematics)Ring% is an abelian group under addition (, , , %) and monoidal under multiplication (, 6), and where multiplication distributes over addition.\a -> zero + a == a\a -> a + zero == a$\a b c -> (a + b) + c == a + (b + c)\a b -> a + b == b + a\a -> a - a == zero\a -> negate a == zero - a\a -> negate a + a == zero\a -> a + negate a == zero\a -> one * a == a\a -> a * one == a$\a b c -> (a * b) * c == a * (b * c)&\a b c -> a * (b + c) == a * b + a * c&\a b c -> (a + b) * c == a * c + b * c\a -> zero * a == zero\a -> a * zero == zeronumhask 3https://en.wikipedia.org/wiki/Distributive_property Distributive&\a b c -> a * (b + c) == a * b + a * c&\a b c -> (a + b) * c == a * c + b * c\a -> zero * a == zero\a -> a * zero == zeroThe sneaking in of the  /https://en.wikipedia.org/wiki/Absorbing_element Absorption laws here glosses over the possibility that the multiplicative zero element does not have to correspond with the additive unital zero.numhask Defining  requires adding the multiplicative unital to itself. In other words, the concept of  is a Ring one.two2  None,'%numhaskA 2https://en.wikipedia.org/wiki/Module_(mathematics)Module a .* one == a (a + b) .* c == (a .* c) + (b .* c) c *. (a + b) == (c *. a) + (c *. b) a .* zero == zero a .* b == b *. anumhaskDivisive ActionnumhaskMultiplicative ActionnumhaskSubtractive ActionnumhaskAdditive Action  77776666 None ,-9>?,numhask is special in two ways:numeric integral literals (like "42") are interpreted specifically as "fromInteger (42 :: GHC.Num.Integer)". The prelude version is used as default (or whatever fromInteger is in scope if RebindableSyntax is set).The default rules in  https://www.haskell.org/onlinereport/haskell2010/haskellch4.html#x10-750004.3 haskell2010 specify that constraints on  need to be in a form C v(, where v is a Num or a subclass of Num.So a type synonym of `type FromInteger a = FromIntegral a Integer` doesn't work well with type defaulting; hence the need for a separate class.numhask"Polymorphic version of fromInteger fromIntegral a == anumhasktoIntegral is kept separate from Integral to help with compatability issues. toIntegral a == anumhask/An Integral is anything that satisfies the law: /b == zero || b * (a `div` b) + (a `mod` b) == anumhaskeven 2Truenumhaskodd 3Truenumhaskraise a number to an  powernumhaskraise a number to an 9 powerNote: This differs from (^) found in prelude which is a partial function (it errors on negative integrals). This monomorphic version is provided to help reduce ambiguous type noise in common usages of this sign.7788 None 9>?3numhaskTrigonometric FieldnumhaskNegative infinity.numhask7numhask,A meet-semilattice with an identity element  for . Identity: x /\ top == xnumhask,A join-semilattice with an identity element  for . Identity: x \/ bottom == xnumhask.A algebraic structure with element meets: See (http://en.wikipedia.org/wiki/Semilattice Semilattice Associativity: x /\ (y /\ z) == (x /\ y) /\ z Commutativity: x /\ y == y /\ x Idempotency: x /\ x == xnumhask.A algebraic structure with element joins: See (http://en.wikipedia.org/wiki/Semilattice Semilattice Associativity: x \/ (y \/ z) == (x \/ y) \/ z Commutativity: x \/ y == y \/ x Idempotency: x \/ x == xnumhask>The partial ordering induced by the join-semilattice structurenumhask>The partial ordering induced by the meet-semilattice structure  65 None8>=numhask;A small number, especially useful for approximate equality.numhask/Something that has a magnitude and a direction.numhaskConvert between a "co-ordinated" or "higher-kinded" number and representations of an angle. Typically thought of as polar co-ordinate conversion.See 5https://en.wikipedia.org/wiki/Polar_coordinate_systemPolar coordinate system (ray . angle == basis norm (ray x) == onenumhaskNorm is a slight generalisation of Signed. The class has the same shape but allows the codomain to be different to the domain. norm a >= zero norm zero == zero a == norm a .* basis a norm (basis a) == onenumhaskor length, or ||v||numhaskor direction, or v-hatnumhask from base is not an operator name in numhask and is replaced by . Compare with % where there is a change in codomain. abs a * sign a == aabs zero == zero, so any value for sign zero is ok. We choose lawful neutral: sign zero == zeronumhaskDistance, which combines the Subtractive notion of difference, with Norm. distance a b >= zero distance a a == zero distance a b .* basis (a - b) == a - bnumhask!Convert from a number to a Polar.numhaskConvert from a Polar to a (coordinated aka higher-kinded) number.numhask About equal.numhask0numhask1e-6numhask1e-144 None ,35678>?numhask.Complex numbers have real and imaginary parts.The  and ( instances traverse the real part first.numhaskforms a complex number from its real and imaginary rectangular components.numhask+Extracts the real part of a complex number.numhask0Extracts the imaginary part of a complex number.numhask8A euclidean-style norm is strong convention for Complex.6None,-9>?Fnumhask$fromRational is special in two ways:numeric decimal literals (like "53.66") are interpreted as exactly "fromRational (53.66 :: GHC.Real.Ratio Integer)". The prelude version, GHC.Real.fromRational is used as default (or whatever is in scope if RebindableSyntax is set).The default rules in  https://www.haskell.org/onlinereport/haskell2010/haskellch4.html#x10-750004.3 haskell2010 specify that contraints on  need to be in a form C v(, where v is a Num or a subclass of Num.So a type synonym of `type FromRational a = FromRatio a Integer` doesn't work well with type defaulting; hence the need for a separate class.numhask%( in base splits into fromRatio and Field-fromRatio (5 :% 2 :: Ratio Integer) :: Double2.5numhasktoRatio is equivalent to +2 in base, but is polymorphic in the Integral type. -toRatio (3.1415927 :: Float) :: Ratio Integer13176795 :% 4194304numhaskA rational numbernumhask normalises a ratio by dividing both numerator and denominator by their greatest common divisor.numhask x y$ is the non-negative factor of both x and y" of which every common factor of x and y is also a factor; for example  4 2 = 2,  (-4) 6 = 2,  0 4 = 4.  0 0 = 0. (That is, the common divisor that is "greatest" in the divisibility preordering.)2Note: Since for signed fixed-width integer types,   < 09, the result may be negative if one of the arguments is & (and necessarily is if the other is 0 or ) for such types. > > Safe-InferredGnumhaskA numhask exception.__None,G>>_None,HnumhaskRebindableSyntax splats this, and I'm not sure where it exists in GHC land !" #$%&'()*+,-./0 1~|yvtu{zx}w2KMNL345BE6789:;?@AGFOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrs; !" #$%&'()*+,-./0 1vtu{zx}w2KMNL345BE6789:?@AGFOPQRSTUVWXYZ[\]^adefghilo1~vtu{z|xy}w`abcdefghijklmnopqrs !"#"$%&'(')*+,-./01213456789:;<=>?>@ABCDEFGHIJK1LMN<OPQRS1TUV<WMX<YZ[8\]^_^`^a^b^cdefEghi^j<k^l^mno^phqhr^sntnu^v^w^xyz{|%}%~%%%%%%%%%%nUUUUMMMMMMMMMMMMM<ZZZZZZZZ"""""""""""""""""""""""""""''RE1111111111                                                                                                                                                                                                                                                                                                                                                    ^^&numhask-0.8.0.0-Dcbjr3MqgLHJ8HTtoBvzgzNumHask.PreludeNumHask.Data.RationalNumHask.ExceptionNumHask.Algebra.AdditiveNumHask.Algebra.GroupNumHask.Algebra.MultiplicativeNumHask.Algebra.RingNumHask.Algebra.ModuleNumHask.Data.IntegralNumHask.Algebra.FieldNumHask.Algebra.LatticeNumHask.Algebra.MetricNumHask.Data.Complex AssociativeUnitalData.Semigroup Semigroup Data.MonoidMonoid Data.FoldableFoldableAdditiveData.Traversable TraversableGHC.EnumminBoundNumHaskbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$enumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=>>=>>fmapreturnControl.Monad.Failfail Data.String fromStringGHC.Real realToFracGHC.ExtsfromList fromListN<>memptymappendmconcat GHC.NaturalNatS#<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalMonadFunctorGHC.NumNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShow MonadFail Applicative GHC.TypesBoolCharDoubleFloatIntinteger-wired-inGHC.Integer.TypeIntegerNatural GHC.MaybeMaybeOrderingRationalIOWord Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGTsequencemapM sequenceAtraversereadIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputCharGHC.IO.ExceptionioErrorGHC.IOFilePath userErrorIOError GHC.ExceptionthrowfindnotElem minimumBy maximumByallanyorand concatMapconcatmsumasum sequence_ sequenceA_forM_mapM_for_ traverse_foldlMfoldrMminimummaximumelemlengthnulltoListfoldl1foldr1foldl'foldlfoldr'foldrfoldMap'foldMapfold Data.OldListunwordswordsunlineslines Text.Readreadreadseitherlex readParenreadList readsPrecText.ParserCombinators.ReadPReadSisIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadixlcmmaxBoundfromEnumtoEnumpredsucc showParen showStringshowCharshowsShowSshowListshow showsPrecunzip3unzipzipWith3zipWithzip3!!lookupreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanlinitlasttailhead Data.Maybemaybe Data.Functor<$>uncurrycurrysignumasTypeOfuntil$!flip.constid=<<<$<*StringGHC.Err undefinederrorWithoutStackTraceerrorNatJ#compare<<=>maxmin/=&&||not Subtractivenegate-+zerosum $fAdditive->$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveWord$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8$fAdditiveNatural$fAdditiveBool$fAdditiveInteger $fAdditiveInt$fAdditiveFloat$fAdditiveDouble$fSubtractive->$fSubtractiveWord64$fSubtractiveWord32$fSubtractiveWord16$fSubtractiveWord8$fSubtractiveWord$fSubtractiveInt64$fSubtractiveInt32$fSubtractiveInt16$fSubtractiveInt8$fSubtractiveNatural$fSubtractiveBool$fSubtractiveInteger$fSubtractiveInt$fSubtractiveFloat$fSubtractiveDouble AbelianGroup Idempotent AbsorbingabsorbGroup Invertibleinv CommutativeunitMagma⊕ $fMagma-> $fUnital->$fAssociative->$fCommutative->$fInvertible->$fGroupa $fAbsorbing->$fIdempotent->$fAbelianGroupaDivisiverecip/Multiplicative*oneproduct$fMultiplicative->$fMultiplicativeWord64$fMultiplicativeWord32$fMultiplicativeWord16$fMultiplicativeWord8$fMultiplicativeWord$fMultiplicativeInt64$fMultiplicativeInt32$fMultiplicativeInt16$fMultiplicativeInt8$fMultiplicativeNatural$fMultiplicativeBool$fMultiplicativeInteger$fMultiplicativeInt$fMultiplicativeFloat$fMultiplicativeDouble $fDivisive->$fDivisiveFloat$fDivisiveDoubleInvolutiveRingadj KleeneAlgebra StarSemiringstarplusRing Distributivetwo$fDistributive->$fDistributiveBool$fDistributiveWord64$fDistributiveWord32$fDistributiveWord16$fDistributiveWord8$fDistributiveWord$fDistributiveInt64$fDistributiveInt32$fDistributiveInt16$fDistributiveInt8$fDistributiveNatural$fDistributiveInteger$fDistributiveInt$fDistributiveFloat$fDistributiveDouble$fRinga$fStarSemiring->$fKleeneAlgebra->$fInvolutiveRing->$fInvolutiveRingWord64$fInvolutiveRingWord32$fInvolutiveRingWord16$fInvolutiveRingWord8$fInvolutiveRingWord$fInvolutiveRingInt64$fInvolutiveRingInt32$fInvolutiveRingInt16$fInvolutiveRingInt8$fInvolutiveRingNatural$fInvolutiveRingInt$fInvolutiveRingInteger$fInvolutiveRingFloat$fInvolutiveRingDoubleModuleDivisiveAction.//.MultiplicativeAction.**.SubtractiveAction.--.AdditiveAction.++. FromInteger fromInteger FromIntegral fromIntegral ToIntegral toIntegralIntegraldivmoddivModquotremquotRemevenodd^^^ $fIntegral->$fIntegralWord64$fIntegralWord32$fIntegralWord16$fIntegralWord8$fIntegralWord$fIntegralInt64$fIntegralInt32$fIntegralInt16$fIntegralInt8$fIntegralNatural$fIntegralInteger $fIntegralInt$fToIntegralWord64Word64$fToIntegralWord32Word32$fToIntegralWord16Word16$fToIntegralWord8Word8$fToIntegralWordWord$fToIntegralInt64Int64$fToIntegralInt32Int32$fToIntegralInt16Int16$fToIntegralInt8Int8$fToIntegralNaturalNatural$fToIntegralWord64Int$fToIntegralWord32Int$fToIntegralWord16Int$fToIntegralWord8Int$fToIntegralWordInt$fToIntegralInt64Int$fToIntegralInt32Int$fToIntegralInt16Int$fToIntegralInt8Int$fToIntegralNaturalInt$fToIntegralIntegerInt$fToIntegralIntInt$fToIntegralWord64Integer$fToIntegralWord32Integer$fToIntegralWord16Integer$fToIntegralWord8Integer$fToIntegralWordInteger$fToIntegralInt64Integer$fToIntegralInt32Integer$fToIntegralInt16Integer$fToIntegralInt8Integer$fToIntegralNaturalInteger$fToIntegralIntInteger$fToIntegralIntegerInteger$fFromIntegralWord64Word64$fFromIntegralWord32Word32$fFromIntegralWord16Word16$fFromIntegralWord8Word8$fFromIntegralWordWord$fFromIntegralInt64Int64$fFromIntegralInt32Int32$fFromIntegralInt16Int16$fFromIntegralInt8Int8$fFromIntegralNaturalNatural$fFromIntegralWord64Int$fFromIntegralWord32Int$fFromIntegralWord16Int$fFromIntegralWord8Int$fFromIntegralWordInt$fFromIntegralInt64Int$fFromIntegralInt32Int$fFromIntegralInt16Int$fFromIntegralInt8Int$fFromIntegralNaturalInt$fFromIntegralIntegerInt$fFromIntegralIntInt$fFromIntegralFloatInt$fFromIntegralDoubleInt$fFromIntegralWord64Integer$fFromIntegralWord32Integer$fFromIntegralWord16Integer$fFromIntegralWord8Integer$fFromIntegralWordInteger$fFromIntegralInt64Integer$fFromIntegralInt32Integer$fFromIntegralInt16Integer$fFromIntegralInt8Integer$fFromIntegralNaturalInteger$fFromIntegralIntegerInteger$fFromIntegralIntInteger$fFromIntegralFloatInteger$fFromIntegralDoubleInteger$fFromIntegral->b$fFromIntegerWord64$fFromIntegerWord32$fFromIntegerWord16$fFromIntegerWord8$fFromIntegerWord$fFromIntegerInt64$fFromIntegerInt32$fFromIntegerInt16$fFromIntegerInt8$fFromIntegerNatural$fFromIntegerInteger$fFromIntegerInt$fFromIntegerFloat$fFromIntegerDouble TrigFieldpisincostanasinacosatanatan2sinhcoshtanhasinhacoshatanhLowerBoundedField negInfinityUpperBoundedFieldinfinitynan QuotientFieldproperFractionroundceilingfloortruncateExpFieldexploglogBase**sqrtFieldhalf $fField-> $fFieldFloat $fFieldDouble $fExpField->$fExpFieldFloat$fExpFieldDouble$fQuotientField->->$fQuotientFieldDoubleInt$fQuotientFieldFloatInt$fQuotientFieldDoubleInteger$fQuotientFieldFloatInteger$fUpperBoundedField->$fUpperBoundedFieldDouble$fUpperBoundedFieldFloat$fLowerBoundedField->$fLowerBoundedFieldDouble$fLowerBoundedFieldFloat $fTrigField->$fTrigFieldFloat$fTrigFieldDoubleBoundedMeetSemiLatticetopBoundedJoinSemiLatticebottomMeetSemiLattice/\JoinSemiLattice\/joinLeqmeetLeq$fJoinSemiLattice->$fJoinSemiLatticeWord64$fJoinSemiLatticeWord32$fJoinSemiLatticeWord16$fJoinSemiLatticeWord8$fJoinSemiLatticeWord$fJoinSemiLatticeInt64$fJoinSemiLatticeInt32$fJoinSemiLatticeInt16$fJoinSemiLatticeInt8$fJoinSemiLatticeNatural$fJoinSemiLatticeBool$fJoinSemiLatticeInteger$fJoinSemiLatticeInt$fJoinSemiLatticeDouble$fJoinSemiLatticeFloat$fMeetSemiLattice->$fMeetSemiLatticeWord64$fMeetSemiLatticeWord32$fMeetSemiLatticeWord16$fMeetSemiLatticeWord8$fMeetSemiLatticeWord$fMeetSemiLatticeInt64$fMeetSemiLatticeInt32$fMeetSemiLatticeInt16$fMeetSemiLatticeInt8$fMeetSemiLatticeNatural$fMeetSemiLatticeBool$fMeetSemiLatticeInteger$fMeetSemiLatticeInt$fMeetSemiLatticeDouble$fMeetSemiLatticeFloat $fLatticea$fBoundedJoinSemiLattice->$fBoundedJoinSemiLatticeWord64$fBoundedJoinSemiLatticeWord32$fBoundedJoinSemiLatticeWord16$fBoundedJoinSemiLatticeWord8$fBoundedJoinSemiLatticeWord$fBoundedJoinSemiLatticeInt64$fBoundedJoinSemiLatticeInt32$fBoundedJoinSemiLatticeInt16$fBoundedJoinSemiLatticeInt8$fBoundedJoinSemiLatticeNatural$fBoundedJoinSemiLatticeBool$fBoundedJoinSemiLatticeInt$fBoundedJoinSemiLatticeDouble$fBoundedJoinSemiLatticeFloat$fBoundedMeetSemiLattice->$fBoundedMeetSemiLatticeWord64$fBoundedMeetSemiLatticeWord32$fBoundedMeetSemiLatticeWord16$fBoundedMeetSemiLatticeWord8$fBoundedMeetSemiLatticeWord$fBoundedMeetSemiLatticeInt64$fBoundedMeetSemiLatticeInt32$fBoundedMeetSemiLatticeInt16$fBoundedMeetSemiLatticeInt8$fBoundedMeetSemiLatticeBool$fBoundedMeetSemiLatticeInt$fBoundedMeetSemiLatticeDouble$fBoundedMeetSemiLatticeFloat$fBoundedLatticeaEpsilonepsilonnearZero aboutEqualPolar magnitude direction DirectionanglerayNormnormbasisSignedsignabsdistancepolarcoord~=$fSignedWord64$fSignedWord32$fSignedWord16 $fSignedWord8 $fSignedWord $fSignedInt64 $fSignedInt32 $fSignedInt16 $fSignedInt8$fSignedNatural$fSignedInteger $fSignedInt $fSignedFloat$fSignedDouble$fNormWord64Word64$fNormWord32Word32$fNormWord16Word16$fNormWord8Word8$fNormWordWord$fNormInt64Int64$fNormInt32Int32$fNormInt16Int16$fNormInt8Int8$fNormNaturalNatural$fNormIntegerInteger $fNormIntInt$fNormFloatFloat$fNormDoubleDouble$fEpsilonWord64$fEpsilonWord32$fEpsilonWord16$fEpsilonWord8 $fEpsilonWord$fEpsilonInt64$fEpsilonInt32$fEpsilonInt16 $fEpsilonInt8$fEpsilonInteger $fEpsilonInt$fEpsilonFloat$fEpsilonDouble $fEqPolar $fShowPolar$fGenericPolarComplex:+realPartimagPart$fBoundedMeetSemiLatticeComplex$fBoundedJoinSemiLatticeComplex$fMeetSemiLatticeComplex$fJoinSemiLatticeComplex$fLowerBoundedFieldComplex$fUpperBoundedFieldComplex$fInvolutiveRingComplex$fExpFieldComplex$fFieldComplex$fEpsilonComplex$fDirectionComplexa$fNormComplexa$fFromIntegralComplexb$fDivisiveComplex$fMultiplicativeComplex$fDistributiveComplex$fSubtractiveComplex$fAdditiveComplex $fEqComplex $fShowComplex $fReadComplex $fDataComplex$fGenericComplex$fGeneric1TYPEComplex$fFunctorComplex$fFoldableComplex$fTraversableComplex FromRational fromRational FromRatio fromRatioToRatiotoRatioRatio:%reducegcd$fFromIntegralRatiob$fEpsilonRatio$fMeetSemiLatticeRatio$fJoinSemiLatticeRatio$fNormRatioRatio $fSignedRatio$fLowerBoundedFieldRatio$fUpperBoundedFieldRatio$fQuotientFieldRatiob $fFieldRatio$fDistributiveRatio$fDivisiveRatio$fMultiplicativeRatio$fSubtractiveRatio$fAdditiveRatio $fOrdRatio $fEqRatio$fToRatioWord64Integer$fToRatioWord32Integer$fToRatioWord16Integer$fToRatioWord8Integer$fToRatioWordInteger$fToRatioInt64Integer$fToRatioInt32Integer$fToRatioInt16Integer$fToRatioInt8Integer$fToRatioNaturalInteger$fToRatioIntegerInteger$fToRatioIntInteger$fToRatioRatioInteger$fToRatioRatioInteger0$fToRatioFloatInteger$fToRatioDoubleInteger$fFromRatioRatioInteger$fFromRatioFloatInteger$fFromRatioDoubleInteger$fFromRationalRatio$fFromRationalFloat$fFromRationalDouble $fShowRatioNumHaskException errorMessage$fExceptionNumHaskException$fShowNumHaskException ifThenElse GHC.GenericsGenerictoRepfromGeneric1to1Rep1from1Datatype isNewtype packageName datatypeName moduleName Constructor conIsRecordconName conFixitySelectorselDecidedStrictnessselSourceStrictnessselNameselSourceUnpackednessstimessconcatType ConstraintV1U1Par1unPar1Rec1unRec1K1unK1M1unM1:+:L1R1:*::.:Comp1unComp1RDCSRec0D1C1S1URecUWordUIntUFloatUDoubleUAddrUCharuAddr#uChar#uDouble#uFloat#uWord#uInt#option mtimesDefaultdiffcycle1MingetMinMaxgetMaxArgArgMinArgMaxFirstgetFirstLastgetLast WrappedMonoid WrapMonoid unwrapMonoidOption getOptionfoldMapDefault fmapDefault mapAccumR mapAccumLforMforData.Semigroup.Internal stimesMonoidstimesIdempotentDualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProductprecFixityPrefixInfixFixityIPrefixIInfixI AssociativityNotAssociativeLeftAssociativeRightAssociativeSourceUnpackednessNoSourceUnpackedness SourceUnpackSourceNoUnpackSourceStrictnessNoSourceStrictness SourceLazy SourceStrictDecidedStrictness DecidedUnpack DecidedLazy DecidedStrictMetaMetaSelMetaDataMetaConsmapMaybe catMaybes listToMaybe maybeToList fromMaybefromJust isNothingisJust Data.BoolboolstimesIdempotentMonoid