h&q[      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                   Safe-Inferred.Cnumhaskor )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 . sum [0..10]55numhask"Compute the accumulating sum of a .accsum [0..10][0,1,3,6,10,15,21,28,36,45,55]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.  3 Safe-Inferred.tnumhaskor 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 .product [1..5]120numhask&Compute the accumulating product of a .accproduct [1..5][1,2,6,24,120]77 Safe-Inferred.&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   Safe-Inferred.)a 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 Action  m |/ one = mnumhaskMultiplicative Action m |* one = m m |* zero = zeronumhaskSubtractive Action  m |- zero = mnumhaskAdditive Action m |+ zero == mnumhaskflipped additive action (+|) == flip (|+) zero +| m = mnumhask'Subtraction with the scalar on the left *(-|) == (+|) . negate zero -| m = negate mnumhaskflipped multiplicative action 1(*|) == flip (|*) one *| m = one zero *| m = zeronumhaskleft scalar division '(/|) == (*|) . recip one |/ m = recip m7766667  Safe-Inferred./ 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 such as +type FromInteger a = FromIntegral a Integer doesn't work well with type defaulting; hence the need for a separate class.numhaskConvert from an 9numhask"Polymorphic version of fromInteger fromIntegral a == anumhaskConvert to an 9numhasktoIntegral is kept separate from Integral to help with compatability issues. toIntegral a == anumhask/An Integral is anything that satisfies the law:7\a b -> b == zero || b * (a `div` b) + (a `mod` b) == a 3 `divMod` 2(1,1)(-3) `divMod` 2(-2,1)(-3) `quotRem` 2(-1,-1)numhaskeven 2Truenumhaskodd 3Truenumhaskraise a number to an  power2 ^^ 38.0 2 ^^ (-2)0.25numhaskraise a number to an 9 powerNote: This differs from (^) found in prelude which is a partial function (it errors on negative integrals). This is a monomorphic version of ? provided to help reduce ambiguous type noise in common usages.2 ^ 38.02 ^ (-2)0.257788  Safe-Inferred.<9lnumhaskTrigonometric Field The list of laws is quite long: >https://en.wikipedia.org/wiki/List_of_trigonometric_identitiestrigonometric identitiesnumhaskQuotienting of a  into a See 0https://en.wikipedia.org/wiki/Field_of_fractionsField of fractions 3\a -> a - one < floor a <= a <= ceiling a < a + onenumhaskround to the nearest IntExact ties are managed by rounding down ties if the whole component is even.round (1.5 :: Double)2round (2.5 :: Double)2numhask%supply the next upper whole componentceiling (1.001 :: Double)2numhask)supply the previous lower whole componentfloor (1.001 :: Double)1numhask*supply the whole component closest to zerofloor (-1.001 :: Double)-2truncate (-1.001 :: Double)-1numhaskA hyperbolic field class'\a -> a < zero || (sqrt . (**2)) a == a$\a -> a < zero || (log . exp) a ~= a\a b -> (b < zero) || a <= zero || a == 1 || abs (a ** logBase a b - b) < 10 * epsilonnumhasklog to the base of logBase 2 82.9999999999999996numhask square rootsqrt 42.0numhaskA  1https://en.wikipedia.org/wiki/Field_(mathematics)Field is a set on which addition, subtraction, multiplication, and division are defined. It is also assumed that multiplication is distributive over addition.=A summary of the rules inherited from super-classes of Field: zero + a == a a + zero == a ((a + b) + c) (a + (b + c)) a + b == b + a a - a == zero negate a == zero - a negate a + a == zero a + negate a == zero one * a == a a * one == a ((a * b) * c) == (a * (b * c)) (a * (b + c)) == (a * b + a * c) ((a + b) * c) == (a * c + b * c) a * zero == zero zero * a == zero a / a == one || a == zero recip a == one / a || a == zero recip a * a == one || a == zero a * recip a == one || a == zeronumhaskinfinity is defined for any .one / zero + infinityInfinity infinity + 1Infinitynumhasknan is defined as zero/zerobut note the (social) law:nan == zero / zeroFalsenumhasknegative infinitynegInfinity + infinityNaNnumhaskA  is a ; because it requires addition, multiplication and division.half :: Double0.5!!  Safe-Inferred.?. numhaskLattices with both boundsnumhask,A meet-semilattice with an identity element  for . Identity: x /\ top == xnumhask,A join-semilattice with an identity element  for . Identity: x \/ bottom == xnumhaskThe combination of two semi lattices makes a lattice if the absorption law holds: see  +http://en.wikipedia.org/wiki/Absorption_lawAbsorption Law and ,http://en.wikipedia.org/wiki/Lattice_(order)Lattice /Absorption: a \/ (a /\ b) == a /\ (a \/ b) == anumhask.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 join-semilattice structurenumhask>The partial ordering induced by the meet-semilattice structurenumhask>The partial ordering induced by the meet-semilattice structure6566  Safe-Inferred.?IJnumhask&Two dimensional cartesian coordinates.numhask;A small number, especially useful for approximate equality.numhaskSomething that has a magnitude and a direction, with both expressed as the same type.See 5https://en.wikipedia.org/wiki/Polar_coordinate_systemPolar coordinate systemnumhaskConvert between a "co-ordinated" or "higher-kinded" number and a direction. -ray . angle == basis magnitude (ray x) == onenumhaskBasis where the domain, magnitude codomain and basis codomain are the same.numhask7Basis where the domain and basis codomain are the same.numhask;Basis where the domain and magnitude codomain are the same.numhask encapsulates the notion of magnitude (intuitively the quotienting of a higher-kinded number to a scalar one) and the basis on which the magnitude quotienting was performed. An instance needs to satisfy these laws: \a -> magnitude a >= zero \a -> magnitude zero == zero \a -> a == magnitude a *| basis a \a -> magnitude (basis a) == oneThe names chosen are meant to represent the spiritual idea of a basis rather than a specific mathematics. See  4https://en.wikipedia.org/wiki/Basis_(linear_algebra) &  0https://en.wikipedia.org/wiki/Norm_(mathematics)# for some mathematical motivations.magnitude (-0.5 :: Double)0.5basis (-0.5 :: Double)-1.0numhaskor length, or ||v||numhaskor direction, or v-hatnumhaskThe absolute value of a number.\a -> abs a * signum a ~= aabs (-1)1numhaskThe sign of a number. signum (-1)-1abs zero == zero, so any value for  signum zero" is ok. We choose lawful neutral:signum zero == zeroTruenumhaskDistance, which combines the Subtractive notion of difference, with Basis. distance a b >= zero distance a a == zero distance a b *| basis (a - b) == a - bnumhask8Convert a higher-kinded number that has direction, to a numhaskConvert a Polar to a (higher-kinded) number that has a direction.numhaskNote that the constraint is Lattice rather than Ord allowing broader usage.nearZero (epsilon :: Double)True*nearZero (epsilon :: EuclideanPair Double)TruenumhaskApproximate equality#aboutEqual zero (epsilon :: Double)TruenumhaskAbout equal operator."(1.0 + epsilon) ~= (1.0 :: Double)Truenumhask0numhask1e-6numhask1e-144  Safe-Inferred.?K7numhaskThe underlying representation is a newtype-wrapped tuple, compared with the base datatype. This was chosen to facilitate the use of DerivingVia.numhaskComplex number constructor.numhask+Extracts the real part of a complex number.numhask0Extracts the imaginary part of a complex number.6 Safe-Inferred.Rnumhask$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 numbernumhaskHas a zero denominatornumhask normalises a ratio by dividing both numerator and denominator by their greatest common divisor. reduce 72 606 :% 5)\a b -> reduce a b == a :% b || b == zeronumhask 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. gcd 72 6012 > > Safe-Inferred.SnumhaskA numhask exception.bb Safe-Inferred.S6>b>b Safe-Inferred.VnumhaskRebindableSyntax splats this, and I'm not sure where it exists in GHC land  ML! "K#$%&'()*+,-./0inopdefhklqmgcj1NPQO234BE56789:;?@AGFRSTUVWXYZ[\]^_`abrstuvwxyz{|}~; 0inopdefhklqmgcjrstuvwxyz{|}~  ML! "K#$%&'()*+,-./0odefhkqmjg1NPQO234BE56789:?@AGFRSTUVWXYZ[\]^_`asuvz !"#$% &' &( )* +, +- !. !/ !0 1 2 3 4#56#57 !8 !9 !: !; <= >? @A BC BD !E !F !G !H !I !J !K L M#5N OP @Q !R !S TU#5V WX @Y OZ @[ \] <^ !_   ! !#`a !b#`c#`d#`e#`fghigjk lm#`n @o#`p#`q rs#`t lu lv#`w rx ry#`z#`{#`|#5} ~      ) ) ) ) ) ) ) ) ) ) ) )                                               r W W W W  O O O O O O O O O O O O O @     \ \ \ \ \ \ \ \ & & & & & & & & & & & & & & & & & & & & & & & & & & &      + + ! ! ! ! ! ! ! !     #5#5#5#5#5#5#5#5#5                                                                                                                                                                                                                                                                                                                                                   !                       ! !#`#`                                                                                                                                                           ! ! ! ! ! ! ! ! 'numhask-0.11.0.1-GlTaMIQoKvi8tt6nmUlhJxNumHask.PreludeNumHask.Data.RationalNumHask.ExceptionNumHask.Algebra.AdditiveNumHask.Algebra.GroupNumHask.Algebra.MultiplicativeNumHask.Algebra.RingNumHask.Algebra.ActionNumHask.Data.IntegralNumHask.Algebra.FieldNumHask.Algebra.LatticeNumHask.Algebra.MetricNumHask.Data.Complex AssociativeUnitalData.Semigroup Semigroup Data.MonoidMonoid Data.FoldableFoldableData.Traversable TraversableAdditiveNumHask.Algebra Commutative InvertibleRingGHC.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<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalMonadFunctorGHC.NumNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShow MonadFail Applicative GHC.TypesBoolStringCharDoubleFloatInt ghc-bignumGHC.Num.IntegerIntegerGHC.Num.NaturalNatural GHC.MaybeMaybeOrderingRationalIOWord Data.EitherEitherFalseNothingJustTrueLeftRightLTEQGT/=maxBoundtraverse sequenceAsequencemapM writeFilereadLnreadIOreadFileputStrLnputStrputCharinteractgetLine getContentsgetChar appendFileGHC.IO.ExceptionioErrorGHC.IOFilePathIOError userError GHC.ExceptionthrowtoListnullminimummaximumlengthfoldr1foldr'foldrfoldl1foldl'foldlfoldMap'foldMapfoldelem traverse_ sequence_ sequenceA_ornotElemmsum minimumBy maximumBymapM_for_forM_foldrMfoldlMfind concatMapconcatasumanyandall Data.OldListwordsunwordsunlineslines Text.Readreadsreadeither readsPrecreadList readParenlexText.ParserCombinators.ReadPReadS significand scaleFloatisNegativeZeroisNaN isInfiniteisIEEEisDenormalized floatRange floatRadix floatDigitsexponent encodeFloat decodeFloatlcmtoEnumsuccpredfromEnumShowS showsPrecshowListshowshows showString showParenshowCharzipWith3zipWithzip3unzip3unzip takeWhiletaketailsplitAtspanscanr1scanrscanl1scanlreverse replicaterepeatlookuplastiterateinithead dropWhiledropcyclebreak!! Data.Maybemaybe Data.Functiononfix& Data.Functor<$>uncurrycurry<$<*untilflipconstasTypeOf=<<$!GHC.Err undefinederrorWithoutStackTraceerror GHC.NaturalNatS#NatJ#&&not||<<=>comparemaxmin Subtractivenegate-+zerosumaccsum $fAdditiveFUN$fAdditiveWord64$fAdditiveWord32$fAdditiveWord16$fAdditiveWord8$fAdditiveWord$fAdditiveInt64$fAdditiveInt32$fAdditiveInt16$fAdditiveInt8$fAdditiveNatural$fAdditiveBool$fAdditiveInteger $fAdditiveInt$fAdditiveFloat$fAdditiveDouble$fSubtractiveFUN$fSubtractiveWord64$fSubtractiveWord32$fSubtractiveWord16$fSubtractiveWord8$fSubtractiveWord$fSubtractiveInt64$fSubtractiveInt32$fSubtractiveInt16$fSubtractiveInt8$fSubtractiveNatural$fSubtractiveInteger$fSubtractiveInt$fSubtractiveFloat$fSubtractiveDouble AbelianGroup Idempotent AbsorbingabsorbGroupinvunitMagma⊕ $fMagmaFUN $fUnitalFUN$fAssociativeFUN$fCommutativeFUN$fInvertibleFUN$fAbsorbingFUN$fIdempotentFUNDivisiverecip/Multiplicative*oneproduct accproduct$fMultiplicativeFUN$fMultiplicativeWord64$fMultiplicativeWord32$fMultiplicativeWord16$fMultiplicativeWord8$fMultiplicativeWord$fMultiplicativeInt64$fMultiplicativeInt32$fMultiplicativeInt16$fMultiplicativeInt8$fMultiplicativeNatural$fMultiplicativeBool$fMultiplicativeInteger$fMultiplicativeInt$fMultiplicativeFloat$fMultiplicativeDouble $fDivisiveFUN$fDivisiveFloat$fDivisiveDoubleInvolutiveRingadj KleeneAlgebra StarSemiringstarplus Distributivetwo$fInvolutiveRingWord64$fInvolutiveRingWord32$fInvolutiveRingWord16$fInvolutiveRingWord8$fInvolutiveRingWord$fInvolutiveRingInt64$fInvolutiveRingInt32$fInvolutiveRingInt16$fInvolutiveRingInt8$fInvolutiveRingNatural$fInvolutiveRingInt$fInvolutiveRingInteger$fInvolutiveRingFloat$fInvolutiveRingDoubleModuleDivisiveAction|/MultiplicativeActionScalar|*SubtractiveAction|-AdditiveActionAdditiveScalar|++|-|*|/| FromInteger fromIntegerFromInt FromIntegral fromIntegralToInt ToIntegral toIntegralIntegraldivmoddivModquotremquotRemevenodd^^^ $fIntegralFUN$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$fFromIntegralFUNb$fFromIntegerWord64$fFromIntegerWord32$fFromIntegerWord16$fFromIntegerWord8$fFromIntegerWord$fFromIntegerInt64$fFromIntegerInt32$fFromIntegerInt16$fFromIntegerInt8$fFromIntegerNatural$fFromIntegerInteger$fFromIntegerInt$fFromIntegerFloat$fFromIntegerDouble TrigFieldpisincostanasinacosatanatan2sinhcoshtanhasinhacoshatanh QuotientFieldWholeproperFractionroundceilingfloortruncateExpFieldexplog**logBasesqrtFieldinfinitynan negInfinityhalf $fExpFieldFUN$fExpFieldFloat$fExpFieldDouble$fQuotientFieldDouble$fQuotientFieldFloat$fTrigFieldFUN$fTrigFieldFloat$fTrigFieldDoubleBoundedLatticeBoundedMeetSemiLatticetopBoundedJoinSemiLatticebottomLatticeMeetSemiLattice/\JoinSemiLattice\/joinLeq<\meetLeq>><<< maybeToListmapMaybe listToMaybe isNothingisJust fromMaybefromJust catMaybes Data.Boolbool Alternativesomemany<|>emptyliftA3liftA<**>stimesIdempotentMonoid