Data.Unfoldable.Trivial

head :: forall a. Trivial a -> Maybe a

Returns the first element, if present.

Not particularly useful, because this is just the Unfoldable instance for Maybe. Included by analogy with head1.

tail :: forall a u. Unfoldable u => Trivial a -> u a

Removes the first element, if present.

last :: forall a. Trivial a -> Maybe a

Returns the last element, if present.

init :: forall a u. Unfoldable u => Trivial a -> u a

Removes the last element, if present.

take :: forall a u. Unfoldable u => Int -> Trivial a -> u a

Keep only a number of elements from the start.

cons :: forall a u. Unfoldable1 u => a -> Trivial a -> u a

Prepend an element.

Do not use this to create a data structure. Please use Data.List.Lazy instead.

snoc :: forall a u. Unfoldable1 u => Trivial a -> a -> u a

Append an element.

Do not use this to create a data structure. Please use Data.List.Lazy instead.

append' :: forall a u. Unfoldable u => Trivial a -> Trivial a -> u a

Concatenate two Unfoldables.

Do not use this to create a data structure. Please use Data.List.Lazy instead.

uncons :: forall a u. Unfoldable u => Trivial a -> Maybe (a /\ (u a))

Returns the first element and a new Unfoldable generating the remaining elements, or Nothing if there are no elements.

index :: forall a. Trivial a -> Int -> Maybe a

Get the element at the specified 0-index, or Nothing if the index is out-of-bounds.

Time complexity: O(n) in the index (calls to the generating function).

drop :: forall a u. Unfoldable u => Int -> Trivial a -> u a

Drop a number of elements from the start.

refoldl :: forall a c. (c -> a -> c) -> c -> Trivial a -> c

foldl specialized to Trivial. "Re-fold" a polymorphic Unfoldable. Usually cleaner and more convenient than turbofish, when applicable.

refoldr :: forall a c. (a -> c -> c) -> c -> Trivial a -> c

foldr specialized to Trivial. "Re-fold" a polymorphic Unfoldable. Usually cleaner and more convenient than turbofish, when applicable.

refoldMap :: forall a c. Monoid c => (a -> c) -> Trivial a -> c

foldMap specialized to Trivial. "Re-fold" a polymorphic Unfoldable. Usually cleaner and more convenient than turbofish, when applicable.

refold :: forall a. Monoid a => Trivial a -> a

fold specialized to Trivial. "Re-fold" a polymorphic Unfoldable. Usually cleaner and more convenient than turbofish, when applicable.

emptyIfNone :: forall a f u. Alternative f => Unfoldable1 u => Trivial a -> u (f a)

Lift the elements of an Unfoldable into an Alternative (such as Maybe), filling in a single empty if there are no elements.

If you more generally want to augment an Unfoldable1 with emptiness, you almost certainly should use MaybeEmpty instead.

catMaybes :: forall u a. Unfoldable u => Trivial (Maybe a) -> u a

Unwrap Justs and discard Nothings.

unfoldr1Default :: forall a b t. Unfoldable t => (b -> a /\ (Maybe b)) -> b -> t a

Provides a default implementation of unfoldr1 using unfoldr to satisfy the superclass bound on Unfoldable.

turbofish :: forall a b. (Trivial a -> b) -> Trivial a -> b

Function application specialized to a Trivial argument, at the same precedence as ($).

Inspired by the Rust syntax of the same name, often used in the analogous context of collecting from an iterator.

trivial :: forall a. Trivial a -> Trivial a

Specializes its argument to Trivial.

Operator alias for Data.Unfoldable.Trivial.Internal.turbofish (right-associative / precedence 0)

newtype Trivial1 a

A type wrapping unfoldr1 calls, existentially quantified over the seed type so that it can be ignored in the type constructor. Its Unfoldable1 instance means that it can directly be constructed by calling unfoldr1.

Instances

• Unfoldable1 Trivial1

  Wraps both arguments to unfoldr1 in an Unfoldr1Call.

• Functor Trivial1
• Invariant Trivial1
• Foldable Trivial1
• Foldable1 Trivial1

  The raison d'être for Trivial1. Allows folding polymorphic Unfoldable1s as they generate with no explicit starting value. In particular, foldMap1 needs map only into a Semigroup rather than a Monoid.

  foldr1 uses a default implementation and may be inefficient.

• (Arbitrary a, Coarbitrary a) => Arbitrary (Trivial1 a)

  Guaranteed finite.

• Lazy (Trivial1 a)
• Semigroup (Trivial1 a)

  Concatenation.

  Do not use this to create a data structure. Please use Data.List.Lazy instead.

• Apply Trivial1

  Zipwith; chosen over the Monad-compatible nondet choice used for Array etc. because that would require effectively forcing one argument and either re-evaluating it constantly or storing its elements in a real container at which point please please please just do that without using Trivial1. Length is the minimum of the arguments' lengths.

