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.

Exact lookup

1. enumerateFromBounded :: forall t (m :: Type -> Type) a . (IsStream t, Monad m, Enumerable a, Bounded a) => a -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   enumerateFromBounded = enumerateFromTo from maxBound
   

   enumerateFrom for Bounded Enum types.

2. enumerateFromFractional :: forall t (m :: Type -> Type) a . (IsStream t, Monad m, Fractional a) => a -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   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]
   

3. enumerateFromIntegral :: forall t (m :: Type -> Type) a . (IsStream t, Monad m, Integral a, Bounded a) => a -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   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]
   

4. enumerateFromStepIntegral :: forall t (m :: Type -> Type) a . (IsStream t, Monad m, Integral a) => a -> a -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   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]
   

5. enumerateFromThen :: forall t (m :: Type -> Type) . (Enumerable a, IsStream t, Monad m) => a -> a -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   enumerateFromThen from then generates a stream whose first element is from, the second element is then and the successive elements are in increments of then - from. 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.enumerateFromThen 0 2
   [0,2,4,6]
   
   >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromThen 0 (-2)
   [0,-2,-4,-6]
   

6. enumerateFromThen :: forall t (m :: Type -> Type) . (Enumerable a, IsStream t, Monad m) => a -> a -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   enumerateFromThen from then generates a stream whose first element is from, the second element is then and the successive elements are in increments of then - from. 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.enumerateFromThen 0 2
   [0,2,4,6]
   
   >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromThen 0 (-2)
   [0,-2,-4,-6]
   

7. enumerateFromThenFractional :: forall t (m :: Type -> Type) a . (IsStream t, Monad m, Fractional a) => a -> a -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   Numerically stable enumeration from a Fractional number in steps. enumerateFromThenFractional from then generates a stream whose first element is from, the second element is then and the successive elements are in increments of then - from. No overflow or underflow checks are performed. This is the equivalent of enumFromThen for Fractional types. For example:

   >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromThenFractional 1.1 2.1
   [1.1,2.1,3.1,4.1]
   
   >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromThenFractional 1.1 (-2.1)
   [1.1,-2.1,-5.300000000000001,-8.500000000000002]
   

8. enumerateFromThenIntegral :: forall t (m :: Type -> Type) a . (IsStream t, Monad m, Integral a, Bounded a) => a -> a -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   Enumerate an Integral type in steps. enumerateFromThenIntegral from then generates a stream whose first element is from, the second element is then and the successive elements are in increments of then - from. The stream is bounded by the size of the Integral type.

   >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromThenIntegral (0 :: Int) 2
   [0,2,4,6]
   
   >>> Stream.toList $ Stream.take 4 $ Stream.enumerateFromThenIntegral (0 :: Int) (-2)
   [0,-2,-4,-6]
   

9. enumerateFromThenSmallBounded :: forall t (m :: Type -> Type) a . (IsStream t, Monad m, Enumerable a, Bounded a) => a -> a -> t m a

   streamly	Streamly.Internal.Data.Stream.IsStream

   enumerateFromThen for Enum types not larger than Int. Note: We convert the Enum to Int and enumerate the Int. If a type is bounded but does not have a Bounded instance then we can go on enumerating it beyond the legal values of the type, resulting in the failure of toEnum when converting back to Enum. Therefore we require a Bounded instance for this function to be safely used.

10. enumerateFromThenTo :: forall t (m :: Type -> Type) . (Enumerable a, IsStream t, Monad m) => a -> a -> a -> t m a

    streamly	Streamly.Internal.Data.Stream.IsStream

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

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

Page 82 of many | Previous | Next