!l6      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012345NoneDb[Rnumhask Ha - a = zero negate a = zero - a negate a + a = zero a + negate a = zeronumhaskFor practical reasons,  has no super classes. Using  Associative and Unital from this library, or using  Semigroup and Monoid from base tends to complexify the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication. Ezero + a == a a + zero == a (a + b) + c == a + (b + c) a + b == b + aBy convention, (+) is regarded as commutative, but this is not universal, and the introduction of another symbol which means non-commutative multiplication seems a bit dogmatic.numhaskCompute the sum of a Foldable.66Safe=?Dbs numhaskAn  +https://en.wikipedia.org/wiki/Abelian_group Abelian Groupn 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 magma a = anumhask#An Absorbing is a Magma with an /https://en.wikipedia.org/wiki/Absorbing_elementAbsorbing Element a `times` absorb = absorbnumhaskA  1https://en.wikipedia.org/wiki/Group_(mathematics)Group2 is a Associative, Unital and Invertible Magma.numhaskAn Invertible Magma H" a,b " T: inv a `magma` (a `magma` b) = b = (b `magma` a) `magma` inv anumhask>A Commutative Magma is a Magma where the binary operation is  2https://en.wikipedia.org/wiki/Commutative_property commutative. a magma b = b magma anumhaskAn Associative Magma )(a magma b) magma c = a magma (b magma c)numhask%A Unital Magma is a magma with an  .https://en.wikipedia.org/wiki/Identity_elementidentity element (the unit). !unit magma a = a a magma 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, " a, b " T: a magma b " TFThese laws are true by construction in haskell: the type signature of . and the above mathematical laws are synonyms.  NoneDb~numhask Aa / a = one recip a = one / a recip a * a = one a * recip a = onenumhaskFor practical reasons,  has no super classes. Using  Associative and Unital from this library, or using  Semigroup and Monoid from base tends to complexify the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication. Cone * a == a a * one == a (a * b) * c == a * (b * c) a * b == b * aBy convention, (*) is regarded as commutative, but this is not universal, and the introduction of another symbol which means non-commutative multiplication seems a bit dogmatic.numhaskCompute the product of a Foldable.77None >@ADHVbnumhaskIa type class to represent an action on elements of a higher-kinded number  77776666None=?DbnumhaskInvolutive 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 aa `times` x + x = a ==> star a `times` x + x = x x `times` a + x = a ==> x `times` star a + x = xnumhaskA  5https://en.wikipedia.org/wiki/Semiring#Star_semirings StarSemiringD is a semiring with an additional unary operator star satisfying: star a = one + a `times` star anumhaskAn  -https://en.wikipedia.org/wiki/Integral_domainIntegral Domain generalizes a ring of integers by requiring the product of any two nonzero elements to be nonzero. This means that if a "` 0, an equality ab = ac implies b = c.numhaskA  0https://en.wikipedia.org/wiki/Ring_(mathematics)Ring is an abelian group under addition and monoidal under multiplication, and where multiplication distributes over addition.numhaskA  &https://en.wikipedia.org/wiki/SemiringSemiring is commutative monoidal under addition, has a monoidal multiplication operator (not necessarily commutative), and where multiplication distributes over addition.numhask 3https://en.wikipedia.org/wiki/Distributive_property Distributive laws [a * (b + c) == a * b + a * c (a * b) * c == a * c + b * c zero * a == zero a * zero == zeroThe sneaking in of the  /https://en.wikipedia.org/wiki/Absorbing_element annihilation laws here glosses over the possibility that the multiplicative zero element does not have to correspond with the additive unital zero.numhask Defining 5 requires adding the multiplicative unital to itself.   None>@ADb)$numhaskA  2https://en.wikipedia.org/wiki/Module_(mathematics)Modulee over r a is a (Ring a), an abelian (Group r a) and a scalar multiplier (.*, *.) with the laws: xa .* one == a (a + b) .* c == (a .* c) + (b .* c) c *. (a + b) == (c *. a) + (c *. b) a .* zero == zero a .* b == b *. a$$ None,8=>?@ADHVb%numhaskghc defaulting rules and, it seems, -XExtendedDefaultRules do not permit multiple parameter typeclasses to be in the mix when types are resolved, hence the simpler `type FromInteger a = FromIntegral a Integer` does not suffice.'numhaskkfromIntegral abstracts the codomain type, compared with the preludes Integral type. > fromIntegral_ a == aWfromIntegral is widely used as general coercion, hence the underscore for the operator.*numhaskatoIntegral is kept separate from Integral to help with compatability issues. > toIntegral a == a,numhask Integral laws /b == zero || b * (a `div` b) + (a `mod` b) == a4numhaskgeneral coercion via Integer7numhask/raise a number to a non-negative integral power%&'()*+,01-.2/345678,01-.2/*+)3'(%&45678-7.7 None 8=>?@ADXbkWnumhaskTrigonometric Fieldnumhask`A bounded field includes the concepts of infinity and NaN, thus moving away from error throwing. Mone / zero + infinity == infinity infinity + a == infinity zero / zero != nan}Note the tricky law that, although nan is assigned to zero/zero, they are never-the-less not equal. A committee decided this.numhaskA hyperbolic field class Ysqrt . (**2) == identity log . exp == identity for +ive b, a != 0,1: a ** logBase a b "H bnumhaskA  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.AA summary of the rules thus inherited from super-classes of Field pzero + 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 * b == b * a a / a = one recip a = one / a recip a * a = one a * recip a = onenumhaskA  is a J because it requires addition, multiplication and division to be computed.!! None=?Db@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 == xnumhaskWThe combination of two semi lattices makes a lattice if the absorption law holds: see  +http://en.wikipedia.org/wiki/Absorption_law and ,http://en.wikipedia.org/wiki/Lattice_(order) /Absorption: a \/ (a /\ b) == a /\ (a \/ b) == anumhask*A algebraic structure with element meets: (http://en.wikipedia.org/wiki/Semilattice hAssociativity: x /\ (y /\ z) == (x /\ y) /\ z Commutativity: x /\ y == y /\ x Idempotency: x /\ x == xnumhask*A algebraic structure with element joins: (http://en.wikipedia.org/wiki/Semilattice hAssociativity: 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 None=?@ADbtnumhask&distance between numbers using L1 norm )distance a b >= zero distance a a == zero numhask Cab be Normed  norm a >= zero norm zero == zero=Note that the Normed codomain can be different to the domain. numhaskz from base is not an operator replicated in numhask, being such a very silly name, and preferred is the much more obvious  . Compare with Norm$ where there is a change in codomain abs a * sign a == aGeneralising this class tends towards size and direction (abs is the size on the one-dim number line of a vector with its tail at zero, and sign is the direction, right?).            4None 24567=?@ADbRFnumhask&Complex numbers are an algebraic type.For a complex number z,   z# is a number with the magnitude of z8, but oriented in the positive real direction, whereas   z has the phase of z, but unit magnitude.The 3 and 4( instances traverse the real part first.GnumhaskKforms a complex number from its real and imaginary rectangular components.Hnumhask+Extracts the real part of a complex number.Inumhask0Extracts the imaginary part of a complex number.KnumhaskK t# is a complex value with magnitude 1 and phase t (modulo 2*).Lnumhask The function L takes a complex number and returns a (magnitude, phase) pair in canonical form: the magnitude is nonnegative, and the phase in the range (-, ]2; if the magnitude is zero, then so is the phase.Mnumhask.The nonnegative magnitude of a complex number.Nnumhask,The phase of a complex number, in the range (-, ]2. If the magnitude is zero, then so is the phase. FGHIJKLMN FGHIJKLMNG6NoneDba$None,8=>?@ADHVXbUknumhask"with RebindableSyntax the literal '1.0'6 mean exactly `fromRational (1.0::GHC.Real.Rational)`.mnumhask Fractional in base splits into fromRatio and Field FIXME: work out why the default type isn't firing so that an explicit instance is needed for `FromRatio (Ratio Integer) Integer`pnumhasktoRatio is equivalent to Real2 in base, but is polymorphic in the Integral type.6numhaskThese common constraints over the Ratio instances are due to the gcd algorithm. Subtractive is somewhat problematic with obtaining a `Ratio (Positive Integer)` which should be made possible.vnumhaskiGiven that fromRational is reserved, fromRational' provides general conversion between numhask rationals.wnumhaskw is a subsidiary function used only in this module. It normalises a ratio by dividing both numerator and denominator by their greatest common divisor.xnumhaskx 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 x 4 2 = 2, x (-4) 6 = 2, x 0 4 = 4. x 0 0 = 0U. (That is, the common divisor that is "greatest" in the divisibility preordering.)2Note: Since for signed fixed-width integer types,   minBound < 09, the result may be negative if one of the arguments is minBound& (and necessarily is if the other is 0 or minBound) for such types.MklmnopqrstuvwxrsMpqotmnklvuwxNone7=>?@ADHVbgtnumhaskLA pair of a's, implemented as a tuple, but api represented as a Pair of a's.fmap (+1) (Pair 1 2)Pair 2 3pure one :: Pair IntPair 1 1(*) <$> Pair 1 2 <*> pure 2Pair 2 4foldr (++) [] (Pair [1,2] [3])[1,2,3]FPair "a" "pair" `mappend` pure " " `mappend` Pair "string" "mappended" Pair "a string" "pair mappended"As a Ring and Field classPair 0 1 + zeroPair 0 1Pair 0 1 + Pair 2 3Pair 2 4Pair 1 1 - onePair 0 0Pair 0 1 * onePair 0 1Pair 0.0 1.0 / one Pair 0.0 1.0Pair 11 12 `mod` (pure 6)Pair 5 0 As an action Pair 1 2 .+ 3Pair 4 5numhaskthe preferred patternNone 24567=?@ADbI7numhaskModule : Data.Number.LogFloat Copyright : Copyright (c) 2007--2015 wren gayle romano License : BSD3 Maintainer : wren@community.haskell.org Stability : stable Portability : portable (with CPP, FFI) Link : ,https://hackage.haskell.org/package/logfloatA LogField is just a % with a special interpretation. The k function is presented instead of the constructor, in order to ensure semantic conversion. At present the . instance will convert back to the normal-domain, and hence will underflow at that point. This behavior may change in the future.Because  performs the semantic conversion, we can use operators which say what we *mean* rather than saying what we're actually doing to the underlying representation. That is, equivalences like the following are true[1] thanks to type-class overloading: WlogField (p + q) == logField p + logField q logField (p * q) == logField p * logField q:Performing operations in the log-domain is cheap, prevents underflow, and is otherwise very nice for dealing with miniscule probabilities. However, crossing into and out of the log-domain is expensive and should be avoided as much as possible. In particular, if you're doing a series of multiplications as in lp * LogField q * LogField r it's faster to do lp * LogField (q * r) if you're reasonably sure the normal-domain multiplication won't underflow; because that way you enter the log-domain only once, instead of twice. Also note that, for precision, if you're doing more than a few multiplications in the log-domain, you should use $ rather than using '(*)' repeatedly.#Even more particularly, you should avoid addition whenever possible. Addition is provided because sometimes we need it, and the proper implementation is not immediately apparent. However, between two LogFieldAs addition requires crossing the exp/log boundary twice; with a LogField and a B it's three times, since the regular number needs to enter the log-domain first. This makes addition incredibly slow. Again, if you can parenthesize to do normal-domain operations first, do it! 1qThat is, true up-to underflow and floating point fuzziness. Which is, of course, the whole point of this module.numhask{Constructor which does semantic conversion from normal-domain to log-domain. Throws errors on negative and NaN inputs. If p4 is non-negative, then following equivalence holds: #logField p == logToLogField (log p)numhaskEConstructor which assumes the argument is already in the log-domain.numhaskSemantically convert our log-domain value back into the normal-domain. Beware of overflow/underflow. The following equivalence holds (without qualification): %fromLogField == exp . logFromLogFieldnumhask6Return the log-domain value itself without conversion.numhaskO(1)n. Compute powers in the log-domain; that is, the following equivalence holds (modulo underflow and all that): 'LogField (p ** m) == LogField p `pow` m Since: 0.13numhaskO(n)&. Compute the sum of a finite list of ws, being careful to avoid underflow issues. That is, the following equivalence holds (modulo underflow and all that): 4LogField . accurateSum == accurateSum . map LogFieldN.B., this function requires two passes over the input. Thus, it is not amenable to list fusion, and hence will use a lot of memory when summing long lists.numhaskO(n)*. Compute the product of a finite list of s, being careful to avoid numerical error due to loss of precision. That is, the following equivalence holds (modulo underflow and all that): <LogField . accurateProduct == accurateProduct . map LogField8None =>?@ADIMbJSafeDbJvNone =>?@ADIMbKNoneDbL5numhaskKrebindable syntax splats this, and I'm not sure where it exists in GHC landU!~" # $7654%&'() *+,DCBA@?>=<;:98-./012 34 56789:;<=>?@mqABlCnDEFGHIJKopLtuvMNOPQRSTUVWrsXYZ[\]^_`abcdefghijk     !"#$%&'()+*,-./0123456798;:=<?>A@CBEDGFHIJKLMNOPQRSTUVWXZY\[^]`_badcfekjihgnmlqporstuvwxyz{~}|wxyz{|}~     ! "#%$&'(*)+,-210/.3EFGHIJKLMNOPQRSTUVWXYnmlkjihgfedcba`_^]\[Zrqpostuvwxyz{|}789:;<=>?@ABCDEFGHIJKLM      !"#$%&'()*+,-./0653421789:;<=>?@ABCDEFGHIJMLKNOPQRSTUVWXYZ[\]^_`bacdefghijklmnopqrstuvwxyz{|}~NOP$%&'()*+,01-.2/345678     FGHIJKLMNklmnopqrstuvwx5J! !~" # $7654%&'() *+,DCBA@?>=<;:98-./012 34 56789:;<=>?@mqABlCnDEFGHIKopLtuvMNOPQRSTUVWrsXYZ[\]^_`abcdefghijk     !"#$%&'()+*,-./0123456798;:=<?>A@CBEDGFHIJKLMNOPQRSTUVWXZY\[^]`_badcfekjihgnmlqporstuvwxyz{~}|wxyz{|}~     "#%$&'(*)+,-210/.3EFGHIJKLMNOPQRSTUVWXYnmlkjihgfedcba`_^]\[Zrqpostuvwxyz{|}      !"#$%&'()*+,-./0653421789:;<=>?@ABCDEFGHIJMLKNOPQRSTUVWXYZ[\]^_`bacdefghijklmnopqrstuvwxyz{|}~5Q !"#"$"%"&'(')*+,-./01234565789:;<=>?@A"B"C'DEF1GHIJK'LMN1OEP1QRSTUVW/XYZ[\]^_^`^a^b^cdefghijklmnonpnqnrnstutvtwtxyz{<|}~n1nnnn^^^^^^^^^^^^nndnnnn}}nnnn^^^^^^^^1111111111111111111""      !"#$%$&$'$()*+,+-./.0.1.1.2.3.4.5.56768h9l:;<=>=?=@3A3B3C3D3E3F3G3H3I3J3K3L3M3N\O\P\Q\R\S\T\U\V\W\XYZY[Y\Y\]^]_]_`abcbdbefghihjhkhlhmhnhohphqrsrtuvuwuxuxyz{|{}{~{{{{{{{{{{{{{{{{{{{{{{{{bZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ       ^^^^^^^^^^^^^^^^^ ^!^"^#^$^%^&^'^(^)^*^+^,f-f.f/f0f1f1d2d23435363738393:3;3<3=3>3?3@3A3B3C3D3EFGFHIJIKILMNOPQRSTUVUWUWXYXYZ[Z\Z]^_^`^a^abcbdbebfbgb(hihjklkmknkokpqrEsEtEuEvEwExEyEzE{E|E}E~EEEEE1111""""""RJ     <'''''''''' !"#$%&$'($)*$+,$-./01/02/03/04/0567867967:67;<=>?@A?@B?@C?@D?@E?@F?GH?GI?GJ?GK?GL?MN?MO?MP<QR<QR<QS<QT<QU<QV<QW<QX<QY<Z[<Z[<Z\<Z]<Z^<_`<_`<_a<_b<_c<_d<_e<_f<_g<_hijkijlijmijnijoijpijqijrijsijtijuijvijwijxijyijzij{i|}i|~i|i|i|i|i|i|i|i|iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii<Q<Q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                              ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                             !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abbcdefghijklmnopqrstuvwxyz{|}~<=<<<$numhask-0.6.0-CeuTuDHUgBCC5SPNLq4vrkNumHask.PreludeNumHask.Data.RationalNumHask.Exception!NumHask.Algebra.Abstract.AdditiveNumHask.Algebra.Abstract.Group'NumHask.Algebra.Abstract.MultiplicativeNumHask.Algebra.Abstract.ActionNumHask.Algebra.Abstract.RingNumHask.Algebra.Abstract.ModuleNumHask.Data.IntegralNumHask.Algebra.Abstract.Field NumHask.Algebra.Abstract.LatticeNumHask.Analysis.MetricNumHask.Data.ComplexNumHask.Data.PairNumHask.Data.LogFieldNumHask.Data.WrappedNumHask.Data.PositiveNumHask.Algebra.AbstractbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listfilterzip Data.Tuplefstsnd otherwise$GHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=fail>>=>>fmapreturn Data.String fromStringGHC.Real realToFrac Control.MonadguardGHC.ExtsfromList fromListN<>memptymappendmconcat GHC.NaturalNatS#join<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalMonadFunctorGHC.NumNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShowData.Typeable.InternalTypeableControl.Monad.Fail MonadFailIsString Applicative Data.FoldableFoldableData.Traversable Traversable GHC.GenericsGenericGeneric1Datatype ConstructorSelector GHC.TypeNatsKnownNat GHC.TypeLits KnownSymbolGHC.OverloadedLabelsIsLabel SemigroupMonoid GHC.RecordsHasField GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeIntegerNatural GHC.MaybeMaybeOrderingRational GHC.Stable StablePtrIOWordGHC.WordWord8Word16Word32Word64GHC.PtrPtrFunPtr Data.EitherEitherType ConstraintV1U1K1M1:+::*::.:Rec0D1C1S1URecNatSymbolCmpNat Coercible GHC.StaticPtr StaticPtrGHC.Stack.Types CallStackD#FalseF#NothingJustTrueLeftRightLTEQGTPrefixIInfixILeftAssociativeRightAssociativeNotAssociativeMetaDataMetaConsMetaSelGHC.IO.Handle.TypesHandleGHC.STST GHC.Conc.SyncforkOnWithUnmaskforkIOWithUnmaskforkOnControl.ConcurrentforkOSThreadId"async-2.2.2-JNOgs3QkEuXLm97AkAPhACControl.Concurrent.Async concurrentlyrace_racelink2linkwaitBothwaitEitherCancel waitEither_ waitEitherwaitEitherCatchCancelwaitEitherCatch waitAnyCancelwaitAnywaitAnyCatchCancel waitAnyCatch cancelWithcancelpoll waitCatchwait withAsyncOnwithAsyncBound withAsyncasyncOn asyncBoundasync asyncThreadIdAsyncrunConcurrently ConcurrentlyintegralEnumFromThenTointegralEnumFromTointegralEnumFromThenintegralEnumFromgcdWord'gcdInt'^^%^^^%^numericEnumFromThenTonumericEnumFromTonumericEnumFromThennumericEnumFrom notANumber ratioPrec1 ratioPrecunderflowError overflowErrorratioZeroDenominatorError divZeroErrorboundedEnumFromThenboundedEnumFrommaxIntminInt Data.Complex conjugate Data.VoidvacuousabsurdVoidData.Semigroupoption mtimesDefaultdiffcycle1 WrappedMonoid getOptionOptionthreadWaitWriteSTMthreadWaitReadSTMthreadWaitWritethreadWaitReadrunInUnboundThreadrunInBoundThreadisCurrentThreadBoundforkOSWithUnmask forkFinallyrtsSupportsBoundThreadsControl.Concurrent.ChanwriteList2ChangetChanContentsdupChanreadChan writeChannewChanChanControl.Concurrent.QSem signalQSemwaitQSemnewQSemQSemControl.Concurrent.QSemN signalQSemN waitQSemNnewQSemNQSemNData.Bifunctorsecondfirstbimap BifunctorData.List.NonEmptynonEmptyGHC.ExecutionStackshowStackTrace getStackTraceGHC.ExecutionStack.Internal sourceColumn sourceLineSrcLocsrcLoc functionName objectNameLocationControl.Monad.IO.ClassliftIOMonadIO fromLabelgetFieldSystem.EnvironmentgetArgs System.Exit exitSuccess exitFailureexitWithmfilter<$!>unless replicateM_ replicateMfoldM_foldM zipWithM_zipWithM mapAndUnzipMforever<=<>=>filterMfoldMapDefault fmapDefault mapAccumR mapAccumLforMforsequencemapM sequenceAtraverseControl.Applicativeoptional getZipListZipListData.Functor.Identity runIdentityIdentity System.IOwithFileGHC.IO.Handle.FDopenFilestderrstdin GHC.Conc.IO threadDelayControl.Concurrent.MVar mkWeakMVaraddMVarFinalizermodifyMVarMaskedmodifyMVarMasked_ modifyMVar modifyMVar_withMVarMaskedwithMVarswapMVar GHC.StackwithFrozenCallStack callStackControl.ExceptionallowInterruptcatchesHandlerControl.Monad.ST.ImpfixSTControl.Exception.BasebracketOnErrorbracket_finallybracket onExceptiontryJusttry mapException handleJusthandle catchJustPatternMatchFail RecSelError RecConError RecUpdError NoMethodError TypeErrorNonTerminationNestedAtomicallycatchSTMthrowSTMorElseretry atomicallymkWeakThreadIdthreadCapabilityyield myThreadId killThreadsetNumCapabilitiesgetNumCapabilitiesforkIOSTMGHC.IO.ExceptionioErrorasyncExceptionFromExceptionasyncExceptionToExceptionBlockedIndefinitelyOnMVarBlockedIndefinitelyOnSTMDeadlockAllocationLimitExceededCompactionFailedAssertionFailedSomeAsyncException UserInterrupt ThreadKilled HeapOverflow StackOverflowAsyncExceptionUndefinedElementIndexOutOfBoundsArrayException ExitFailure ExitSuccessExitCodestdoutGHC.IOevaluateuninterruptibleMaskuninterruptibleMask_maskmask_getMaskingState interruptiblecatchFilePathMaskedUninterruptibleMaskedInterruptibleUnmasked MaskingState IOException GHC.ExceptionprettyCallStack prettySrcLocthrow ErrorCallErrorCallWithLocationGHC.Exception.Type SomeExceptiondisplayException fromException toException ExceptionRatioZeroDenominatorDenormal DivideByZeroLossOfPrecision UnderflowOverflowArithException Data.TypeablegcasteqTcasttypeReptypeOfTypeRepData.Functor.ConstgetConstConstfindnotElem minimumBy maximumByallanyorand concatMapconcatmsumasum sequence_ sequenceA_forM_mapM_for_ traverse_foldlMfoldrMminimummaximumelemlengthnulltoListfoldl'foldlfoldr'foldrfoldMapfold Data.MonoidgetFirstFirstgetLastLastgetApApData.Semigroup.Internal stimesMonoidstimesIdempotentgetDualDualappEndoEndogetAllAllgetAnyAnygetAltAltunK1unM1R1L1unComp1Comp1 isNewtype packageName moduleName datatypeName conIsRecord conFixityconNameInfixPrefixFixityFixityI AssociativityselDecidedStrictnessselSourceStrictnessselSourceUnpackednessselNametofromMeta someSymbolVal someNatVal symbolValnatVal SomeSymbolSomeNat Data.OldListunfoldrsortBysort permutations subsequencestailsinitsgroupBygroupgenericReplicategenericSplitAt genericDrop genericTake genericLength transpose intercalate intersperse isPrefixOf Data.CharisLetter digitToInt Text.Read readMaybe readEitherreads fromRightfromLeftisRightisLeftpartitionEithersrightsleftseitherData.Ord comparingDown Data.ProxyProxyControl.Category.idCategoryData.Type.Coercionrepr coerceWithCoercionData.Type.Equality gcastWithcastWithsymRefl:~: Foreign.PtrWordPtrIntPtr GHC.IO.IOMode ReadWriteMode AppendMode WriteModeReadModeIOModeForeign.StorableStorablelog1mexplog1pexpexpm1log1pisIEEEisNegativeZeroisDenormalized isInfiniteisNaN scaleFloat significandexponent encodeFloat decodeFloat floatRange floatDigits floatRadix byteSwap64 byteSwap32 byteSwap16 GHC.UnicodetoTitletoUppertoLowerisLowerisUpperisPrint isControl isAlphaNumisAlpha isHexDigitisDigitisSpaceisAsciirunST Data.BitstoIntegralSizedpopCountDefaulttestBitDefault bitDefaultpopCountrotateRrotateLshiftRshiftLisSignedbitSize bitSizeMaybetestBit complementBitclearBitsetBitbitzeroBitsrotateshift complementxor.|..&.BitscountTrailingZeroscountLeadingZeros finiteBitSize FiniteBits Data.Function&onfix Data.Functorvoid$><&><$>lcm denominator numerator%maxBoundminBoundfromEnumtoEnumpredsuccGHC.Charchr intToDigitunzipzipWithreversebreaksplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanrscanl'scanl Data.MaybemapMaybe catMaybes listToMaybe maybeToList fromMaybe isNothingisJustmaybeswapuncurrycurryGHC.MVar isEmptyMVar tryReadMVar tryPutMVar tryTakeMVarputMVarreadMVartakeMVarnewMVar newEmptyMVarMVarsignum GHC.Stack.CCScurrentCallStackasTypeOfuntilflipconstordapliftM5liftM4liftM3liftM2liftMwhen=<<liftA3liftA<**>stimessconcat<$<*liftA2manysome<|>empty Alternativemplusmzero MonadPlus:|NonEmpty getCallStack HasCallStackstimesIdempotentMonoidNatJ#/=<=compare&&||not<>maxminbytestring-0.10.8.2Data.ByteString.Internal ByteStringcontainers-0.6.0.1Data.IntMap.InternalIntMapData.IntSet.InternalIntSetData.Map.InternalMapData.Sequence.InternalSeqData.Set.InternalSetdeepseq-1.4.4.0Control.DeepSeqforce$!!deepseqrnfNFData'hashable-1.3.0.0-1RsrIcitxVDKffGN1TuMlmData.Hashable.Class hashUsinghash hashWithSaltHashabletransformers-0.5.5.0Control.Monad.Trans.Classlift mtl-2.2.2Control.Monad.State.Classgetsmodifystateputget MonadStateControl.Monad.Reader.Classasksreaderlocalask MonadReaderControl.Monad.Error.Class catchError throwError MonadErrorControl.Monad.Trans.ExceptExceptTExcept runExcept mapExcept withExcept runExceptT mapExceptT withExceptTControl.Monad.Trans.ReaderReaderT runReaderTReader runReaderControl.Monad.Trans.State.LazyStateT runStateTStaterunState evalState execState withState evalStateT execStateT&protolude-0.3.0-2wdl5ADWXt8DxyUh9xtxak ProtoludedieshowliftIO2liftIO1guardedAguardedpassthrowTothrowIOprintapplyNunsnocunconsmapidentityLText LByteStringProtolude.Debugwitness undefinednotImplementedtraceIdtraceM traceShowM traceShowId traceShowtraceIOtraceProtolude.Show putErrTextputLByteString putByteStringputLTextputTextputErrLnputStrLn hPutStrLnputStrhPutStrPrintProtolude.SafeatDefatMay foldl1May' foldl1May foldr1May maximumDef minimumDef maximumMay minimumMaylastDeflastMaytailSafetailDeftailMayinitSafeinitDefinitMayheadDefheadMayProtolude.PanicpanicfatalErrorMessage FatalErrorProtolude.MonadliftM2'liftM' concatMapMProtolude.ListlistordNubsortOnheadProtolude.FunctorforeachProtolude.ExceptionstryIOnotehushProtolude.Either maybeToEither maybeEmpty maybeToLeft maybeToRight rightToMaybe leftToMaybeProtolude.ConvertText toUtf8LazytoUtf8toS ConvertTextProtolude.Bool<&&>&&^<||>||^guardMifMunlessMwhenMboolProtolude.Base$!Protolude.ApplicativeliftAA2purereitherAorEmptyorAltthrowEcatchE text-1.2.3.1Data.Text.Encoding.ErrorUnicodeException OnDecodeErrorOnError strictDecode lenientDecodeignorereplaceData.Text.InternalTextData.Text.EncodingdecodeUtf8With decodeUtf8 decodeUtf8' encodeUtf8 Data.TextwordslinesunlinesunwordsData.Text.LazytoStrict fromStrict Data.Text.IOreadFile writeFile appendFileinteract getContentsgetLine stm-2.5.0.0Control.Monad.STMcheckpackData.Text.Showunpack Subtractivenegate-Additive+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 Commutative AssociativeUnitalunitMagmamagma $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$fDivisiveDoubleDivisiveAction.//.MultiplicativeAction.**.SubtractiveAction.--.AdditiveAction.++.ActorInvolutiveRingadj KleeneAlgebra StarSemiringstarplusIntegralDomainRingSemiring Distributivetwo$fDistributive->$fDistributiveBool$fDistributiveWord64$fDistributiveWord32$fDistributiveWord16$fDistributiveWord8$fDistributiveWord$fDistributiveInt64$fDistributiveInt32$fDistributiveInt16$fDistributiveInt8$fDistributiveNatural$fDistributiveInteger$fDistributiveInt$fDistributiveFloat$fDistributiveDouble $fSemiringa$fRinga$fIntegralDomain->$fIntegralDomainFloat$fIntegralDomainDouble$fStarSemiring->$fKleeneAlgebra->$fInvolutiveRing->$fInvolutiveRingWord64$fInvolutiveRingWord32$fInvolutiveRingWord16$fInvolutiveRingWord8$fInvolutiveRingWord$fInvolutiveRingInt64$fInvolutiveRingInt32$fInvolutiveRingInt16$fInvolutiveRingInt8$fInvolutiveRingNatural$fInvolutiveRingInt$fInvolutiveRingInteger$fInvolutiveRingFloat$fInvolutiveRingDoubleModule FromInteger fromInteger FromIntegral fromIntegral_ ToInteger ToIntegral toIntegralIntegraldivmoddivModquotremquotRem toInteger fromIntegralevenodd^^^ $fIntegral->$fIntegralWord64$fIntegralWord32$fIntegralWord16$fIntegralWord8$fIntegralWord$fIntegralInt64$fIntegralInt32$fIntegralInt16$fIntegralInt8$fIntegralNatural$fIntegralInteger $fIntegralInt$fToIntegralWord64Word64$fToIntegralWord32Word32$fToIntegralWord16Word16$fToIntegralWord8Word8$fToIntegralWordWord$fToIntegralInt64Int64$fToIntegralInt32Int32$fToIntegralInt16Int16$fToIntegralInt8Int8$fToIntegralNaturalNatural$fToIntegralIntInt$fToIntegralWord64Integer$fToIntegralWord32Integer$fToIntegralWord16Integer$fToIntegralWord8Integer$fToIntegralWordInteger$fToIntegralInt64Integer$fToIntegralInt32Integer$fToIntegralInt16Integer$fToIntegralInt8Integer$fToIntegralNaturalInteger$fToIntegralIntInteger$fToIntegralIntegerInteger$fFromIntegralWord64Word64$fFromIntegralWord32Word32$fFromIntegralWord16Word16$fFromIntegralWord8Word8$fFromIntegralWordWord$fFromIntegralInt64Int64$fFromIntegralInt32Int32$fFromIntegralInt16Int16$fFromIntegralInt8Int8$fFromIntegralNaturalNatural$fFromIntegralIntInt$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$fFromIntegerFloat$fFromIntegerDouble$fFromIntegerInt$fFromIntegerInteger TrigFieldpisincostanasinacosatansinhcoshtanhasinhacoshatanhLowerBoundedField negInfinityUpperBoundedFieldinfinitynan QuotientFieldproperFractionroundceilingfloortruncateExpFieldexploglogBase**sqrtFieldhalf $fField-> $fFieldFloat $fFieldDouble $fExpField->$fExpFieldFloat$fExpFieldDouble$fQuotientField->->$fQuotientFieldDoubleInteger$fQuotientFieldFloatInteger$fUpperBoundedField->$fUpperBoundedFieldDouble$fUpperBoundedFieldFloat$fLowerBoundedField->$fLowerBoundedFieldDouble$fLowerBoundedFieldFloat $fTrigField->$fTrigFieldFloat$fTrigFieldDoubleBoundedLatticeBoundedMeetSemiLatticetopBoundedJoinSemiLatticebottomLatticeMeetSemiLattice/\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 aboutEqualMetricdistanceNormednormSignedsignabs~=$fSignedWord64$fSignedWord32$fSignedWord16 $fSignedWord8 $fSignedWord $fSignedInt64 $fSignedInt32 $fSignedInt16 $fSignedInt8$fSignedNatural$fSignedInteger $fSignedInt $fSignedFloat$fSignedDouble$fNormedWord64Word64$fNormedWord32Word32$fNormedWord16Word16$fNormedWord8Word8$fNormedWordWord$fNormedInt64Int64$fNormedInt32Int32$fNormedInt16Int16$fNormedInt8Int8$fNormedNaturalNatural$fNormedIntegerInteger$fNormedIntInt$fNormedFloatFloat$fNormedDoubleDouble$fMetricWord64Word64$fMetricWord32Word32$fMetricWord16Word16$fMetricWord8Word8$fMetricWordWord$fMetricInt64Int64$fMetricInt32Int32$fMetricInt16Int16$fMetricInt8Int8$fMetricNaturalNatural$fMetricIntegerInteger$fMetricIntInt$fMetricFloatFloat$fMetricDoubleDouble$fEpsilonWord64$fEpsilonWord32$fEpsilonWord16$fEpsilonWord8 $fEpsilonWord$fEpsilonInt64$fEpsilonInt32$fEpsilonInt16 $fEpsilonInt8$fEpsilonInteger $fEpsilonInt$fEpsilonFloat$fEpsilonDoubleComplex:+realPartimagPartmkPolarcispolar magnitudephase$fBoundedMeetSemiLatticeComplex$fBoundedJoinSemiLatticeComplex$fMeetSemiLatticeComplex$fJoinSemiLatticeComplex$fLowerBoundedFieldComplex$fUpperBoundedFieldComplex$fInvolutiveRingComplex$fExpFieldComplex$fFieldComplex$fIntegralDomainComplex$fEpsilonComplex$fMetricComplexa$fNormedComplexa$fFromIntegralComplexb$fDivisiveComplex$fMultiplicativeComplex$fDistributiveComplex$fSubtractiveComplex$fAdditiveComplex $fEqComplex $fShowComplex $fReadComplex $fDataComplex$fGenericComplex$fGeneric1Complex$fFunctorComplex$fFoldableComplex$fTraversableComplex FromRational fromRational FromRatio fromRatio ToRationalToRatiotoRatioRatio:% toRationalfromBaseRational fromRational'reducegcd$fFromIntegralRatiob $fOrdRatio $fEqRatio$fMeetSemiLatticeRatio$fJoinSemiLatticeRatio$fEpsilonRatio$fMetricRatioRatio$fNormedRatioRatio $fSignedRatio$fLowerBoundedFieldRatio$fUpperBoundedFieldRatio$fQuotientFieldRatiob $fFieldRatio$fIntegralDomainRatio$fDistributiveRatio$fDivisiveRatio$fMultiplicativeRatio$fSubtractiveRatio$fAdditiveRatio$fToRatioWord64Integer$fToRatioWord32Integer$fToRatioWord16Integer$fToRatioWord8Integer$fToRatioWordInteger$fToRatioInt64Integer$fToRatioInt32Integer$fToRatioInt16Integer$fToRatioInt8Integer$fToRatioNaturalInteger$fToRatioIntegerInteger$fToRatioIntInteger$fToRatioRatioInteger$fToRatioRatioInteger0$fToRatioFloatInteger$fToRatioDoubleInteger$fFromRatioRatioInteger$fFromRatioRatioInteger0$fFromRatioFloatInteger$fFromRatioDoubleInteger$fFromRationalRatio$fFromRationalFloat$fFromRationalDouble $fShowRatioPairPair'$fMetricPairPair$fNormedPairPair$fFromRatioPairb$fFromIntegralPairb$fBoundedMeetSemiLatticePair$fBoundedJoinSemiLatticePair$fMeetSemiLatticePair$fJoinSemiLatticePair$fDivisiveActionPair$fMultiplicativeActionPair$fSubtractiveActionPair$fAdditiveActionPair$fLowerBoundedFieldPair$fUpperBoundedFieldPair$fExpFieldPair$fIntegralDomainPair $fFieldPair$fDistributivePair $fMetricPaira $fEpsilonPair $fNormedPaira $fSignedPair$fIntegralPair$fDivisivePair$fMultiplicativePair$fSubtractivePair$fAdditivePair $fBoundedPair $fMonoidPair$fSemigroupPair$fTraversablePair$fFoldablePair $fMonadPair$fApplicativePair $fShow1Pair $fEq1Pair $fFunctorPair $fShowPair$fEqPair $fGenericPairLogFieldlogField logToLogField fromLogFieldlogFromLogFieldpow accurateSumaccurateProduct$fSignedLogField$fUpperBoundedFieldLogField$fIntegralDomainLogField$fLowerBoundedFieldLogField$fFieldLogField$fEpsilonLogField$fMeetSemiLatticeLogField$fJoinSemiLatticeLogField$fToRatioLogFieldb$fFromRatioLogFieldb$fToIntegralLogFieldb$fFromIntegralLogFieldb$fExpFieldLogField$fDistributiveLogField$fDivisiveLogField$fMultiplicativeLogField$fSubtractiveLogField$fAdditiveLogField$fShowLogField $fEqLogField $fOrdLogField$fReadLogField$fDataLogField$fGenericLogField$fGeneric1LogField$fFunctorLogField$fFoldableLogField$fTraversableLogFieldWrapped unWrapped$fMetricWrappedWrapped$fNormedWrappedWrapped$fToRatioWrappedb$fFromRatioWrappedb$fToIntegralWrappedb$fFromIntegralWrappedb$fQuotientFieldWrappedWrapped $fShowWrapped $fEqWrapped $fOrdWrapped$fMagmaWrapped$fIdempotentWrapped$fAdditiveWrapped$fSubtractiveWrapped$fMultiplicativeWrapped$fDivisiveWrapped$fDistributiveWrapped$fIntegralDomainWrapped$fInvolutiveRingWrapped$fStarSemiringWrapped$fKleeneAlgebraWrapped$fFieldWrapped$fExpFieldWrapped$fTrigFieldWrapped$fIntegralWrapped$fSignedWrapped$fMeetSemiLatticeWrapped$fJoinSemiLatticeWrapped$fEpsilonWrapped$fUpperBoundedFieldWrapped$fLowerBoundedFieldWrappedNumHaskException errorMessage$fExceptionNumHaskException$fShowNumHaskExceptionPositive unPositivepositive positive_$fMetricaPositive$fNormedaPositive$fBoundedPositive$fUpperBoundedFieldPositive$fQuotientFieldPositivePositive$fSubtractivePositive$fShowPositive $fEqPositive $fOrdPositive$fAdditivePositive$fMultiplicativePositive$fDivisivePositive$fDistributivePositive$fIntegralDomainPositive$fFieldPositive$fExpFieldPositive$fTrigFieldPositive$fIntegralPositive$fSignedPositive$fJoinSemiLatticePositive$fMeetSemiLatticePositive$fEpsilonPositive ifThenElseGCDConstraints'bifunctors-5.5.7-K3znhqcGXpP3BVPnO58c1JData.BiapplicativetraverseBiaWith sequenceBia traverseBiabiliftA3<<**>><<$>> Biapplicativebipure<<*>>biliftA2*>><<*#mmorph-1.1.3-CrbW1pkoojp2congoTX0Y2Control.Monad.Morph|>==<|<|<>|>squash generalizeMFunctorhoistMMonadembed MonadTransData.Functor.ConstantConstant getConstant