Hoogle Search

Within LTS Haskell 24.31 (ghc-9.10.3)

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

Exact lookup

1. enumerateFromThen :: forall (m :: Type -> Type) . (Enumerable a, Monad m) => Unfold m (a, a) a

   streamly-core	Streamly.Data.Unfold

   Unfolds (from, then) generating a stream whose first element is from and the successive elements are in increments of then. Enumeration can occur downwards or upwards depending on whether then comes before or after from. For Bounded types the stream ends when maxBound is reached, for unbounded types it keeps enumerating infinitely.

   >>> Stream.toList $ Stream.take 4 $ Stream.unfold Unfold.enumerateFromThen (0, 2)
   [0,2,4,6]
   

   >>> Stream.toList $ Stream.take 4 $ Stream.unfold Unfold.enumerateFromThen (0,(-2))
   [0,-2,-4,-6]
   

   Pre-release

2. enumerateFromThenTo :: forall (m :: Type -> Type) . (Enumerable a, Monad m) => Unfold m (a, a, a) a

   streamly-core	Streamly.Data.Unfold

   Unfolds (from, then, to) generating a finite stream whose first element is from and the successive elements are in increments of then up to to. Enumeration can occur downwards or upwards depending on whether then comes before or after from.

   >>> Stream.toList $ Stream.unfold Unfold.enumerateFromThenTo (0, 2, 6)
   [0,2,4,6]
   

   >>> Stream.toList $ Stream.unfold Unfold.enumerateFromThenTo (0, (-2), (-6))
   [0,-2,-4,-6]
   

   Pre-release

3. enumerateFromTo :: forall (m :: Type -> Type) . (Enumerable a, Monad m) => Unfold m (a, a) a

   streamly-core	Streamly.Data.Unfold

   Unfolds (from, to) generating a finite stream starting with the element from, enumerating the type up to the value to. If to is smaller than from then an empty stream is returned.

   >>> Stream.toList $ Stream.unfold Unfold.enumerateFromTo (0, 4)
   [0,1,2,3,4]
   

   For Fractional types, the last element is equal to the specified to value after rounding to the nearest integral value.

   >>> Stream.toList $ Stream.unfold Unfold.enumerateFromTo (1.1, 4)
   [1.1,2.1,3.1,4.1]
   

   >>> Stream.toList $ Stream.unfold Unfold.enumerateFromTo (1.1, 4.6)
   [1.1,2.1,3.1,4.1,5.1]
   

   Pre-release

4. enumerate :: forall (m :: Type -> Type) a . (Monad m, Bounded a, Enumerable a) => Stream m a

   streamly-core	Streamly.Internal.Data.Stream

   enumerate = enumerateFrom minBound
   

   Enumerate a Bounded type from its minBound to maxBound

5. enumerateFrom :: forall (m :: Type -> Type) . (Enumerable a, Monad m) => a -> Stream m a

   streamly-core	Streamly.Internal.Data.Stream

   enumerateFrom from generates a stream starting with the element from, enumerating up to maxBound when the type is Bounded or generating an infinite stream when the type is not Bounded.

   >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFrom (0 :: Int)
   [0,1,2,3]
   

   For Fractional types, enumeration is numerically stable. However, no overflow or underflow checks are performed.

   >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFrom 1.1
   [1.1,2.1,3.1,4.1]
   

6. enumerateFromBounded :: forall (m :: Type -> Type) a . (Monad m, Enumerable a, Bounded a) => a -> Stream m a

   streamly-core	Streamly.Internal.Data.Stream

   >>> enumerateFromBounded from = Stream.enumerateFromTo from maxBound
   

   enumerateFrom for Bounded Enum types.

7. enumerateFromFractional :: forall (m :: Type -> Type) a . (Monad m, Fractional a) => a -> Stream m a

   streamly-core	Streamly.Internal.Data.Stream

   Numerically stable enumeration from a Fractional number in steps of size 1. enumerateFromFractional from generates a stream whose first element is from and the successive elements are in increments of 1. No overflow or underflow checks are performed. This is the equivalent to enumFrom for Fractional types. For example:

   >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromFractional 1.1
   [1.1,2.1,3.1,4.1]
   

8. enumerateFromIntegral :: forall (m :: Type -> Type) a . (Monad m, Integral a, Bounded a) => a -> Stream m a

   streamly-core	Streamly.Internal.Data.Stream

   Enumerate an Integral type. enumerateFromIntegral from generates a stream whose first element is from and the successive elements are in increments of 1. The stream is bounded by the size of the Integral type.

   >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromIntegral (0 :: Int)
   [0,1,2,3]
   

9. enumerateFromNum :: forall (m :: Type -> Type) a . (Monad m, Num a) => a -> Stream m a

   streamly-core	Streamly.Internal.Data.Stream

   No documentation available.

10. enumerateFromStepIntegral :: forall a (m :: Type -> Type) . (Integral a, Monad m) => a -> a -> Stream m a

    streamly-core	Streamly.Internal.Data.Stream

    enumerateFromStepIntegral from step generates an infinite stream whose first element is from and the successive elements are in increments of step. CAUTION: This function is not safe for finite integral types. It does not check for overflow, underflow or bounds.

    >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromStepIntegral 0 2
    [0,2,4,6]
    

    >>> Stream.toList $ Stream.take 3 $ Stream.enumerateFromStepIntegral 0 (-2)
    [0,-2,-4]
    

Page 70 of many | Previous | Next