PrFA      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqr s t u v w x y z { | } ~        !"#$%&'()*+,-./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 MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@" None!"%&'()*+,34579>CFIKLNVABCABCABCNone!"%&'()*+,34579>CFIKLNVF7Inspects the given type and creates the most efficient Mutable instance possible.FIXME: implement properlyG Create a Mutable; instance for newtype wrappers. The instance has the form: Bnewtype instance Mutable m (TyCon t) = Mutable_TyCon (Mutable m t)Also create the appropriate  IsMutable instance.>FIXME: Currently uses default implementations which are slow.H Create a Mutable instance that uses PrimRefs for the underlying implementation. This method will succeed for all types. But certain types can be implemented for efficiently.DEFGHFGHFHGDEFGH!None!"%&'()*+,34579>CFIKLNVJOFIXME: Move to a better spot Add rewrite rules to remove with optimization -OIJFGHI JKLMNOPQRS !"#$%&TUVWXYZ[\]^_`'()*+,-./01abcdefghijklmnopqrstuvwxyz{|}~2345678IJIJNone!"%&'()*+34579>CFIKLNVK.This data type is a huge hack to work around some unimplemented features in the type system. In particular, we want to be able to declare any type constructor to be a subtype of any other type constructor. The main use case is for making subcategories use the same subtyping mechanism as other types.FIXME: replace this data family with a system based on type families; everything I've tried so far requires injective types or foralls in constraints.LqWe use `s <: t` to denote that s is s subtype of t. The "embedType" function must be s homomorphism from s to t.:class (Sup s t t, Sup t s t) => (s :: k) <: (t :: k) whereN[Subtypes are partially ordered. Unfortunately, there's no way to use the machinery of the POrd/Lattice classes. The SupD type family is a promotion of the "sup" function to the type level.It must obey the laws: &Sup a b c <===> ( a <: c, b <: c ) Sub a b c <===> Sup b a c>And there is no smaller value of "c" that can be used instead.FFIXME: it would be nicer if this were a type family; is that possible?|FIXME: can these laws be simplified at all? In particular, can we automatically infer ctx from just the function parameter?R^FIXME: This should automatically search for other subtypes that can be inferred from t1 and t2>converts types created by `[t| ... |]` into a more useful formSCalling: mkSubtypeInstance a b fgenerates the following code: .instance a <: b where embedType_ = Embed0 f,FIXME: What if the type doesn't have kind *?Calling:  mkSup a b cgenerates the following code: %instance Sup a b c instance Sup b a c KLMNOPQ)this parameter is only for type inference)this parameter is only for type inference)this parameter is only for type inference)this parameter is only for type inferenceRSKLMNOPQRS LMNKOPQRSKLMNOPQRSNone!"%&'()*+,34579>CFIKLNVTThis class provides an artificial hierarchy that defines all the classes that a "well behaved" data type should implement. All newtypes will derive them automatically.UIWe need to export this function for deriving of Monadic functions to workWList all the superclasses of a one parameter class. This does not include: * constraints involving types other than the parameter (e.g. made with type families). * type synonyms (although these will get substituted in the recursion)RFor example, convert ''Group into [''Semigroup, ''Monoid, ''Cancellative, ''Group]Xcreates the instance: +type instance Scalar (Newtype s) = Scalar sYThis is the main TH function to call when deriving classes for a newtype. You only need to list the final classes in the hierarchy that are supposed to be derived. All the intermediate classes will be derived automatically.ZMLike "deriveHierarchy" except classes in the second list will not be derived.[EGiven a single newtype and single class, constructs newtype instances\Generate an Eq_ instance from the Prelude's Eq instance. This requires that Logic t = Bool, so we also generate this type instance.TUVWXYZ[\ GTUVWXYZ[\ YZ[XGW\TUVTUVWXYZ[\None!"%&'()*+34579>CFIKLNV ]~This class implements conversion between mutable and immutable data types. It is the equivalent of the functions provided in Contol.Monad.Primitive$, but we use the names of from the  Data.Vector7 interface because they are simpler and more intuitive.UEvery data type is an instance of this class using a default implementation based on PrimRefs. We use OverlappingInstances to allow some instances to provide more efficient implementations. We require that any overlapping instance be semantically equivalent to prevent unsafe behavior. The use of OverlappingInstances should only affect you if your creating your own specialized instances of the class. You shouldn't have to do this unless you are very concerned about performance on a complex type.AFIXME: It's disappointing that we still require this class, the  Primitive class, and the Storable" class. Can these all be unified?^Convert a mutable object into an immutable one. The implementation is guaranteed to copy the object within memory. The overhead is linear with the size of the object._Convert an immutable object into a mutable one The implementation is guaranteed to copy the object within memory. The overhead is linear with the size of the object.`?Assigns the value of the mutable variable to the immutable one.ahReturn a copy of the mutable object. Changes to the copy do not update in the original, and vice-versa.brLike "freeze", but much faster on some types because the implementation is not required to perform a memory copy.WARNING: You must not modify the mutable variable after calling unsafeFreeze. This might change the value of the immutable variable. This breaks referential transparency and is very bad.cpLike "thaw", but much faster on some types because the implementation is not required to perform a memory copy.WARNING: You must not access the immutable variable after calling unsafeThaw. The contents of this variable might have changed arbitrarily. This breaks referential transparency and is very bad.dJThe mutable version of an immutable data type. This is equivalent to the PrimRef type, which generalizes STRef and IORef.Unlike PrimRef, Mutable is implemented using a data family. This means that data types can provide more efficient implementations. The canonical example is VectorK. Vectors in standard Haskell use a different interface than the standard PrimRef. This requires the programmer learn multiple interfaces, and prevents the programmer from reusing code. Very un-Haskelly. This implementation of mutability gives a consistent interface for all data types.e7A Simple default implementation for mutable operations.f9A Simple default implementation for immutable operations.g`This function should only be used from within quickcheck properties. All other uses are unsafe.#]^_`abcdefg@ABCDEFU]^_`abcdefgd]^_`abcefgFEDCA@BU]^_`abcdefgNone!"%&'()*+,34579>CFIKLNVhUIdeally, this map would be generated automatically via template haskell. Due to bug  ,https://ghc.haskell.org/trac/ghc/ticket/9699#9699(, however, we must enter these manually.iDmakes tests for all instances of a class that take no type variablesjGiven a type and a class, searches "testMap" for all tests for the class; then specializes those tests to test on the given typek;Like "mkSpecializedClassTests", but takes a list of classesl*replace all variables with a concrete typen"creates an expression of the form: KtestProperty "testname" (law_Classname_testname :: typeName -> ... -> Bool)oCLike "mkTest", but takes a list of laws and returns a list of testsqtakes a Name of the form law_Class_testand returns the string test hijtype to create tests forclass to create tests forkltype with variables"instantiate variables to this typemtype to specialize the law to&law (i.e. function) that we're testingntype to specialize the law to&law (i.e. function) that we're testingopq hijklmnopq hijklmnopq hijklmnopq None!"%&'()*+34579>CFIKLNVsA provable category gives us the opposite ability as a Concrete category. Instead of embedding a function in the subcategory into Hask, we can embed certain functions from Hask into the subcategory.t}If you want to apply a function inside of a proof, you must use the "($$)" operator instead of the more commonly used "($)".BFIXME: This is rather inelegant. Is there any way to avoid this?uCThis data family can be used to provide proofs that an arrow in Hask (i.e. a function) can be embedded in some subcategory. We're travelling in the opposite direction of the subtyping mechanism. That's valid only in a small number of cases. These proofs give a type safe way to capture some (but not all) of those cases.vA dagger (also called an involution) is an arrow that is its own inverse. Daggers generalize the idea of a transpose from linear algebra. Notably,  is NOT a dagger category.More details avalable at  -https://en.wikipedia.org/wiki/Dagger_category wikipedia and ,http://ncatlab.org/nlab/show/dagger-categoryncatlabxCompact categories are another generalization from linear algebra. In a compact category, we can dualize any object in the same way that we can generate a covector from a vector. Notably,  is NOT compact.More details available at  4http://en.wikipedia.org/wiki/Compact_closed_category wikipedia and  4http://ncatlab.org/nlab/show/dagger-compact+categoryncatlab.|yGroupoids are categories where every arrow can be reversed. This generalizes bijective and inverse functions. Notably,  is NOT a Groupoid.More details available at  %http://en.wikipedia.org/wiki/Groupoid wikipedia  %http://ncatlab.org/nlab/show/groupoidncatlib, and  Zhttp://mathoverflow.net/questions/1114/whats-a-groupoid-whats-a-good-example-of-a-groupoidstack overflow.~xClosed monoidal categories allow currying, and closed braided categories allow flipping. We combine them into a single Closed class to simplify notation.1In general, closed categories need not be either Monoidal or Braided+. All a closed category requires is that all arrows are also objects in the category. For example, `a +> (b +> c)` is a vallid arrow in the category `(+>)`. But I don't know of any uses for this general definition of a closed category. And this restricted definition seems to have a lot of uses.More details available at  -https://en.wikipedia.org/wiki/Closed_category wikipedia and ,http://ncatlab.org/nlab/show/closed+categoryncatlabwThe default definition should be correct for any category, but can be overridden with a more efficient implementation.fFIXME: does this actually need to be in a class? or should it be a stand-alone function like "const"?In a cartesian monoidal category, the monoid object acts in a particularly nice way where we can compose and decompose it. Intuitively, we can delete information using the  and 5 arrows, as well as duplicate information using the  duplicate arrow.More details available at 8http://ncatlab.org/nlab/show/cartesian+monoidal+categoryncatlab!In a symmetric braided category,  and  are inverses of each other.More details available at 8http://en.wikipedia.org/wiki/Symmetric_monoidal_category wikipedia?Braided categories let us switch the order of tensored objects.More details available at  7https://en.wikipedia.org/wiki/Braided_monoidal_category wikipedia and 6http://ncatlab.org/nlab/show/braided+monoidal+categoryncatlabQThe intuition behind a monoidal category is similar to the intuition behind the " algebraic structure. Unfortunately, there are a number of rather awkward laws to work out the technical details. The associator and unitor functions are provided to demonstrate the required isomorphisms.More details available at .http://en.wikipedia.org/wiki/Monoidal_category wikipediaTechnicaly, a concrete category is any category equiped with a faithful functor to the category of sets. This is just a little too platonic to be represented in Haskell, but 4 makes a pretty good approximation. So we call any  SubCategory of  <. Importantly, not all categories are concrete. See the # category for an example.More details available at  .http://en.wikipedia.org/wiki/Concrete_category wikipedia and  .http://ncatlab.org/nlab/show/concrete+categoryncatlib.?The category with categories as objects and functors as arrows.More details available at  4https://en.wikipedia.org/wiki/Category_of_categories wikipedia and  http://ncatlab.org/nlab/show/Catncatlab.--3TODO: can this be extended to functor categories? -http://ncatlab.org/nlab/show/functor+categoryDThe category with Haskell types as objects, and functions as arrows.More details available at the  'http://www.haskell.org/haskellwiki/Hask Haskell wiki.This ? class modifies the one in the Haskell standard to include the ^ type constraint. This constraint let's us make instances of arbitrary subcategories of Hask.Subcategories are defined using the subtyping mechanism "(<:)". Intuitively, arrows and objects in a subcategory satisfy additional properties that elements of the larger category do not necessarily satisfy. Elements of a subcategory can always be embeded in the larger category. Going in the other direction, however, requires a proof. These proofs can (usually) not be verified by the type system and are therefore labeled unsafe.More details available at  (http://en.wikipedia.org/wiki/Subcategory wikipedia and  (http://ncatlab.org/nlab/show/subcategoryncatlab.7An alternative form of function composition taken from  Control.Arrow7An alternative form of function composition taken from  Control.ArrowXWe generalize the Prelude's definition of "$" so that it applies to any subcategory of  (that is, any  g. This lets us easily use these subcategories as functions. For example, given a polynomial function f :: Polynomial Double1we can evaluate the polynomial at the number 5 by f $ 5 NOTE: Base's implementation of m has special compiler support that let's it work with the RankNTypes extension. This version does not. See  `http://stackoverflow.com/questions/8343239/type-error-with-rank-2-types-and-function-compositionthis stackoverflow question for more detail.A strict version of Embeds a unary function into Embeds a binary function into This is a special form of the embedO function which can make specifying the category we are embedding into easier.YFIXME: This would be a useful function to have, but I'm not sure how to implement it yet!^This is a convenient and (hopefully) suggestive shortcut for constructing tensor products in  categories.i"fst" specialized to Hask to aid with type inference FIXME: this will not be needed with injective typesi"snd" specialized to Hask to aid with type inference FIXME: this will not be needed with injective types2Creates an arrow that ignores its first parameter.Based on the type signature, this looks like it should be the inverse of "embed" function. But it's not. This function completely ignores its second argument!Arstuvwxyz{|}~0rstuvwxyz{|}~0~|}xyz{vwstru(rstuvwxyz{|}~t  None!"%&'()*+,34579>CFIKLNVNone !"%&'()*+,34579<>CFIKLNVo`Some containers that use indices are not typically constructed with those indices (e.g. Arrays).aConstruct a container with only the single (index,element) pair. This function is equivalent to  in the  class.oInsert an element, overwriting the previous value if the index already exists. This function is equivalent to  in the  class.Insert an element only if the index does not already exist. If the index already exists, the container is unmodified. This function is equivalent to  in the  class.#This function is the equivalent of  in the / class. We do not require all the variants of  because of our ? constraint.MSliceable containers generalize the notion of a substring to any IxContainer.1An indexed constructible container associates an  with each 5. This class generalizes the map abstract data type.dThere are two differences in the indexed hierarchy of containers from the standard hierarchy. 1.  requires a ? constraint whereas  requires a E' constraint because there are no valid .s (that I know of at least) that are not also ?s. 2. Many regular containers are indexed containers, but not the other way around. So the class hierarchy is in a different order.<FIXME: should the functions below be moved to other classes?sFIXME: This is a correct definition of topologies, but is it useful? How can this relate to continuous functions? Provides inverse operations for  Constructible.;FIXME: should this class be broken up into smaller pieces?"Convert the container into a list.1Remove an element from the left of the container.2Remove an element from the right of the container./Add all the elements of the container together.the default summation uses kahan summation sum :: (Abelian (Elem s), Group (Elem s)) => s -> Elem s sum = snd . foldl' go (zero,zero) where go (c,t) i = ((t'-t)-y,t') where y = i-c t' = t+y.The monoid of endomorphisms under composition.<The dual of a monoid, obtained by swapping the arguments of mappend.nThis is a generalization of a "set". We do not require a container to be a boolean algebra, just a semigroup.This is the class for any type that gets "constructed" from smaller types. It is a massive generalization of the notion of a constructable set in topology.See  >https://en.wikipedia.org/wiki/Constructible_set_%28topology%29 wikipedia for more details.7creates the smallest value containing the given elementinserts an element on the left3inserts an element on the right; in a non-abelian N, this may not insert the element; this occurs, for example, in the Map type.GConstruct the type from a list. Since lists may be empty (but not all 0s can be empty) we explicitly pass in an Elem s.TLike "fromList1" but passes in the size of the list for more efficient construction.LMetric spaces give us the most intuitive notion of distance between objects.UFIXME: There are many other notions of distance and we should make a whole hierarchy.If the distance between two datapoints is less than or equal to the upper bound, then this function will return the distance. Otherwise, it will return some number greater than the upper bound.NTensor algebras generalize the outer product of vectors to construct a matrix.See  ,https://en.wikipedia.org/wiki/Tensor_algebra wikipedia for details.UFIXME: This needs to be replaced by the Tensor product in the Monoidal category Vect&Take the tensor product of two vectors("left multiplication" of a square matrix)"right multiplication" of a square matrixbHilbert spaces are a natural generalization of Euclidean space that allows for infinite dimension.See  *http://en.wikipedia.org/wiki/Hilbert_space wikipedia for more details.FIXME: The result of a dot product must always be an ordered field. This is true even when the Hilbert space is over a non-ordered field like the complex numbers. But the OrdFieldc constraint currently prevents us from doing scalar multiplication on Complex Hilbert spaces. See  Uhttp://math.stackexchange.com/questions/49348/inner-product-spaces-over-finite-fields and  Zhttp://math.stackexchange.com/questions/47916/banach-spaces-over-fields-other-than-mathbbc for some technical details.LA Banach space is a Vector Space equipped with a compatible Norm and Metric.See  )http://en.wikipedia.org/wiki/Banach_space wikipedia for more details.CA Reisz space is a vector space obeying nice partial ordering laws.See  (http://en.wikipedia.org/wiki/Riesz_space wikipedia for more details.VAn element of a reisz space can always be split into positive and negative components.If our  FreeModule! has a finite basis, then we can:)index into the modules basis coefficientsSprovide a dense construction method that's a bit more convenient than "fromIxList".Returns the dimension of the object. For some objects, this may be known statically, and so the parameter will not be "seq"ed. But for others, this may not be known statically, and so the parameter will be "seq"ed.rFree modules have a basis. This means it makes sense to perform operations elementwise on the basis coefficients.See  )https://en.wikipedia.org/wiki/Free_module wikipedia for more detail.kMultiplication of the components pointwise. For matrices, this is commonly called Hadamard multiplication.See  <http://en.wikipedia.org/wiki/Hadamard_product_%28matrices%29 wikipedia for more detail.3FIXME: This is only valid for modules with a basis.hThe identity for Hadamard multiplication. Intuitively, this object has the value "one" in every column.Scalar multiplication.A Cone is an "almost linear" subspace of a module. Examples include the cone of positive real numbers and the cone of positive semidefinite matrices.See < 6http://en.wikipedia.org/wiki/Cone_%28linear_algebra%29 wikipedia for more details.FIXME: There are many possible laws for cones (as seen in the wikipedia article). I need to explicitly formulate them here. Intuitively, the laws should apply the module operations and then project back into the "closest point" in the cone.FIXME: We're using the definition of a cone from linear algebra. This definition is closely related to the definition from topology. What is needed to ensure our definition generalizes to topological cones? See  ,http://en.wikipedia.org/wiki/Cone_(topology) wikipedia and  !http://ncatlab.org/nlab/show/conencatlab for more details.1FIXME: What constraint should be here? Semigroup?See +http://ncatlab.org/nlab/show/normed%20groupncatlab)A (sometimes) more convenient version of IsScalar.SA synonym that covers everything we intuitively thing scalar variables should have.^This is a catch-all class for things the real numbers can do but don't exist in other classes.FIXME: Factor this out into a more appropriate class hierarchy. For example, some (all?) trig functions need to move to a separate class in order to support trig in finite fields (see  3en.wikipedia.org/wiki/Trigonometry_in_Galois_fields wikipedia).?FIXME: This class is misleading/incorrect for complex numbers.6FIXME: There's a lot more functions that need adding./Fields augmented with exponents and logarithms.Technically, there are fields for which only a subset of the functions below are meaningful. But these fields don't have any practical computational uses that I'm aware of. So I've combined them all into a single class for simplicity.See  .http://en.wikipedia.org/wiki/Exponential_field wikipedia for more detail.3Rings augmented with the ability to take exponents.XNot all rings have this ability. Consider the ring of rational numbers (represented by Rational in Haskell). Raising any rational to an integral power results in another rational. But raising to a fractional power results in an irrational number. For example, the square root of 2.See  @http://en.wikipedia.org/wiki/Exponential_field#Exponential_rings wikipedia for more detail.FIXME: This class hierarchy doesn't give a nice way exponentiate the integers. We need to add instances for all the quotient groups.A  is a field with an IntegralDomain as a subring. There may be many such subrings (for example, every field has itself as an integral domain subring). This is especially true in Haskell because we have different data types that represent essentially the same ring (e.g. Int and Integer8). Therefore this is a multiparameter type class. The r2 parameter represents the quotient field, and the sp parameter represents the subring. The main purpose of this class is to provide functions that map elements in r to elements in s in various ways.8FIXME: Need examples. Is there a better representation?See  /http://en.wikipedia.org/wiki/Field_of_fractions wikipedia for more details.9A Rational field is a field with only a single dimension.8FIXME: this isn't part of standard math; why is it here?!The prototypical example of a bounded field is the extended real numbers. Other examples are the extended hyperreal numbers and the extended rationals. Each of these fields has been extensively studied, but I don't know of any studies of this particular abstraction of these fields.See  7https://en.wikipedia.org/wiki/Extended_real_number_line wikipedia for more details.$Ordered fields are generalizations of the rational numbers that maintain most of the nice properties. In particular, all finite fields and the complex numbers are NOT ordered fields.See  *http://en.wikipedia.org/wiki/Ordered_field wikipedia for more details.%/Fields are Rings with a multiplicative inverse.See  5https://en.wikipedia.org/wiki/Field_%28mathematics%29 wikipedia and  "http://ncatlab.org/nlab/show/fieldncatlab for more details.))z numbers can be formed from a wide class of things that behave like integers, but intuitively look nothing like integers.FIXME: All Fields are integral domains; should we make it a subclass? This wouuld have the (minor?) problem of making the Integral class have to be an approximate embedding. FIXME: Not all integral domains are homomorphic to the integers (e.g. a field)See wikipedia on  .https://en.wikipedia.org/wiki/Integral_elementintegral elements,  -https://en.wikipedia.org/wiki/Integral_domainintegral domains , and the  .https://en.wikipedia.org/wiki/Ring_of_integersring of integers.+truncates towards zero.#truncates towards negative infinity1It is not part of the standard definition of rings that they have a "fromInteger" function. It follows from the definition, however, that we can construct such a function. The "slowFromInteger" function is this standard construction.See  4https://en.wikipedia.org/wiki/Ring_%28mathematics%29 wikipedia and  !http://ncatlab.org/nlab/show/ringncatlab for more details.FIXME: We can construct a Module+ from any ring by taking (*)=(.*.). Thus, Module should be a superclass of Ring. Currently, however, this creates a class cycle, so we can't do it. A number of type signatures are therefore more complicated than they need to be.3A Ring without identity.4NA Rig is a Rg with multiplicative identity. They are also known as semirings.See  &https://en.wikipedia.org/wiki/Semiring wikipedia and  http://ncatlab.org/nlab/show/rigncatlab for more details.5the multiplicative identity6vA Rg is a Ring without multiplicative identity or negative numbers. (Hence the removal of the i and n from the name.)There is no standard terminology for this structure. They might also be called "semirings without identity", "pre-semirings", or "hemirings". See  lhttp://math.stackexchange.com/questions/359437/name-for-a-semiring-minus-multiplicative-identity-requirementthis stackexchange question for a discussion on naming.<In a cancellative semigroup,1) a + b = a + c ==> b = c#so > (a + b) - b = a + (b - b) = a2) b + a = c + a ==> b = c%so > -b + (b + a) = (-b + b) + a = a\This allows us to define "subtraction" in the semigroup. If the semigroup is embeddable in a group, subtraction can be thought of as performing the group subtraction and projecting the result back into the domain of the cancellative semigroup. It is an open problem to fully characterize which cancellative semigroups can be embedded into groups.See  3http://en.wikipedia.org/wiki/Cancellative_semigroup wikipedia for more details.A~Semigroup actions let us apply a semigroup to a set. The theory of Modules is essentially the theory of Ring actions. (See < dhttp://mathoverflow.net/questions/100565/why-are-ring-actions-much-harder-to-find-than-group-actionsB mathoverflow.) That is why the two classes use similar notation.See  .https://en.wikipedia.org/wiki/Semigroup_action wikipedia for more detail.=FIXME: These types could probably use a more expressive name.YFIXME: We would like every Semigroup to act on itself, but this results in a class cycle.D$This type class is only used by the Action; class. It represents the semigroup that acts on our type.HGeneralizes Boolean variables.See  =https://en.wikipedia.org/wiki/Boolean_algebra_%28structure%29 wikipedia for more details.IgHeyting algebras are lattices that support implication, but not necessarily the law of excluded middle.FIXME: Is every Heyting algebra a cancellative Abelian semigroup? If so, should we make that explicit in the class hierarchy?LawsAThere is a single, simple law that Heyting algebras must satisfy:a ==> b = c ===> a && c < bTheorems6From the laws, we automatically get the properties of:distributivitySee  -https://en.wikipedia.org/wiki/Heyting_algebra wikipedia for more details.J"FIXME: think carefully about infixMFA Bounded lattice is a lattice with both a minimum and maximum elementP%This is the class of total orderings.See )https://en.wikipedia.org/wiki/Total_orderR6An element of a graded poset has a unique predecessor.See  *https://en.wikipedia.org/wiki/Graded_poset wikipedia for more details.Sthe predecessor in the orderingTAlgebrists typically call this function the "rank" of the element in the poset; however we use the name from the standard prelude insteadUaIn a WellFounded type, every element (except the 'maxBound" if it exists) has a successor elementSee  ncatlab2http://ncatlab.org/nlab/show/well-founded+relation for more info.YSee  1https://en.wikipedia.org/wiki/Lattice_%28order%29 wikipedia for more details.]9This function does not make sense on non-classical logicssFIXME: there are probably related functions for all these other logics; is there a nice way to represent them all?^YRepresents all the possible ordering relations in a classical logic (i.e. Logic a ~ Bool)d'Most Lattice literature only considers MB lattices, but here we have both upper and lower bounded lattices.#minBound <= b || not (minBound > b)g3This is more commonly known as a "meet" semilatticemzDefines equivalence classes over the type. The values need not have identical representations in the machine to be equal.See  /https://en.wikipedia.org/wiki/Equivalence_class wikipedia and  .http://ncatlab.org/nlab/show/equivalence+classncatlab for more details.omIn order to have the "not equals to" relation, your logic must have a notion of "not", and therefore must be Boolean.p=Classical logic is implemented using the Prelude's Bool type.rEvery type has an associated logic. Most types use classical logic, which corresponds to the Bool type. But types can use any logical system they want. Functions, for example, use an infinite logic. You probably want your logic to be an instance of Boolean, but this is not required.See wikipedia's articles on  -https://en.wikipedia.org/wiki/Algebraic_logicalgebraic logic, and  .https://en.wikipedia.org/wiki/Infinitary_logicinfinitary logic for more details.s]Creates a quickcheck property for a simple mutable operator defined using "immutable2mutable"{A"false" is an upper bound because `a && false = false` for all a.@A chain is a collection of elements all of which can be comparedFAn antichain is a collection of elements none of which can be comparedSee  &http://en.wikipedia.org/wiki/Antichain wikipedia for more details.See also the article on  1http://en.wikipedia.org/wiki/Dilworth%27s_theoremDilward's Theorem.>"true" is an lower bound because `a && true = true` for all a.TFIXME: add the axioms for intuitionist logic, which are theorems based on these laws:Modus ponens gives us a default definition for "==>" in a Boolean7 algebra. This formula is guaranteed to not work in a Heyting algebra that is not Boolean.See  *https://en.wikipedia.org/wiki/Modus_ponens wikipedia for more details.CMeasures the degree to which a Semigroup obeys the associative law.VFIXME: Less-than-perfect associativity should be formalized in the class laws somehow.A generalization of $% to an arbitrary E<. May fail to terminate for some values in some semigroups. s .+ a = a +. s_FIXME: this should be in the Monoid class, but putting it there requires a lot of changes to Eq_FIXME: this should be in the Monoid class, but putting it there requires a lot of changes to Eq\FIXME: this should be in the Rig class, but putting it there requires a lot of changes to Eq\FIXME: this should be in the Rig class, but putting it there requires a lot of changes to EqHere we construct an element of the Ring based on the additive and multiplicative identities. This function takes O(n) time, where n is the size of the Integer. Most types should be able to compute this value significantly faster.0FIXME: replace this with peasant multiplication.=FIXME: These functions don't work for Int's, but they shouldBAn alternate form of "(**)" that some people find more convenient.-Calling this function will be faster on some ?s than manually checking if distance is greater than the bound.AThis function constructs an efficient default implementation for 8 given a function that lower bounds the distance metric.Two sets are disjoint if their infimum is the empty set. This function generalizes the notion of disjointness for any lower bounded lattice. FIXME: add other notions of disjoint`A more suggestive name for inserting an element into a container that does not remember locationAA slightly more suggestive name for a container's monoid identityDA slightly more suggestive name for checking if a container is emptyAThis function needed for the OverloadedStrings language extensionTFIXME: if -XOverloadedLists is enabled, this causes an infinite loop for some reason Note: The inverse "theorem" of (toList . fromList) xs == xs is actually not true. See the Set type for a counter example.yFIXME: This law can't be automatically included in the current test system because it breaks parametricity by requiring Monoid (Elem s)2This fold is not in any of the standard libraries.NFor anything foldable, the norm must be compatible with the folding structure.  An infix operator equivalent to _FIXME: there are many semigroups over POrdering; how should we represent the others? newtypes?      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsmutable function3create a mutable function using "immutable2mutable"the output propertytuvwxyz{|}~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOP~@ABCDEFU]^_`abcdefg      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~   krqpmnolktuvghijfwxyYZ[\]X^_`ab|}~deczMNKLIJHRSTPQOUVW{   EFGDABC<=>?@9:;67845312)*+,-./0%&'($ !"#     sA        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABDCFEHGJILKNMPO&'+,./78=>BCFGJ[\ijno None!"%&'()*+,34579>CFIKLNV# )Every Monad has a unique Kleisli categoryFIXME: should this be a GADT?FIXME: right now, we're including any possibly relevant operator in this class; the main reason is that I don't know if there will be more efficient implementations for these in different categories$FIXME: think about do notation again/join ought to have a default implementation of: join = (>>= id)but "id" requires a  ValidCategory9 constraint, so we can't use this default implementation.5In Hask, most people think of monads in terms of the >>=g operator; for our purposes, the reverse operator is more fundamental because it does not require the Concrete constraintThe bind operator is used in desguaring do notation; unlike all the other operators, we're explicitly applying values to the arrows passed in; that's why we need the Concrete constraint-Right-to-left Kleisli composition of monads. (), with the arguments flipped,Left-to-right Kleisli composition of monads.,This class is a hack. We can't include the (>>) operator in the Monad< class because it doesn't depend on the underlying category.oFIXME: Not all monads can be made instances of Applicative in certain subcategories of hask. For example, the OrdHask instance of SetU requires an Ord constraint and a classical logic. This means that we can't support  Set (a -> b)&, which means no applicative instance.There are reasonable solutions to this problem for Set (by storing functions differently), but are there other instances where Applicative is not a monad?A default implementation,This is the only current alternative to the Then class for supporting (>>). The problems with this implementation are: 1. All those ValidCategory constraints are ugly! 2. We've changed the signature of (>>)/ in a way that's incompatible with do notation. REvaluate each action in the sequence from left to right, and collect the results.!QEvaluate each action in the sequence from left to right, and ignore the results."" f is equivalent to   .  f.## f is equivalent to ! .  f.$ This generalizes the list-based filter function.%% is " with its arguments flipped&& is # with its arguments flipped'' act repeats the action infinitely.(( valueN discards or ignores the result of evaluation, such as the return value of an  action.)The ) function maps its first argument over a list, returning the result as a pair of lists. This function is mainly used with complicated data structures or a state-transforming monad.*The * function generalizes Q to arbitrary monads.++ is the extension of * which ignores the final result.,The , function is analogous to ?, except that its result is encapsulated in a monad. Note that ,P works from left-to-right over the list arguments. This could be an issue where ()/ and the `folded function' are not commutative. " foldM f a1 [x1, x2, ..., xm]== P do a2 <- f a1 x1 a3 <- f a2 x2 ... f am xmKIf right-to-left evaluation is required, the input list should be reversed.-Like ,, but discards the result... n act performs the action n times, gathering the results./Like ., but discards the result.0:Conditional execution of monadic expressions. For example, ' when debug (putStr "Debugging\n")will output the string  Debugging\n if the Boolean value debug is , and otherwise do nothing.1The reverse of 0.2Promote a function to a monad.3`Promote a function to a monad, scanning the monadic arguments from left to right. For example, N liftM2 (+) [0,1] [0,2] = [0,2,1,3] liftM2 (+) (Just 1) Nothing = Nothing4WPromote a function to a monad, scanning the monadic arguments from left to right (cf. 3).5WPromote a function to a monad, scanning the monadic arguments from left to right (cf. 3).6WPromote a function to a monad, scanning the monadic arguments from left to right (cf. 3).7In many situations, the 2' operations can be replaced by uses of 7&, which promotes function application. ' return f `ap` x1 `ap` ... `ap` xnis equivalent to  liftMn f x1 x2 ... xn-   !"#$%&'()*+,-./012345678,   !"#$%&'()*+,-./01234567-  8 !"#$%&'()*+,-./01234567"   !"#$%&'()*+,-./012345678 None!"%&'()*+,34579>CFIKLNV 9jA Partitionable container can be split up into an arbitrary number of subcontainers of roughly equal size.:The Int must be >0<Converts any monoid homomorphism into an efficient parallelized function. This is the only function you should have to care about. It uses rewrite rules to select the most cache-efficient parallelization method for the particular data types called.=BLet's you specify the exact number of threads to parallelize over.?kLet's you specify the exact number of threads to parallelize over. This function is unsafe because if our range is not Abelian$, this function changes the results.@This function automatically detects the number of available processors and parallelizes the function accordingly. This function is unsafe because if our range is not Abelian$, this function changes the results.AThis function automatically detects the number of available processors and parallelizes the function accordingly. This function is safe (i.e. it won't affect the output) because it requires the Abelian constraint.BeThis forces a function to be run with only a single thread. That is, the function is executed as if -N1r was passed into the program rather than whatever value was actually used. Subsequent functions are not affected.Why is this useful? The GHC runtime system can make non-threaded code run really slow when many threads are enabled. For example, I have found instances of sequential code taking twice as long when the -N16 flag is passed to the run time system. By wrapping those function calls in "disableMultithreading", we restore the original performance.RLike foldtree1, but parallelSThis is an alternative definition for list partitioning. It should be faster on large lists because it only requires one traversal. But it also breaks parallelism for non-commutative operations.9:;<sequential monoid homomorphismparallel monoid homomorphismTnumber of parallel threadssequential monoid homomorphismparallel monoid homomorphism=number of parallel threadssequential monoid homomorphismparallel monoid homomorphism>sequential monoid homomorphismparallel monoid homomorphism?number of parallel threadssequential monoid homomorphismparallel monoid homomorphism@sequential monoid homomorphismparallel monoid homomorphismAsequential monoid homomorphismparallel monoid homomorphismBCDRUSV 9:;<=>?@ABCD <B9:;CD=>?@A9:;<T=>?@ABCDRUSV None!"%&'()*+,34579>CFIKLNVL{FIXME: for some reason, our deriving mechanism doesn't work on Show here; It causes's Set's show to enter an infinite loopEFGHIJKLEFGIEFGHLILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILILIKJEFGHJKLINone!"%&'()*+,34579>CFIKLNVP3The type of equivalence classes created by a mod b.RBMaps members of an equivalence class into the "canonical" element.X Galois p kY is the type of integers modulo p^k, where p is prime. All finite fields have this form.See wikipedia  *https://en.wikipedia.org/wiki/Finite_field for more details.|FIXME: Many arithmetic operations over Galois Fields can be implemented more efficiently than the standard operations. See  4http://en.wikipedia.org/wiki/Finite_field_arithmetic.ZThe type of integers modulo n\OExtended Euclid's algorithm is used to calculate inverses in modular arithmeticiThe Vedic Square always forms a monoid, and sometimes forms a group depending on the value of "n". (The type system isn't powerful enough to encode these special cases.)See  *https://en.wikipedia.org/wiki/Vedic_square wikipedia for more detail.kThe symmetric group is one of the simplest and best studied finite groups. It is efficiently implemented as a "BijectiveT SparseFunction (Z n) (Z n)". See -https://en.wikipedia.org/wiki/Symmetric_groupXThe GrothendieckGroup is a general way to construct groups from cancellative semigroups.4FIXME: How should this be related to the Ratio type?See  /http://en.wikipedia.org/wiki/Grothendieck_group wikipedia for more details.5MNOPQRSTUVWXYZ[\W]^_X`abcdefghijklmnopqrstuvwxyz{|}~MNOPQRSTXYZ[\ijklmn|MNOWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTWTVRSPQUh[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[h[gfedcba`_Z^]\XY{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{n{nzymxwvutsrqpoklij|||||||||||||||||||||||||||~}*MNOPQRSUVWTXYZ\W]^_X`abcdefgh[ijklmopqrstuvwxyz{n}~|None!"%&'()*+,34579>CFIKLNV}The closed balls in metric space. Note that since we are not assuming any special structure, addition is rather inefficient.FIXME: There are several valid ways to perform the addition; which should we use? We could add Lattice instances in a similar way as we could with Box if we added an empty element; should we do this?$Useful for identifying tree metrics.&There are three distinct perfect matchings in every complete 4 node graph. A metric is a tree metric iff two of these perfect matchings have the same weight. This is called the 4 points condition. printQuadDistances :: (Ord (Scalar m), Show (Scalar m), Metric m) => m -> m -> m -> m -> IO ()nFIXME: In a Banach space we can make Ball addition more efficient by moving the center to an optimal location.YZ[\ YZ[\None!"%&'()*+,34579>CFIKLNVThe 7 class is a newtype wrapper around the natural numbers Z.0FIXME: remove this layer; I don't think it helpsRA type is finite if there is a bijection between it and the natural numbers. The 'index'/'deZIndex'$ functions implement this bijection.QRepresents finite functions as a hash table associating input/output value pairs.DRepresents finite functions as a map associating input/output pairs.]*Swap the phantom type between two indices.'Generates a sparse representation of a ` function. This proof will always succeed, although it may be computationally expensive if the  of a and b is large.7Generate sparse functions on some subset of the domain.&Generates a dense representation of a < function. This proof will always succeed; however, if the P of the finite types are very large, it may take a long time. In that case, a ' is probably the better representation.^_`abc]defghi  ^_`ab]defghicNone!"%&'()*+,34579>CFIKLNVFIXME:  Polynomial_> takes two type parameters in order to be compatible with the Category hierarchy of classes. But currently, both types must match each other. Can/Should we generalize this to allow polynomials between types?/The type of polynomials over an arbitrary ring.See  .https://en.wikipedia.org/wiki/Polynomial__ring wikipedia for more detail.)jkl *$jklNone!"%&'()*+,34579>CFIKLNVNone!"%&'()*+,34579>CFIKLNV=Bijective functions are both injective and surjective. See  0https://en.wikipedia.org/wiki/Bijective_function wikipedia for more detail.HSurjective (onto) functions can take on every value in the range. See  1https://en.wikipedia.org/wiki/Surjective_function wikipedia for more detail.KInjective (one-to-one) functions map every input to a unique output. See  0https://en.wikipedia.org/wiki/Injective_function wikipedia for more detail.!mnopqrstuvwxyz{|}~  mnopqrstuvwxyz{|}~None!"%&'()*+,34579>CFIKLNVNone!"%&'()*+,34579>CFIKLNVA convenient specialization of MonT and Hask!%None!"&'()*+,34579>CFIKLNVDerives instances for all data types in scope. This is the only function you should need to use. The other functions are exported only for debugging purposes if this function should fail.HConstructs an instance using the given function for everything in scope.nThis is an internal helper function. It prevents us from defining two instances for the same class/type pair. Create an Eq instance from a  Prelude.Eq instance. Create a Functor instance from a Prelude.Functor instance. Create an  Applicative instance from a Prelude.Applicative instance. Create a Monad instance from a  Prelude.Monad instance.TFIXME: Monad transformers still require their parameter monad to be an instance of  Prelude.Monad.   &None!"&'()*+,34579>CFIKLNVNone!"%&'()*+,34579>CFIKLNVJThe type of dynamic or statically sized vectors implemented using the FFI. JThe type of dynamic or statically sized vectors implemented using the FFI.$does the foreign pointer equal null?4allocates a ForeignPtr that is filled with n "zero"s=A slightly more convenient type for linear functions between SVectors Construct an SMatrix           !"#$%&'()*+,-./01                      !"#$%&'()*+,-./01None!"%&'()*+,34579>CFIKLNVG23456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst?2345679:;<=>?@ABCDEFGHIJKLM8STNUVOWXYPZ[Q\]^_`abcdefghijklmnopqrstRNone!"%&'()*+,34579>CFIKLNV.This is essentially just a translation of the Numeric.AD.Forward.Forward2 type for use with the SubHask numeric hierarchy.FIXME:>Add reverse mode auto-differentiation for vectors. Apply the ProofOf framework from Monotonic6 !"#$%&'()*+,f(x)f'(x)-f(x)f'(x)f''(x)./0123456789:;<=>?@ABCDEFGHIJKLM !"#$%&'()*+,-F:E(E(DCBA@?>=<)*%&'"#$;:9876543210/.+,-! MFMFLKJIHG- !"#$%&')*+,-./0123456789:;<=>?@ABCDE(GHIJKLMFNone!"%&'()*+,34579>CFIKLNVNA N is a generalization of an interval from the real numbers into an arbitrary lattice. Boxes are closed in the sense that the end points of the boxes are also contained within the box.See  ;http://en.wikipedia.org/wiki/Partially_ordered_set#Interval wikipedia for more details.RThe Jaccard distance.See  +https://en.wikipedia.org/wiki/Jaccard_index wikipedia for more detail.\The Hamming distance.See  .https://en.wikipedia.org/wiki/Hamming_distance wikipedia for more detail.afThe Levenshtein distance is a type of edit distance, but it is often referred to as THE edit distance.FIXME: The implementation could be made faster in a number of ways; for example, the Hamming distance is a lower bound on the Levenshtein distanceSee  2https://en.wikipedia.org/wiki/Levenshtein_distance wikipedia for more detail.f:Compensated sums are more accurate for floating point mathZFIXME: There are many different types of compensated sums, they should be implemented too.FIXME: Is this the best representation for compensated sums? The advantage is that we can make any algorithm work in a compensated or uncompensated manner by just changing the types. This is closely related to the measure theory containers work. See, e.g.  7https://en.wikipedia.org/wiki/Kahan_summation_algorithmkahan summation for more detail.ithis function stolen from 1https://www.haskell.org/haskellwiki/Edit_distancel#Lexical ordering of foldable types.NOTE: The default ordering for containers is the partial ordering by inclusion. In most cases this makes more sense intuitively. But this is NOT the ordering in the Prelude, because the Prelude does not have partial orders. Therefore, in the prelude, @ "abc" < "def"0@, but for us, "abc" and "def" are incomparable PNAK. The Lexical newtype gives us the total ordering provided by the Prelude.NFIXME: there are more container orderings that probably deserve implementation8NOPQRSTUVWXYZuvwx[\]^_`abcdefghijklmnopqrstuvwxyz{|}~NOPQRSTU\]^abcfghilmnorstu{|NOPQ[T[TUZYXWVRS`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^`^_\]ececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececececdabkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhkhjifgqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoqoplmnzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuzuyxwvrst||||||||||||||||||||||||||||||||||||||||||||||||||||{~}&NOPQRSUVWXYZuvwx[T\]_`^abdecfgijkhlmnpqorstvwxyzu{}~|None!"%&'()*+,34579>CFIKLNVThe Goedel fuzzy logic is one of the simpler fuzzy logics. In particular, it is an example of a Heyting algebra that is not also a Boolean algebra.See the &plato.stanford.edu/entries/logic-fuzzystandford encyclopedia of logicA Boolean algebra is a special type of Ring. Their applications (set-like operations) tend to be very different than Rings, so it makes sense for the class hierarchies to be completely unrelated. The  Boolean2Ring4 type, however, provides the correct transformation.K3 stands for Kleene's 3-valued logic. In addition to true and false, there is a value to represent whether something's truth is unknown. K3 is an example of a logic that is neither Boolean nor Heyting.See  /http://en.wikipedia.org/wiki/Three-valued_logic wikipedia.gFIXME: We need a way to represent implication and negation for logics outside of the Lattice hierarchy.H3 is the smallest Heyting algebra that is not also a boolean algebra. In addition to true and false, there is a value to represent whether something's truth is unknown. AFAIK it has no real applications.See 6https://en.wikipedia.org/wiki/Heyting_algebra#Examples wikipedia6yz,yzNone!"%&'()*+,34579>CFIKLNV{|}~ {}~|None!"%&'()*+,34579>CFIKLNV+This is a thin wrapper around Data.Sequence&This is a thin wrapper around Data.Map-This is a thin wrapper around Data.Map.Strict)This is a thin wrapper around Data.IntMap0This is a thin wrapper around Data.IntMap.Strict6This is a thin wrapper around the container's set type"FIXME: implement this in terms of Lexical and SetFIXME: add the  Constrained Monad0FIXME: is there a more efficient implementation?       w       }     None!"%&'()*+,34579>CFIKLNV  !"#$%&' !"  !'"'"&%$#  !#$%&'"None!"%&'()*+,34579>CFIKLNVmFGHI JKLMNOPQRS !"#$%&TUVWXYZ[\]^_`'()*+,-./01abcdefghijklmnopqrstuvwxyz{|}~2345678@ABCDEFIJKLMNOPQRSU]^_`abcdefgrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./01234567765432$/.-,+*)('0    %&817JI#"!None!"%&'()*+,34579>CFIKLNV(The type of lazy byte strings.(FIXME: Add strict byte strings as type  ByteString')FIXME: Make this generic by moving some of the BS functions into the Foldable/Unfoldable type classes. Then move this into Algebra.Containers.CFIXME: Make generic method "readFile" probably using cereal/binary()*+,-./0123456789:;<=>()*+,-.<(;-;-:+,9876543210/.)*><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><=()*./0123456789:+,;-=><None!"%&'()*+,34579>CFIKLNV?AThis is a monoid homomorphism, which means it can be parallelized@=Like the "decode" function in Data.Csv, but works in parallel?@ 9:;<=>??@ ?@9:;<?>=?@'()'(*'+,-./'(0'(1'+2'34'56-78-79-7:-7;-7<'=>'=?'=@'=ABCD-7E'FG-7H'IJ-.K'(L-7M-7N'IO'IP-7Q-7R-7S'TUVWXVWYVWZ'[\'(]'(^'_`'_a'_b'_c'_d'_e'_f'_g'_h'ij'kl'3m'3n'5o'5p'5q'(r'(stuvtuwtuxtuytz{tz|tz|}~}~}~}~!!                           !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|"}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGH I 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 { | } ~          ee#       !"#$%&'()*+,-./0123456789:;<<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsttuvwwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>??@ABCDEFGHIJKLMNOPQRSTU V W XYZ'[\'[]'^_'^`'^a'^b'^'^u'^'^c'^{'^d'^e'[f'^g'^h'^i'^j'^k'^l'^m'^n'^o'^o'^p'^p'^'qr'qs'qt'qu'qv'[w'[x'[y'[z'[{'[|'[}'[~'['['['['['['['['['['['['['['['['['['['['['['['['['''''''^                %      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ['\] ^ _ ` a bcdefghijklmnopqrstuvwxyz{|}~&&&&&&&&&&&&&&&&&&&&&&&&&      !"#$%&'()*+,-./0123456789:;=<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~subha_EeiVTLuZZKl0kwhGyiXsU8SubHaskSubHask.AlgebraSubHask.Compatibility.CassavaSubHask.MutableSubHask.TemplateHaskell.MutableSubHask.SubType SubHask.TemplateHaskell.DerivingSubHask.TemplateHaskell.TestSubHask.CategorySubHask.Category.Product SubHask.MonadSubHask.Algebra.ParallelSubHask.Algebra.OrdSubHask.Algebra.GroupSubHask.Algebra.MetricSubHask.Category.FiniteSubHask.Category.PolynomialSubHask.Category.Slice SubHask.Category.Trans.Bijective"SubHask.Category.Trans.Constrained SubHask.Category.Trans.MonotonicSubHask.TemplateHaskell.BaseSubHask.Algebra.VectorSubHask.Algebra.Array!SubHask.Category.Trans.DerivativeSubHask.Algebra.ContainerSubHask.Algebra.Logic!SubHask.Compatibility.BloomFilter SubHask.Compatibility.Containers!SubHask.Compatibility.HyperLogLog SubHask.Compatibility.ByteStringSubHask.TemplateHaskell.CommonSubHask.Internal.PreludeMonoidSlice Data.ListcycleSubHask.Compatibility.BasebaseGHC.Base++buildGHC.Errerrorghc-primGHC.Primseq otherwisemap undefinedGHC.ReadReadGHC.ShowShow GHC.TypesBoolCharDoubleFloatIntGHC.IntInt8Int16Int32Int64 integer-gmpGHC.Integer.TypeIntegerOrderingGHC.RealRationalIO Data.EitherEither ConstraintStringFalseTrueLeftRightLTEQGTGHC.STSTQuick_1fWvpr9QgXz0phpE20gfU8Test.QuickCheck.Arbitraryshrink arbitrary Arbitrary Text.ReadreadMaybeNothingForeign.Storablepokepeek pokeByteOff peekByteOff pokeElemOff peekElemOff alignmentsizeOfStorableGHC.IOFilePath Data.FoldableallreadList readsPrecshowListshow showsPrecasTypeOfJustcassa_ALp8SDPnhvM264PUJysACOData.Csv.Conversion FromRecordToRecord FromFieldToFieldData.Csv.TypesNoHeader HasHeadermonad_1LiI6fUdivMJ2EDMRYqfWW Data.PrimRef writePrimRef readPrimRef newPrimRefPrimRefprimi_3d4UsQu7pJCEtlsxN3gLjkControl.Monad.Primitive PrimStatePrimBase mkMutablemkMutableNewtypemkMutablePrimRef ifThenElseassertEmbed<: embedType_Sup embedType embedType1 embedType2 mkSubtypemkSubtypeInstance BasicType helper_liftM helper_idlistSuperClassesderiveTypefamiliesderiveHierarchyderiveHierarchyFilteredderiveSingleInstance fromPreludeEq IsMutablefreezethawwritecopy unsafeFreeze unsafeThawMutableimmutable2mutablemutable2immutableunsafeRunMutablePropertytestMap mkClassTestsmkSpecializedClassTestmkSpecializedClassTestsspecializeType specializeLawmkTestmkTests listExp2ExpextractTestStrProofOf_Provable$$ProofOfDaggertransCompactDualunitcounitGroupoidinverseClosedcurryuncurryflip Cartesianfst_snd_terminalinitial SymmetricBraidedbraidunbraidMonoidalTensorTUnittensortunitConcreteHaskCategory ValidCategoryid.>>><<<$$! embedHask embedHask2 withCategoryembed2fstsndconstconst2><Product $fCategoryk><Labeled' xLabeled' yLabeled'Maybe'Nothing'Just' fromJust'IxConstructible singletonAtconsAtsnocAt fromIxList Sliceableslice IxContainer ValidElemlookup!findWithDefaulthasIndeximaptoIxListindicesvaluesSetIndexIndexFoldabletoListunconsunsnocsumfoldMapfoldrfoldr'foldlfoldl'foldr1foldr1'foldl1foldl1' ContainerelemnotElem Constructible singletonconssnoc fromList1 fromList1NSetElemElemCanErrorerrorValisErrorisJustMetricdistance distanceUB TensorAlgebravXmmXvHilbert<>Banach normalize VectorSpace././../=./.= FiniteModuledimunsafeToModule FreeModule.*..*.=onesModule.*.*=Cone*....*..Normedsize sizeSquared HasScalarIsScalarScalarRealgammalnGammaerfpisincostanasinacosatansinhcoshtanhasinhacoshatanhExpFieldsqrtexplogExpRing**logBase QuotientFieldtruncateroundceilingfloor^^ RationalField toRational BoundedFieldnanisNaNOrdFieldField reciprocal/ fromRationalIntegral toIntegerquotremquotRemdivmoddivModRing fromIntegerRngRigoneRg**=AbelianGroupnegate Cancellative--=zeroAction.+.+=Actor Semigroup++=BooleanHeyting==> ComplementednotBoundedmaxBoundOrdOrd_compareGradedpredfromEnumEnumsucctoEnumLatticeLattice_sup>=>pcompare POrderingPLTPGTPEQPNAMinBound MinBound_minBoundPOrdPOrd_inf<=<ValidEqEqEq_==/=ClassicalLogic ValidLogicLogicsimpleMutableDefnlaw_Eq_reflexivelaw_Eq_symmetriclaw_Eq_transitivelaw_POrd_commutativelaw_POrd_associativetheorem_POrd_idempotentlaw_MinBound_inffalselaw_Lattice_commutativelaw_Lattice_associativetheorem_Lattice_idempotentlaw_Lattice_infabsorptionlaw_Lattice_supabsorptionlaw_Lattice_reflexivitylaw_Lattice_antisymmetrylaw_Lattice_transitivitydefn_Lattice_greaterthan&&||isChain isAntichain law_Enum_succlaw_Enum_toEnumlaw_Graded_predlaw_Graded_fromEnumlaw_Ord_totality law_Ord_min law_Ord_maxminmaxlaw_Bounded_suptruelaw_Complemented_notlaw_Heyting_maxboundlaw_Heyting_infleftlaw_Heyting_infrightlaw_Heyting_distributive modusPonenslaw_Boolean_infcomplementlaw_Boolean_supcomplementlaw_Boolean_infdistributivitylaw_Boolean_supdistributivitylaw_Semigroup_associativitydefn_Semigroup_plusequallaw_Action_compatibilitydefn_Action_dotplusequal+.isZeronotZerolaw_Monoid_leftidlaw_Monoid_rightiddefn_Monoid_isZerolaw_Cancellative_rightminus1law_Cancellative_rightminus2defn_Cancellative_plusequaldefn_Group_negateminuslaw_Group_leftinverselaw_Group_rightinverselaw_Abelian_commutative"law_Rg_multiplicativeAssociativity law_Rg_multiplicativeCommutivitylaw_Rg_annihilationlaw_Rg_distributivityLefttheorem_Rg_distributivityRightdefn_Rg_timesequalisOnenotOnelaw_Rig_multiplicativeIddefn_Ring_fromInteger indicatorlaw_Integral_divModlaw_Integral_quotRemlaw_Integral_toFromInverse fromIntegralinfinity negInfinityconvertRationalFieldtoFloattoDouble^abslaw_Module_multiplicationlaw_Module_additionlaw_Module_actionlaw_Module_unitaldefn_Module_dotstarequal*.law_FreeModule_commutativelaw_FreeModule_associativelaw_FreeModule_iddefn_FreeModule_dotstardotequalinnerProductNorminnerProductDistance isFartherThan lb2distanceUBlaw_Metric_nonnegativitylaw_Metric_indiscernableslaw_Metric_symmetrylaw_Metric_triangledefn_Constructible_fromListdefn_Constructible_fromListNdefn_Constructible_consdefn_Constructible_snocinsertemptyisEmpty fromStringfromList fromListNlaw_Container_preservationlaw_Constructible_singletontheorem_Constructible_consdefn_Foldable_foldrdefn_Foldable_foldr'defn_Foldable_foldldefn_Foldable_foldl'defn_Foldable_foldr1defn_Foldable_foldr1'defn_Foldable_foldl1defn_Foldable_foldl1'theorem_Foldable_tofromlaw_Foldable_sum foldtree1reducelengthandorargminargmaxmaximummaximum_minimumminimum_supremum supremum_infimuminfimum_concat headMaybe tailMaybe lastMaybe initMaybelaw_IxContainer_preservationdefn_IxContainer_bang defn_IxContainer_findWithDefaultdefn_IxContainer_hasIndexlaw_IxConstructible_lookupdefn_IxConstructible_consAtdefn_IxConstructible_snocAtdefn_IxConstructible_fromIxListinsertAt!?KleisliMonadreturn_join=<<>>=<=<>=>Then>> Applicativepure<*>FunctorfmaphaskThenmkThenreturnfailsequence sequence_mapMmapM_filterMforMforM_forevervoid mapAndUnzipMzipWithM zipWithM_foldMfoldM_ replicateM replicateM_whenunlessliftMliftM2liftM3liftM4liftM5ap$fCategory*Kleisli Partitionable partitionpartitionInterleavedparallelparallelBlockedNparallelBlockedunsafeParallelInterleavedNunsafeParallelInterleavedparallelInterleaveddisableMultithreadinglaw_Partitionable_lengthlaw_Partitionable_monoidWithPreludeOrdunWithPreludeOrd$fShowWithPreludeOrdMutable_WithPreludeOrd$fOrdWithPreludeOrd$fEqWithPreludeOrdTFCo:R:ActorWithPreludeOrd NonNegative unNonNegativeModQuotient mkQuotientMutable_NonNegative $fArbitrary/$fCancellativeNonNegativeTFCo:R:ActorNonNegativeGaloisZ Mutable_ModextendedEuclid$fQuotientNatIntegern$fQuotientNatIntn $fModule/$fRing/$fRig/$fRg/$fGroup/$fCancellative/ $fMonoid/ $fAbelian/ $fSemigroup/ TFCo:R:Actor/ VedicSquareGrothendieckGroupGrotheindieckGroupPrimeMutable_Galois $fPrime23 $fPrime19 $fPrime17 $fPrime13 $fPrime11$fPrime7$fPrime5$fPrime3$fPrime2$fPrime1 $fFieldGalois$fModuleGaloisTFCo:R:ActorGaloisMutable_VedicSquare$fMonoidVedicSquare$fSemigroupVedicSquareTFCo:R:ActorVedicSquareBallradiuscenterprintTriDistancesprintQuadDistances BanachBallCMutable_AppT__ConT_SubHask_Algebra_Metric_Ball___VarT_b_1627650421_invar_Ball_radius$fContainerBall$fConstructibleBall$fSemigroupBall $fEq_Ball $fNFDataBall$fArbitraryBallTFCo:R:MutablemBallZIndex FiniteTypeOrderindexdeZIndex enumerategetOrder DenseFunctionSparseFunctionMonoidSparseFunctionproveSparseFunctionlist2sparseFunctionproveDenseFunction Polynomial_ Polynomial unProofOfjMutable_AppT__AppT__ConT_SubHask_Category_Polynomial_Polynomial____VarT_a_1627667776____VarT_b_1627667777_TFCo:R:ProofOf*Polynomial_a$fShowPolynomial_TFCo:R:MutablemPolynomial_vMutable_AppT__AppT__ConT_SubHask_Category_ProofOf___ConT_SubHask_Category_Polynomial_Polynomial_____VarT_a_1627668165_provePolynomialsumListpowevalPolynomial_$f<:(->)Polynomial_(->)$fSup(->)(->)Polynomial_(->)$fSup(->)Polynomial_(->)(->)$fCategory*Polynomial_$fFreeModulePolynomial_$fModulePolynomial_$fRingPolynomial_$fRigPolynomial_$fRgPolynomial_$fAbelianPolynomial_$fGroupPolynomial_$fCancellativePolynomial_$fMonoidPolynomial_$fSemigroupPolynomial_$fEq_Polynomial_ $fRingProofOf $fRigProofOf $fRgProofOf$fGroupProofOf$fAbelianProofOf$fMonoidProofOf$fCancellativeProofOf$fSemigroupProofOfTFCo:R:MutablemProofOfCommarunSlice $fCategory*/$fCategorykComma BijectiveT Bijective SurjectiveT Surjective InjectiveT InjectiveunsafeProveInjectiveunsafeProveSurjectiveproveBijectiveunsafeProveBijective ConstrainedTOrdHaskEqHaskproveConstrained proveEqHask proveOrdHask IncreasingTMutable_AppT__AppT__AppT__ConT_SubHask_Category_Trans_Monotonic_IncreasingT___VarT_cat_1627684843____VarT_a_1627684844____VarT_b_1627684845_TFCo:R:ProofOf*IncreasingTa$fProvableIncreasingT$fAbelianIncreasingT$fSemigroupIncreasingT$f<:(->)IncreasingTcat$fSup(->)aIncreasingTc$fSup(->)IncreasingTbc$fCategory*IncreasingTTFCo:R:MutablemIncreasingTMonTValidMonMon Increasing_ IncreasingMutable_AppT__AppT__ConT_SubHask_Category_ProofOf___AppT__ConT_SubHask_Category_Trans_Monotonic_IncreasingT___VarT_cat_1627685386_____VarT_a_1627685385_proveIncreasingunsafeProveIncreasingunsafeProveMonTunsafeProveMon$f<:(->)MonTcat$fSup(->)aMonTc$fSup(->)MonTbc$fCategory*MonT$f<:*(->)IncreasingT deriveAll forAllInScoperunIfNotInstance mkPreludeEqmkPreludeFunctormkPreludeApplicativemkPreludeMonad $fEq_Type$fEq_Dec $fEq_Name+>SVectorUVectorUnboxdistanceUB_l2_m128distance_l2_m128 distance_l2_m128_UVector_Dynamic"distanceUB_l2_m128_UVector_Dynamic distance_l2_m128_SVector_Dynamic"distanceUB_l2_m128_SVector_DynamicsafeNewByteArraySMatrixunsafeMkSMatrixBArrayUArray UnboxableForwardvalval'C2_C2C1_C1C0_C0DiffDiff0DiffnCD derivativeQMutable_AppT__ConT_SubHask_Category_Trans_Derivative_Forward___VarT_a_1628002786_proveC1proveC2 unsafeProveC0 unsafeProveC1 unsafeProveC2$fCDiff$f<:(->)DiffDiff$fSup(->)DiffDiffDiff$fSup(->)DiffDiffDiff0$f<:(->)DiffDiff0$fSup(->)DiffDiffDiff1$fSup(->)DiffDiffDiff2$f<:(->)DiffDiff1$fSup(->)DiffDiffDiff3$fSup(->)DiffDiffDiff4$f<:(->)Diff(->)$f<:(->)Diff(->)0$fSup(->)Diff(->)(->)$fSup(->)(->)Diff(->)$fFieldForward $fRingForward $fRigForward $fRgForward$fAbelianForward$fGroupForward$fMonoidForward$fCancellativeForward$fSemigroupForwardTFCo:R:MutablemForwardMutable_AppT__AppT__AppT__ConT_SubHask_Category_Trans_Derivative_Diff___VarT_n_1628004304____VarT_a_1628004305____VarT_b_1628004306_ $fMonoidDiff $fMonoidDiff0 $fMonoidDiff1$fSemigroupDiff$fSemigroupDiff0$fSemigroupDiff1TFCo:R:MutablemDiffBoxsmallestlargestJaccardEMutable_AppT__ConT_SubHask_Algebra_Container_Box___VarT_v_1628010546_invar_Box_ordered$fContainerBox$fConstructibleBox$fSemigroupBox$fEq_Box$fArbitraryBoxTFCo:R:MutablemBoxHammingMutable_Jaccard$fMetricJaccardTFCo:R:ActorJaccard LevenshteinMutable_Hamming$fMetricHammingTFCo:R:ActorHamming UncompensatedMutable_Levenshteindist$fMetricLevenshteinTFCo:R:ActorLevenshteinLexical unLexicalMutable_Uncompensated$fFoldableUncompensatedTFCo:R:ActorUncompensated ComponentWiseunComponentWiseMutable_Lexical $fOrd_Lexical$fLattice_Lexical$fMinBound_Lexical$fPOrd_LexicalTFCo:R:ActorLexicalSimpleContainerLogicMutable_ComponentWise$fLattice_ComponentWise$fMinBound_ComponentWise$fPOrd_ComponentWise$fSimpleContainerLogicaTFCo:R:ActorComponentWiseGoedel_GoedelOrdRing_ $fOrdRing_r Boolean2RingK3KTrueKFalseKUnknownH3HTrueHFalseHUnknownMutable_Goedel_ $fBoundedK3 $fMinBound_K3$fOrd_K3 $fLattice_K3 $fPOrd_K3$fEq_K3 $fArbitraryK3 $fNFDataK3 $fHeytingH3 $fBoundedH3 $fMinBound_H3$fOrd_H3 $fLattice_H3 $fPOrd_H3$fEq_H3 $fArbitraryH3 $fNFDataH3$fHeytingGoedel_$fBoundedGoedel_$fMinBound_Goedel_ $fOrd_Goedel_$fLattice_Goedel_$fPOrd_Goedel_$fArbitraryGoedel_TFCo:R:ActorGoedel_Mutable_Boolean2RingmkBoolean2Ring$fRingBoolean2Ring$fRigBoolean2Ring$fRgBoolean2Ring$fGroupBoolean2Ring$fCancellativeBoolean2Ring$fMonoidBoolean2Ring$fAbelianBoolean2Ring$fSemigroupBoolean2RingTFCo:R:ActorBoolean2Ring BloomFilterSeqMapLMutable_AppT__ConT_SubHask_Compatibility_Containers_Seq___VarT_a_1628093734_$fPartitionableSeq $fFoldableSeq$fConstructibleSeq$fContainerSeq $fMonoidSeq$fSemigroupSeq$fMinBound_Seq $fPOrd_Seq$fEq_Seq $fNormedSeq$fArbitrarySeqTFCo:R:MutablemSeqMap'gMutable_AppT__AppT__ConT_SubHask_Compatibility_Containers_Map___VarT_i_1628094878____VarT_e_1628094879_$fIxConstructibleMap$fIxContainerMap $fNormedMap $fMonoidMap$fSemigroupMap$fMinBound_Map $fPOrd_Map$fEq_Map$fArbitraryMapTFCo:R:MutablemMapIntMaphMutable_AppT__AppT__ConT_SubHask_Compatibility_Containers_Map'___VarT_i_1628096019____VarT_e_1628096020_$fIxConstructibleMap'$fIxContainerMap' $fNormedMap' $fMonoidMap'$fSemigroupMap'$fMinBound_Map' $fPOrd_Map' $fEq_Map'$fArbitraryMap'TFCo:R:MutablemMap'IntMap'OMutable_AppT__ConT_SubHask_Compatibility_Containers_IntMap___VarT_a_1628097182_$fIxContainerIntMap$fIxConstructibleIntMap$fNormedIntMap$fMonoidIntMap$fSemigroupIntMap$fMinBound_IntMap $fPOrd_IntMap $fEq_IntMap$fArbitraryIntMapTFCo:R:MutablemIntMapSetPMutable_AppT__ConT_SubHask_Compatibility_Containers_IntMap'___VarT_a_1628098079_$fIxContainerIntMap'$fIxConstructibleIntMap'$fNormedIntMap'$fMonoidIntMap'$fSemigroupIntMap'$fMinBound_IntMap'$fPOrd_IntMap' $fEq_IntMap'$fArbitraryIntMap'TFCo:R:MutablemIntMap'LexSetLMutable_AppT__ConT_SubHask_Compatibility_Containers_Set___VarT_a_1628098888_ $fFoldableSet$fConstructibleSet$fContainerSet $fAbelianSet $fMonoidSet$fSemigroupSet $fLattice_Set$fMinBound_Set $fPOrd_Set$fEq_Set $fNormedSet$fArbitrarySetTFCo:R:MutablemSetOMutable_AppT__ConT_SubHask_Compatibility_Containers_LexSet___VarT_a_1628099839_liftPreludeOrd $fThen*LexSet$fMonadMonTLexSet$fFunctor*MonTLexSet$fMonadConstrainedTLexSet$fFunctor*ConstrainedTLexSet$fFoldableLexSet$fMinBound_LexSet$fNormedLexSet$fConstructibleLexSet$fContainerLexSet$fMonoidLexSet$fSemigroupLexSet $fOrd_LexSet$fLattice_LexSet $fPOrd_LexSet $fEq_LexSet $fShowLexSetTFCo:R:MutablemLexSet HyperLogLogHpMutable_AppT__AppT__ConT_SubHask_Compatibility_HyperLogLog_HyperLogLog___VarT_p_1628142800____VarT_a_1628142801_$fConstructibleHyperLogLog$fNormedHyperLogLog$fAbelianHyperLogLog$fSemigroupHyperLogLogTFCo:R:MutablemHyperLogLog ByteStringPartitionOnNewlineBSLCunBSLCSMutable_AppT__ConT_SubHask_Compatibility_ByteString_ByteString___VarT_a_1628145375_readFileByteString$fPartitionableByteString$fFoldableByteString$fNormedByteString$fConstructibleByteString$fContainerByteString$fMonoidByteString$fSemigroupByteString$fMinBound_ByteString$fPOrd_ByteString$fEq_ByteString$fArbitraryByteStringTFCo:R:ByteStringCharTFCo:R:MutablemByteStringMutable_PartitionOnNewline!$fPartitionablePartitionOnNewlineTFCo:R:ActorPartitionOnNewlinedecode_decode bndr2typeisStar apply2varlistshowtype type2nameData.Typeable.InternalmkAppTyTypeable GHC.TypeLitsKnownNat KnownSymbolNatSymbol<=? CmpSymbolCmpNatTypeRep sameSymbolsameNat someSymbolVal someNatVal symbolVal'natVal' symbolValnatValSomeNat SomeSymbol Data.Typeablegcast2gcast1gcasteqTcastrnfTyCon rnfTypeRep showsTypeReptypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1typeOftypeReptypeRepFingerprint tyConString typeRepArgs typeRepTyConmkTyCon3 funResultTy splitTyConAppmkFunTy mkTyConApp tyConName tyConModule tyConPackagetyConFingerprintTyCon Typeable1 Typeable2 Typeable3 Typeable4 Typeable5 Typeable6 Typeable7 Data.Proxy asProxyTypeOfProxyKProxyData.Type.EqualityRefl:~:deeps_LbCWUlehDDeLxurARKDH5oControl.DeepSeqforce$!!deepseqrnfNFDatalaw_Subtype_f1 stripForallmkSupWhenIfEmbed2unEmbed2Embed1unEmbed1Embed0unEmbed0law_Subtype_f2 apEmbedType1 apEmbedType2 $f<:(->)aaTFCo:R:Embed(->)st $f<:(->)aa0TFCo:R:Embed(->)st0$f<:*aaTFCo:R:Embed*st $fSupksss tuple2list expandTySyn substitutePatsubstituteVarEreturnType2newtypeApplicatorisNewtypeInstancesubstituteNewtype typeL2patL typeL2expL arrow2listlist2exp$fArbitraryMutable $fShowMutableMutable_ConT_GHC_Types_IntTFCo:R:MutablemInt%Mutable_ConT_GHC_Integer_Type_IntegerTFCo:R:MutablemIntegerMutable_ConT_GHC_Real_RationalTFCo:R:MutablemRatioMutable_ConT_GHC_Types_FloatTFCo:R:MutablemFloatMutable_ConT_GHC_Types_DoubleTFCo:R:MutablemDoubleMutable_ConT_GHC_Types_BoolTFCo:R:MutablemBool&Mutable_AppT_ListT__VarT_a_1627457511_TFCo:R:Mutablem[]Mutable_TupleT_0TFCo:R:Mutablem()FMutable_AppT__AppT__TupleT_2___VarT_a_1627457708____VarT_b_1627457709_TFCo:R:Mutablem(,)aMutable_AppT__AppT__AppT__TupleT_3___VarT_a_1627457847____VarT_b_1627457848____VarT_c_1627457849_TFCo:R:Mutablem(,,)BMutable_AppT__AppT_ArrowT__VarT_a_1627457988____VarT_b_1627457989_TFCo:R:Mutablem(->)CatCatT unProofOfHask $f<:*aProofOf$fSup*aProofOfProofOf$fSup*ProofOfaProofOfTFCo:R:ProofOf*(->)a $fClosed(->)$fCartesian(->)$fSymmetric(->) $fBraided(->)$fMonoidal(->)$fCategory(->)CatT$fCategory*(->)TopologyEndoDualSGReisz reiszSplit associatorslowFromInteger infDisjoint$fSemigroupPOrdering ValidSetIndexopenclosedclopenappEndo getDualSG ValidSetElemItem defn_Eq_noteq<.>.law_Banach_distancelaw_Banach_sizesquaredInnerProductNorm sizeDisjointconvertUnfoldable$fNormedLabeled'$fMetricLabeled'$fActionLabeled'$fOrd_Labeled'$fLattice_Labeled'$fPOrd_Labeled' $fEq_Labeled'TFCo:R:ElemLabeled'TFCo:R:LogicLabeled'TFCo:R:ActorLabeled'TFCo:R:ScalarLabeled'$fArbitraryLabeled'$fNFDataLabeled' $fAbelian(,,) $fAbelian(,) $fGroup(,,) $fGroup(,)$fCancellative(,,)$fCancellative(,) $fMonoid(,,) $fMonoid(,)$fSemigroup(,,)$fSemigroup(,) $fEq_(,,)$fEq_(,)TFCo:R:Logic(,,)TFCo:R:Logic(,)$fMonoidMaybe'$fSemigroupMaybe' $fEq_Maybe'$fNFDataMaybe'TFCo:R:LogicMaybe'TFCo:R:ScalarMaybe' $fMonoidMaybe$fSemigroupMaybe $fEq_MaybeTFCo:R:LogicMaybeTFCo:R:ScalarMaybe$fIxContainer[] $fFoldable[]$fConstructible[] $fContainer[] $fMonoid[] $fSemigroup[] $fNormed[] $fMinBound_[] $fPOrd_[]$fEq_[]TFCo:R:Index[]TFCo:R:SetElem[]b TFCo:R:Elem[]TFCo:R:Logic[]TFCo:R:Scalar[]$fIxContainerRatioTFCo:R:ElemRatioTFCo:R:IndexRatio$fIxContainerDoubleTFCo:R:ElemDoubleTFCo:R:IndexDouble$fIxContainerFloatTFCo:R:ElemFloatTFCo:R:IndexFloat$fIxContainerIntegerTFCo:R:ElemIntegerTFCo:R:IndexInteger$fIxContainerIntTFCo:R:ElemIntTFCo:R:IndexInt $fMonoidEndo$fSemigroupEndo$fMonoidDualSG$fSemigroupDualSG$fCanErrorDouble$fCanErrorFloat $fCanError[]$fCanErrorMaybe'$fCanErrorMaybe $fMetricRatio$fMetricDouble $fMetricFloat$fMetricInteger $fMetricInt$fTensorAlgebraRatio$fTensorAlgebraDouble$fTensorAlgebraFloat$fHilbertDouble$fHilbertFloat $fBanachRatio$fBanachDouble $fBanachFloat$fVectorSpace(->)$fVectorSpaceRatio$fVectorSpaceDouble$fVectorSpaceFloat$fFiniteModuleRatio$fFiniteModuleDouble$fFiniteModuleFloat$fFiniteModuleInteger$fFiniteModuleIntTFCo:R:SetIndexRatioaTFCo:R:SetIndexDoubleaTFCo:R:SetIndexFloataTFCo:R:SetIndexIntegeraTFCo:R:SetIndexIntaTFCo:R:IndexRatio0TFCo:R:IndexDouble0TFCo:R:IndexFloat0TFCo:R:IndexInteger0TFCo:R:IndexInt0TFCo:R:SetElemRatioaTFCo:R:SetElemDoubleaTFCo:R:SetElemFloataTFCo:R:SetElemIntegeraTFCo:R:SetElemIntaTFCo:R:ElemRatio0TFCo:R:ElemDouble0TFCo:R:ElemFloat0TFCo:R:ElemInteger0TFCo:R:ElemInt0$fFreeModule(->)$fFreeModuleRatio$fFreeModuleDouble$fFreeModuleFloat$fFreeModuleInteger$fFreeModuleInt $fModule(->) $fModuleRatio$fModuleDouble $fModuleFloat$fModuleInteger $fModuleInt $fNormedRatio$fNormedDouble $fNormedFloat$fNormedInteger $fNormedIntTFCo:R:Scalar(->)TFCo:R:Scalar(,,,)TFCo:R:Scalar(,,)TFCo:R:Scalar(,)TFCo:R:ScalarRatioTFCo:R:ScalarDoubleTFCo:R:ScalarFloatTFCo:R:ScalarIntegerTFCo:R:ScalarIntTFCo:R:><*k(->)cTFCo:R:><**RatioRatioTFCo:R:><**DoubleDoubleTFCo:R:><**FloatFloatTFCo:R:><**IntegerIntegerTFCo:R:><**IntInt $fRealDouble $fRealFloat$fExpFieldDouble$fExpFieldFloat$fExpRingDouble$fExpRingFloat$fQuotientField(->)(->)$fQuotientFieldRatioInteger$fQuotientFieldRatioInt$fQuotientFieldDoubleInteger$fQuotientFieldDoubleInt$fQuotientFieldFloatInteger$fQuotientFieldFloatInt$fRationalFieldRatio$fRationalFieldDouble$fRationalFieldFloat$fBoundedFieldDouble$fBoundedFieldFloat$fOrdFieldRatio$fOrdFieldDouble$fOrdFieldFloat $fField(->) $fFieldRatio $fFieldDouble $fFieldFloat$fIntegral(->)$fIntegralInteger $fIntegralInt $fRing(->) $fRingRatio $fRingDouble $fRingFloat $fRingInteger $fRingInt $fRig(->) $fRigRatio $fRigDouble $fRigFloat $fRigInteger$fRigInt$fRg(->) $fRgRatio $fRgDouble $fRgFloat $fRgInteger$fRgInt $fAbelian(->) $fAbelian()$fAbelianRatio$fAbelianDouble$fAbelianFloat$fAbelianInteger $fAbelianInt $fGroup(->) $fGroup() $fGroupRatio $fGroupDouble $fGroupFloat$fGroupInteger $fGroupInt$fCancellative(->)$fCancellative()$fCancellativeRatio$fCancellativeDouble$fCancellativeFloat$fCancellativeInteger$fCancellativeInt $fMonoid(->) $fMonoid() $fMonoidRatio$fMonoidDouble $fMonoidFloat$fMonoidInteger $fMonoidInt $fAction(->) $fAction() $fActionRatio$fActionDouble $fActionFloat$fActionInteger $fActionIntTFCo:R:Actor(->)TFCo:R:Actor()TFCo:R:ActorRatioTFCo:R:ActorDoubleTFCo:R:ActorFloatTFCo:R:ActorIntegerTFCo:R:ActorInt$fSemigroup(->) $fSemigroup()$fSemigroupRatio$fSemigroupDouble$fSemigroupFloat$fSemigroupInteger$fSemigroupInt $fBoolean(->) $fBooleanBool $fBoolean() $fHeyting(->) $fHeytingBool $fHeyting()$fComplemented(->)$fComplementedBool$fComplemented() $fBounded(->)$fBoundedDouble$fBoundedFloat $fBoundedInt $fBoundedChar $fBoundedBool $fBounded() $fOrd_Bool $fOrd_Ratio $fOrd_Double $fOrd_Float $fOrd_Integer $fOrd_Int $fOrd_Char$fOrd_()$fGradedInteger $fGradedChar $fGradedInt $fGradedBool $fEnumInteger $fEnumChar $fEnumInt $fEnumBool$fLattice_(->) $fLattice_()$fLattice_Ratio$fLattice_Double$fLattice_Float$fLattice_Integer $fLattice_Int$fLattice_Char$fLattice_Bool$fMonoidOrdering$fMonoidPOrdering$fSemigroupOrdering $fEq_OrderingTFCo:R:LogicOrdering$fEq_POrdering$fArbitraryPOrderingTFCo:R:LogicPOrdering$fMinBound_(->)$fMinBound_Double$fMinBound_Float$fMinBound_Int$fMinBound_Char$fMinBound_Bool $fMinBound_() $fPOrd_(->) $fPOrd_() $fPOrd_Ratio $fPOrd_Double $fPOrd_Float$fPOrd_Integer $fPOrd_Int $fPOrd_Char $fPOrd_Bool $fEq_(->) $fEq_Double $fEq_Float $fEq_Ratio $fEq_Integer$fEq_Int $fEq_Char $fEq_Bool$fEq_()TFCo:R:Logic()TFCo:R:Logic(->)TFCo:R:LogicDoubleTFCo:R:LogicFloatTFCo:R:LogicRatioTFCo:R:LogicIntegerTFCo:R:LogicIntTFCo:R:LogicCharTFCo:R:LogicBool&Mutable_ConT_SubHask_Algebra_POrderingTFCo:R:MutablemPOrderingMutable_ConT_GHC_Types_OrderingTFCo:R:MutablemOrderingMutable_AppT__ConT_SubHask_Algebra_DualSG___VarT_a_1627508448_TFCo:R:MutablemDualSG6Mutable_AppT__ConT_GHC_Base_Maybe___VarT_a_1627508563_TFCo:R:MutablemMaybe>Mutable_AppT__ConT_SubHask_Algebra_Maybe'___VarT_a_1627508678_TFCo:R:MutablemMaybe'[Mutable_AppT__AppT__ConT_SubHask_Algebra_Labeled'___VarT_a_1627508802____VarT_b_1627508803_TFCo:R:MutablemLabeled'GHC.ListzipWith parfoldtree1partitionInterleaved_list parallelNpartitionBlocked_list$fPartitionable[]TFCo:R:><**GaloisInteger TFCo:R:><*k/cTFCo:R:SetElemBallv'TFCo:R:ElemBallTFCo:R:LogicBallTFCo:R:ScalarBall swapZIndex $fFiniteType/Mutable_ZIndex int2index index2int$fCategory*DenseFunction$fCategory*SparseFunctionMonoid$fCategory*SparseFunctionTFCo:R:ActorZIndexTFCo:R:><**Polynomial_rTFCo:R:LogicPolynomial_TFCo:R:ScalarPolynomial_ unBijectiveT unSurjectiveT unInjectiveT$f<:(->)BijectiveTcat$fSup(->)aBijectiveTc$fSup(->)BijectiveTbc$fCategorykBijectiveT$fBijectiveBijectiveT$fInjectiveBijectiveT$fSurjectiveBijectiveT$f<:(->)SurjectiveTcat$fSup(->)aSurjectiveTc$fSup(->)SurjectiveTbc$fCategorykSurjectiveT$fSurjectiveSurjectiveT$f<:(->)InjectiveTcat$fSup(->)aInjectiveTc$fSup(->)InjectiveTbc$fCategorykInjectiveT$fInjectiveInjectiveTAppConstraints$fMonoidalConstrainedT$f<:(->)ConstrainedTcat$fSup(->)aConstrainedTc$fSup(->)ConstrainedTbc$fCategory*ConstrainedTTFCo:R:AppConstraints:aTFCo:R:AppConstraints[]aTFCo:R:LogicTypeTFCo:R:LogicDecTFCo:R:LogicNamedummy1dummy2dummy3$fFunctor*(->)NoIO$fFunctor*(->)Q $fMonad(->)Q4Mutable_AppT__ConT_GHC_Types_IO___VarT_a_1627701515_ $fOrd_TypeRep$fLattice_TypeRep$fPOrd_TypeRep $fEq_TypeRepTFCo:R:LogicTypeRep $fMonoidIO $fSemigroupIOTFCo:R:MutablemIOUMutable_AppT__AppT__ConT_Data_Either_Either___VarT_a_1627701788____VarT_b_1627701789_$fMonad(->)Maybe' $fThen*Maybe'$fFunctor*(->)Maybe' $fMonadMaybe'$fApplicativeMaybe'$fFunctorMaybe'$fMonoidEither$fSemigroupEitherTFCo:R:MutablemEitherisNullzerofp Tensor_LinearZeroId_Mat_ ToFromVectortoVector fromVector MatrixField ValidSVectorTensor_SVectorMutable_SVector_Nat SVector_NatMutable_SVectorSVector_DynamicMutable_UVectorUVector_Dynamicnat2intnat200 sizeOfFloatextendDimensions binopDynUV monopDynUVisConstbinopDynmonopDyn binopDynM monopDynMstatic2dynamic binopStatic monopStatic binopStaticM monopStaticMapMat_TFCo:R:><*k+>cTFCo:R:Logic+>TFCo:R:Scalar+>$fToFromVectorSVector$fToFromVectorSVector0$fToFromVectorDouble$fHilbertSVector$fBanachSVector$fNormedSVector$fMetricSVector $fEq_SVector$fFiniteModuleSVector$fIxContainerSVector$fVectorSpaceSVector$fFreeModuleSVector$fModuleSVector$fAbelianSVector$fGroupSVector$fMonoidSVector$fCancellativeSVector$fSemigroupSVector$fIsMutableSVectorTFCo:R:MutablemSVector$fNFDataSVector$fArbitrarySVector $fShowSVectorTFCo:R:SVectorNatnr$fHilbertSVector0$fBanachSVector0$fNormedSVector0$fMetricSVector0 $fEq_SVector0$fFiniteModuleSVector0$fIxContainerSVector0$fVectorSpaceSVector0$fFreeModuleSVector0$fModuleSVector0$fAbelianSVector0$fGroupSVector0$fMonoidSVector0$fCancellativeSVector0$fSemigroupSVector0$fIsMutableSVector0TFCo:R:MutablemSVector0$fFromRecordSVector$fNFDataSVector0$fArbitrarySVector0$fShowSVector0TFCo:R:SVectorSymbolnrTFCo:R:SetElemSVectorbTFCo:R:ElemSVectorTFCo:R:IndexSVectorTFCo:R:><**SVectorbTFCo:R:LogicSVectorTFCo:R:ScalarSVector$fNormedUVector$fMetricUVector $fEq_UVector$fFiniteModuleUVector$fIxContainerUVector$fVectorSpaceUVector$fFreeModuleUVector$fModuleUVector$fAbelianUVector$fGroupUVector$fMonoidUVector$fCancellativeUVector$fSemigroupUVector$fIsMutableUVectorTFCo:R:MutablemUVector$fFromRecordUVector$fNFDataUVector$fArbitraryUVector $fShowUVectorTFCo:R:UVectorSymbolnrTFCo:R:SetElemUVectorbTFCo:R:ElemUVectorTFCo:R:IndexUVectorTFCo:R:><*kUVectoraTFCo:R:LogicUVectorTFCo:R:ScalarUVector\Mutable_AppT__AppT__ConT_SubHask_Algebra_Vector______VarT_a_1627750060____VarT_b_1627750061_$fTensorAlgebraSVector $fField+>$fRing+>$fRig+>$fRg+>$fVectorSpace+>$fFreeModule+> $fModule+> $fAbelian+> $fGroup+>$fCancellative+> $fMonoid+> $fSemigroup+> $fNormed+> $fGroupoid*+> $fDagger*+>$f<:(->)+>(->)$fSup(->)(->)+>(->)$fSup(->)+>(->)(->) $fCategory*+>TFCo:R:Mutablem+>TFCo:R:SetElemBArraye'TFCo:R:ElemBArrayTFCo:R:ScalarBArrayTFCo:R:LogicBArrayTFCo:R:IndexBArrayDMutable_AppT__ConT_SubHask_Algebra_Array_BArray___VarT_e_1627965524_TFCo:R:SetElemUArraye'TFCo:R:ElemUArrayTFCo:R:ScalarUArrayTFCo:R:LogicUArrayTFCo:R:IndexUArray$fPartitionableBArray$fIxContainerBArray$fSliceableBArray$fFoldableBArray$fContainerBArray$fConstructibleBArray$fMinBound_BArray $fPOrd_BArray $fEq_BArray$fNormedBArray$fMonoidBArray$fSemigroupBArray $fShowBArray$fNFDataBArray$fArbitraryBArrayTFCo:R:MutablemBArrayUArray_Labeled'_UVectorUArray_Labeled'_MUVectorUArray_MUVectorUArray_UVectorDMutable_AppT__ConT_SubHask_Algebra_Array_UArray___VarT_e_1627966749_$fVectorVectorLabeled'TFCo:R:VectorLabeled'$fMVectorMVectorLabeled'TFCo:R:MVectorsLabeled'$fUnboxLabeled'$fMVectorMVectorUVectorTFCo:R:MVectorsUVector$fVectorVectorUVectorTFCo:R:VectorUVector$fUnboxUVector$fPartitionableUArray$fIxContainerUArray$fSliceableUArray$fFoldableUArray$fContainerUArray$fMonoidUArray$fConstructibleUArray$fMonoidUArray0$fConstructibleUArray0$fMonoidUArray1$fConstructibleUArray1$fMonoidUArray2$fConstructibleUArray2$fMonoidUArray3$fConstructibleUArray3$fMinBound_UArray $fPOrd_UArray $fEq_UArray$fNormedUArray$fSemigroupUArray $fShowUArray$fNFDataUArray$fArbitraryUArrayTFCo:R:MutablemUArrayTFCo:R:SetElemBoxv'TFCo:R:ElemBoxTFCo:R:LogicBoxTFCo:R:ScalarBoxTFCo:R:LogicK3TFCo:R:LogicH3pMutable_AppT__AppT__ConT_SubHask_Compatibility_BloomFilter_BloomFilter___VarT_n_1628092139____VarT_a_1628092140_hash$fNormedBloomFilter$fContainerBloomFilter$fConstructibleBloomFilter$fMonoidBloomFilter$fSemigroupBloomFilterTFCo:R:SetElemBloomFilterbTFCo:R:ElemBloomFilterTFCo:R:LogicBloomFilterTFCo:R:ScalarBloomFilterTFCo:R:MutablemBloomFilterTFCo:R:SetElemSeqbTFCo:R:ElemSeqTFCo:R:LogicSeqTFCo:R:ScalarSeqTFCo:R:SetElemMape'TFCo:R:ElemMapTFCo:R:SetIndexMapi'TFCo:R:IndexMapTFCo:R:LogicMapTFCo:R:ScalarMapTFCo:R:SetElemMap'e'TFCo:R:ElemMap'TFCo:R:SetIndexMap'i'TFCo:R:IndexMap'TFCo:R:LogicMap'TFCo:R:ScalarMap'TFCo:R:SetElemIntMape'TFCo:R:ElemIntMapTFCo:R:IndexIntMapTFCo:R:LogicIntMapTFCo:R:ScalarIntMapTFCo:R:SetElemIntMap'e'TFCo:R:ElemIntMap'TFCo:R:IndexIntMap'TFCo:R:LogicIntMap'TFCo:R:ScalarIntMap'TFCo:R:SetElemSetbTFCo:R:ElemSetTFCo:R:LogicSetTFCo:R:ScalarSetTFCo:R:SetElemLexSetbTFCo:R:ElemLexSetTFCo:R:LogicLexSetTFCo:R:ScalarLexSetTFCo:R:ScalarInt64TFCo:R:ElemHyperLogLogTFCo:R:LogicHyperLogLogTFCo:R:ScalarHyperLogLogTFCo:R:SetElemByteStringcTFCo:R:ElemByteStringTFCo:R:LogicByteStringTFCo:R:ScalarByteString$fFromRecordUArray$fFromRecordBArray