Data.Tuple.Experimental

Solo is the canonical lifted 1-tuple, just like Tuple2 is the canonical lifted 2-tuple (pair) and Tuple3 is the canonical lifted 3-tuple (triple).

The most important feature of Solo is that it is possible to force its "outside" (usually by pattern matching) without forcing its "inside", because it is defined as a datatype rather than a newtype. One situation where this can be useful is when writing a function to extract a value from a data structure. Suppose you write an implementation of arrays and offer only this function to index into them:

index :: Array a -> Int -> a

Now imagine that someone wants to extract a value from an array and store it in a lazy-valued finite map/dictionary:

insert "hello" (arr index 12) m

This can actually lead to a space leak. The value is not actually extracted from the array until that value (now buried in a map) is forced. That means the entire array may be kept live by just that value! Often, the solution is to use a strict map, or to force the value before storing it, but for some purposes that's undesirable.

One common solution is to include an indexing function that can produce its result in an arbitrary Applicative context:

indexA :: Applicative f => Array a -> Int -> f a

When using indexA in a pure context, Solo serves as a handy Applicative functor to hold the result. You could write a non-leaky version of the above example thus:

case arr indexA 12 of
  Solo a -> insert "hello" a m

While such simple extraction functions are the most common uses for unary tuples, they can also be useful for fine-grained control of strict-spined data structure traversals, and for unifying the implementations of lazy and strict mapping functions.

The unit datatype Unit has one non-undefined member, the nullary constructor ().

Extract the value from a Solo. Very often, values should be extracted directly using pattern matching, to control just what gets evaluated when. getSolo is for convenience in situations where that is not the case:

When the result is passed to a strict function, it makes no difference whether the pattern matching is done on the "outside" or on the "inside":

Data.Set.insert (getSolo sol) set === case sol of Solo v -> Data.Set.insert v set

A traversal may be performed in Solo in order to control evaluation internally, while using getSolo to extract the final result. A strict mapping function, for example, could be defined

map' :: Traversable t => (a -> b) -> t a -> t b
map' f = getSolo . traverse ((Solo $!) . f)

A tuple of zero elements, a synonym for Unit.

A tuple of one element, a synonym for Solo.

A tuple of ten elements.

A tuple of eleven elements.

A tuple of twelve elements.

A tuple of 13 elements.

A tuple of 14 elements.

A tuple of 15 elements.

A tuple of 16 elements.

A tuple of 17 elements.

A tuple of 18 elements.

A tuple of 19 elements.

A tuple of two elements.

A tuple of 20 elements.

A tuple of 21 elements.

A tuple of 22 elements.

A tuple of 23 elements.

A tuple of 24 elements.

A tuple of 25 elements.

A tuple of 26 elements.

A tuple of 27 elements.

A tuple of 28 elements.

A tuple of 29 elements.

A tuple of three elements.

A tuple of 30 elements.

A tuple of 31 elements.

A tuple of 32 elements.

A tuple of 33 elements.

A tuple of 34 elements.

A tuple of 35 elements.

A tuple of 36 elements.

A tuple of 37 elements.

A tuple of 38 elements.

A tuple of 39 elements.

A tuple of four elements.

A tuple of 40 elements.

A tuple of 41 elements.

A tuple of 42 elements.

A tuple of 43 elements.

A tuple of 44 elements.

A tuple of 45 elements.

A tuple of 46 elements.

A tuple of 47 elements.

A tuple of 48 elements.

A tuple of 49 elements.

A tuple of five elements.

A tuple of 50 elements.

A tuple of 51 elements.

A tuple of 52 elements.

A tuple of 53 elements.

A tuple of 54 elements.

A tuple of 55 elements.

A tuple of 56 elements.