Hoogle Search
Within LTS Haskell 24.35 (ghc-9.10.3)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
enumArgP :: EnumText a => MetaVar -> Parser aoptparse-enum Text.Enum.Optparse parsing an EnumText argument
enumOptP :: EnumText a => FlagChar -> MetaVar -> Parser aoptparse-enum Text.Enum.Optparse parsing an EnumText option
enumSwitchesP :: EnumText a => Parser aoptparse-enum Text.Enum.Optparse generate mutually exclusive switches based on EnumText a
enumDownFrom :: DownwardEnum a => a -> [a]prelude-safeenum Prelude.SafeEnum Return x followed by all it's predecessors, in (reverse) order. The resulting list is always non-empty, since it includes x. If the resulting list is always finite, then the precedes ordering is well-founded. In GHC, the default implementation is a "good producer" for list fusion.
enumDownFromTo :: DownwardEnum a => a -> a -> [a]prelude-safeenum Prelude.SafeEnum Return the elements of enumDownFrom x, filtering out everything that precedes z. If x precedes z, then the resulting list is empty; otherwise, it is non-empty, since it includes x. In GHC, the default implementation is a "good producer" for list fusion.
enumFrom :: UpwardEnum a => a -> [a]prelude-safeenum Prelude.SafeEnum Return x followed by all it's successors, in order. The resulting list is always non-empty, since it includes x. If the resulting list is always finite, then the succeeds ordering is converse well-founded. In GHC, the default implementation is a "good producer" for list fusion.
enumFromThen :: Enum a => a -> a -> [a]prelude-safeenum Prelude.SafeEnum Enumerate values with an inferred stride. The resulting list is always non-empty, since it includes x. Naturally, this should agree with enumFrom and enumDownFrom (assuming Eq a, by magic if need be):
if succ x == Just y then enumFromThen x y == enumFrom x if pred x == Just y then enumFromThen x y == enumDownFrom x
In the default implementation: if fromEnum fails on either argument, then the result is exactly [x]; and if toEnum fails on any of the enumerated integers, then the first failure terminates the enumeration. If either of these properties is inappropriate, then you should override the default. In GHC, the default implementation is a "good producer" for list fusion.enumFromThenTo :: Enum a => a -> a -> a -> [a]prelude-safeenum Prelude.SafeEnum Enumerate values with an inferred stride and a given limit. If x precedes y (and therefore we're enumerating forward) but x succeeds z (and therefore is past the limit), then the result is empty. Similarly, if x succeeds y (and therefore we're enumerating backward) but x precedes z (and therefore is past the limit), then the result is empty. Otherwise the result is non-empty since it contains x. Naturally, this should agree with enumFromTo and enumDownFromTo (assuming Eq a, by magic if need be):
if succ x == Just y then enumFromThenTo x y z == enumFromTo x z if pred x == Just y then enumFromThenTo x y z == enumDownFromTo x z
In the default implementation: if fromEnum fails on any argument, then the result is either [] or [x] (as appropriate); and if toEnum fails on any of the enumerated integers, then the first failure terminates the enumeration. If either of these properties is inappropriate, then you should override the default. In GHC, the default implementation is a "good producer" for list fusion.enumFromTo :: UpwardEnum a => a -> a -> [a]prelude-safeenum Prelude.SafeEnum Return the elements of enumFrom x, filtering out everything that succeeds z. If x succeeds z, then the resulting list is empty; otherwise, it is non-empty, since it includes x. In GHC, the default implementation is a "good producer" for list fusion.
enumT :: (RealFloat prob, Ord a) => [Int] -> SpreadT prob aprobability Numeric.Probability.Transition No documentation available.