Hoogle Search

Within LTS Haskell 24.51 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

Exact lookup

1. grepREwithLineNum :: StringLike s => GenRegex s -> [s] -> [(Int, s)]

   hxt-regex-xmlschema	Text.Regex.XMLSchema.Generic

   grep with Regex and line numbers

2. grepREwithLineNum :: StringLike s => GenRegex s -> [s] -> [(Int, s)]

   hxt-regex-xmlschema	Text.Regex.XMLSchema.Generic.Matching

   grep with Regex and line numbers

3. grepREwithLineNum :: Regex -> [String] -> [(Int, String)]

   hxt-regex-xmlschema	Text.Regex.XMLSchema.String

   grep with Regex and line numbers

4. enumerateFromTo :: Enum a => a -> a -> Source a

   machines	Data.Machine.Source

   Enumerate from a value to a final value, inclusive, via succ Examples:

   >>> run $ enumerateFromTo 1 3
   [1,2,3]
   

5. type ReadNum b = Value -> Either String b

   matrix-as-xyz	Data.Matrix.AsXYZ.ParseXYZ

   No documentation available.

6. package mixed-types-num

   Alternative Prelude with numeric and logic expressions typed bottom-up Please see the README on GitHub at https://github.com/michalkonecny/mixed-types-num#readme

7. module MixedTypesNumPrelude

   MixedTypesNumPrelude provides a version of Prelude where unary and binary operations such as not, +, == have their result type derived from the parameter type(s). This module facilitates a single-line import for the package mixed-types-num. See the re-exported modules for further details.

8. specCanNegNum :: (Arbitrary t, Show t, Show (NegType (NegType t)), HasEqAsymmetric t t, HasEqAsymmetric (NegType t) t, HasEqAsymmetric (NegType (NegType t)) t, CanTestCertainly (EqCompareType t t), CanTestCertainly (EqCompareType (NegType t) t), CanTestCertainly (EqCompareType (NegType (NegType t)) t), CanTestFinite t, CanTestPosNeg t, CanTestPosNeg (NegType t), ConvertibleExactlyWithSample Integer t, CanNeg t, CanNeg (NegType t)) => T t -> Spec

   mixed-types-num	Numeric.MixedTypes.MinMaxAbs

   HSpec properties that each numeric implementation of CanNeg should satisfy.

9. class Enum a

   mixed-types-num	Numeric.MixedTypes.PreludeHiding

   Class Enum defines operations on sequentially ordered types. The enumFrom... methods are used in Haskell's translation of arithmetic sequences. Instances of Enum may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by fromEnum from 0 through n-1. See Chapter 10 of the Haskell Report for more details. For any type that is an instance of class Bounded as well as Enum, the following should hold:

   • The calls succ maxBound and pred minBound should result in a runtime error.
   • fromEnum and toEnum should give a runtime error if the result value is not representable in the result type. For example, toEnum 7 :: Bool is an error.
   • enumFrom and enumFromThen should be defined with an implicit bound, thus:

   enumFrom     x   = enumFromTo     x maxBound
   enumFromThen x y = enumFromThenTo x y bound
   where
   bound | fromEnum y >= fromEnum x = maxBound
   | otherwise                = minBound
   

10. enumFrom :: Enum a => a -> [a]

    mixed-types-num	Numeric.MixedTypes.PreludeHiding

    Used in Haskell's translation of [n..] with [n..] = enumFrom n, a possible implementation being enumFrom n = n : enumFrom (succ n).

    Examples

    • enumFrom 4 :: [Integer] = [4,5,6,7,...]

    • enumFrom 6 :: [Int] = [6,7,8,9,...,maxBound ::
      Int]

Page 354 of many | Previous | Next