• Applicative Trivial1

  Infinitely cycles to satisfy the Applicative laws! If you just want one element, use singleton instead.

• Alt Trivial1

  Not concatenation! (<|>) clobbers a prefix of the right argument of the length of the left for consistency with Alternative Trivial, although Trivial1 itself fundamentally lacks a Plus instance.

• (Eq a) => Eq (Trivial1 a)

  Does not and cannot memoize the values being produced to compare. Please consider using Data.List.Lazy or your strict container of choice instead if you have any intention of using this for anything else.

• (Ord a) => Ord (Trivial1 a)
• Eq1 Trivial1
• Ord1 Trivial1
• (Show a) => Show (Trivial1 a)

unfoldrInf :: forall a b u. Unfoldable1 u => (b -> a /\ b) -> b -> u a

Unfold an infinite Unfoldable1. Analogous to unfold1 and unfold, but with no way to signal termination; unfoldInf f b consists of fst $ f b appended to unfoldInf f $ snd $ f b.

This should only be used to produce either lazy types (like lazy Lists) or types with truncating Unfoldable1 instances (like Maybe).

uncons1 :: forall a u. Unfoldable u => Trivial1 a -> a /\ (u a)

Returns the first element, and an Unfoldable of the remaining elements.

turbofish1 :: forall a b. (Trivial1 a -> b) -> Trivial1 a -> b

Function application specialized to a Trivial1 argument, at the same precedence as ($).

Inspired by the Rust syntax of the same name, often used in the analogous context of collecting from an iterator.

trivial1 :: forall a. Trivial1 a -> Trivial1 a

Specializes its argument to Trivial1.

take1 :: forall a u. Unfoldable1 u => Int -> Trivial1 a -> u a

Keep only a strictly positive number of elements from the start.

repeat :: forall a u. Unfoldable1 u => a -> u a

Create an infinite Unfoldable1 by repeating a single element.

refoldr1 :: forall a. (a -> a -> a) -> Trivial1 a -> a

foldr1 specialized to Trivial1. "Re-fold" a polymorphic Unfoldable1. Usually cleaner and more convenient than turbofish, when applicable.

refoldl1 :: forall a. (a -> a -> a) -> Trivial1 a -> a

foldl1 specialized to Trivial1. "Re-fold" a polymorphic Unfoldable1. Usually cleaner and more convenient than turbofish, when applicable.

refoldMap1 :: forall a c. Semigroup c => (a -> c) -> Trivial1 a -> c

foldMap specialized to Trivial1. "Re-fold" a polymorphic Unfoldable1. Usually cleaner and more convenient than turbofish1, when applicable.

refold1 :: forall a. Semigroup a => Trivial1 a -> a

fold specialized to Trivial1. "Re-fold" a polymorphic Unfoldable1. Usually cleaner and more convenient than turbofish1, when applicable.

last1 :: forall a. Trivial1 a -> a

Returns the last element.

iterate :: forall a u. Unfoldable1 u => (a -> a) -> a -> u a

Create an infinite Unfoldable1 by repeated application of a function to a seed value. Analogous to iterateN, but with no iteration limit.

This should only be used to produce either lazy types (like lazy Lists) or types with truncating Unfoldable1 instances (like Maybe).

index1 :: forall a. Trivial1 a -> Int -> a

Get the element at the specified modular 0-index, i.e. the element at that 0-index in the elements infinitely extended left and right.

Will loop infinitely if given an infinite Unfoldable1 and a negative index. Will not loop infinitely if given an infinite Unfoldable1 and a nonnegative index; computes the length for itself as it iterates. Iterates twice when resolving an out of bounds index; does not store any intermediate results. In general, this function is not supposed to be used for modular indexing, because modular indexing just happens to be a simple and sensible way to guarantee an output, and there's no point in this existing without a guaranteed output (just use index). If you want modular indexing for the mod, please use an actual container.

head1 :: forall a. Trivial1 a -> a

Returns the first element.

foldEnum :: forall a b. BoundedEnum a => Semigroup b => (a -> b) -> b

Map each element of a BoundedEnum into a semigroup, and combine the results through refold1.

append1' :: forall a u. Unfoldable1 u => Trivial a -> Trivial1 a -> u a

Concatenate a possibly-empty Unfoldable with an Unfoldable1.

Do not use this to create a data structure. Please use Data.List.Lazy instead.

append1 :: forall a u. Unfoldable1 u => Trivial1 a -> Trivial a -> u a

Concatenate an Unfoldable1 with a possibly-empty Unfoldable.

Do not use this to create a data structure. Please use Data.List.Lazy instead.

Operator alias for Data.Unfoldable1.Trivial1.Internal.turbofish1 (right-associative / precedence 0)