Module

Data.Unfoldable

Package: unfoldable
Repository: purerl/purescript-unfoldable

This module provides a type class for unfoldable functors, i.e. functors which support an unfoldr operation.

This allows us to unify various operations on arrays, lists, sequences, etc.

#Unfoldable Source

class (Unfoldable1 t) <= Unfoldable t  where

This class identifies data structures which can be unfolded.

The generating function f in unfoldr f in understood as follows:

If f b is Nothing, then unfoldr f b should be empty.
If f b is Just (Tuple a b1), then unfoldr f b should consist of a appended to the result of unfoldr f b1.

Members

unfoldr :: forall b a. (b -> Maybe (Tuple a b)) -> b -> t a

Instances

Unfoldable Array

#replicate Source

replicate :: forall a f. Unfoldable f => Int -> a -> f a

Replicate a value some natural number of times. For example:

replicate 2 "foo" == ["foo", "foo"] :: Array String

#replicateA Source

replicateA :: forall a f m. Applicative m => Unfoldable f => Traversable f => Int -> m a -> m (f a)

Perform an Applicative action n times, and accumulate all the results.

#none Source

none :: forall a f. Unfoldable f => f a

The container with no elements - unfolded with zero iterations. For example:

none == [] :: forall a. Array a

#fromMaybe Source

fromMaybe :: forall a f. Unfoldable f => Maybe a -> f a

Convert a Maybe to any Unfoldable like lists and arrays.

Re-exports from Data.Unfoldable1

#Unfoldable1 Source

class Unfoldable1 t  where

This class identifies non-empty data structures which can be unfolded.

The generating function f corresponds to the uncons operation of a non-empty list or array; it always return a value, and then optionally a value to continue unfolding from.

Members

unfoldr1 :: forall b a. (b -> Tuple a (Maybe b)) -> b -> t a

Instances

Unfoldable1 Array

#singleton Source

singleton :: forall a f. Unfoldable1 f => a -> f a

Contain a single value. For example:

singleton "foo" == NEL.singleton "foo" :: NEL.NonEmptyList String

#replicate1A Source

replicate1A :: forall a f m. Apply m => Unfoldable1 f => Traversable1 f => Int -> m a -> m (f a)

Perform an Apply action n times (at least once, so values n < 1 less than one will be ignored), and accumulate the results.

#replicate1 Source

replicate1 :: forall a f. Unfoldable1 f => Int -> a -> f a

Replicate a value n times. At least one value will be produced, so values n < 1 less than one will be ignored.

replicate1 0 "foo" == NEL.singleton "foo" :: NEL.NonEmptyList String
replicate1 2 "foo" == NEL.cons "foo" (NEL.singleton "foo") :: NEL.NonEmptyList String

#range Source

range :: forall f. Unfoldable1 f => Int -> Int -> f Int

Create an Unfoldable1 containing a range of values, including both endpoints.

range 0 0 "foo" == NEL.singleton 0 :: NEL.NonEmptyList Int
range 1 2 "foo" == NEL.cons 1 (NEL.singleton 2) :: NEL.NonEmptyList Int
range 2 0 "foo" == NEL.cons 2 (NEL.cons 1 (NEL.singleton 0)) :: NEL.NonEmptyList Int

Modules: Data.Unfoldable; Data.Unfoldable1