Data.Unfoldable1.Trivial1

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.

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.

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.

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.

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).

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).

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

Create an infinite Unfoldable1 by repeating a single element.

head1 :: forall a. Trivial1 a -> a

Returns the first element.

last1 :: forall a. Trivial1 a -> a

Returns the last element.

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

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

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.

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.

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.

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)

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.

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