Zero is the base value for the Peano numbers.

Succ represents the next number in the sequence of natural numbers.

It takes a nat (a natural number) as an argument.

Zero is a nat, allowing Succ Zero to represent 1.

Succ is also a nat, so it can be applied to itself, allowing Succ (Succ Zero) to represent 2, Succ (Succ (Succ Zero)) to represent 3, and so on.

Type-level natural number utility typeclass

Adds two type-level naturals.

See the mlappend type signature for an example.

> :t typeNat :: AddNat (Succ (Succ Zero)) (Succ Zero)

typeNat :: AddNat (Succ (Succ Zero)) (Succ Zero)
  :: Succ (Succ (Succ Zero))

Calculates the maximum of two type-level naturals.

See the mlunion type signature for an example.

> :t typeNat :: MaxNat (Succ (Succ Zero)) (Succ Zero)

typeNat :: MaxNat (Succ (Succ Zero)) (Succ Zero)
  :: Succ (Succ Zero)

A wrapper around a container which encodes its minimum length in the type system. This allows functions like head and maximum to be made safe without using Maybe.

The length, nat, is encoded as a Peano number, which starts with the Zero constructor and is made one larger with each application of Succ (Zero for 0, Succ Zero for 1, Succ (Succ Zero) for 2, etc.). Functions which require at least one element, then, are typed with Succ nat, where nat is either Zero or any number of applications of Succ:

head :: MonoTraversable mono => MinLen (Succ nat) mono -> Element mono

The length is also a phantom type, i.e. it is only used on the left hand side of the type and doesn't exist at runtime. Notice how Succ Zero isn't included in the printed output:

> toMinLen [1,2,3] :: Maybe (MinLen (Succ Zero) [Int])
Just (MinLen {unMinLen = [1,2,3]})

You can still use GHCI's :i command to see the phantom type information:

> let xs = mlcons 1 $ toMinLenZero []
> :i xs
xs :: Num t => MinLen (Succ Zero) [t]

Get the monomorphic container out of a MinLen wrapper.

Types a container as having a minimum length of zero. This is useful when combined with other MinLen functions that increase the size of the container.

Examples

> 1 `mlcons` toMinLenZero []
MinLen {unMinLen = [1]}

Attempts to add a MinLen constraint to a monomorphic container.

Examples

> let xs = toMinLen [1,2,3] :: Maybe (MinLen (Succ Zero) [Int])
> xs
Just (MinLen {unMinLen = [1,2,3]})

> :i xs
xs :: Maybe (MinLen (Succ Zero) [Int])

> toMinLen [] :: Maybe (MinLen (Succ Zero) [Int])
Nothing

Unsafe

Although this function itself cannot cause a segfault, it breaks the safety guarantees of MinLen and can lead to a segfault when using otherwise safe functions.

Examples

> let xs = unsafeToMinLen [] :: MinLen (Succ Zero) [Int]
> olength xs
0
> head xs
*** Exception: Data.MonoTraversable.headEx: empty

Adds an element to the front of a list, increasing its minimum length by 1.

Examples

> let xs = unsafeToMinLen [1,2,3] :: MinLen (Succ Zero) [Int]
> 0 `mlcons` xs
MinLen {unMinLen = [0,1,2,3]}

Concatenate two sequences, adding their minimum lengths together.

Examples

> let xs = unsafeToMinLen [1,2,3] :: MinLen (Succ Zero) [Int]
> xs `mlappend` xs
MinLen {unMinLen = [1,2,3,1,2,3]}

Joins two semigroups, keeping the larger MinLen of the two.

Examples

> let xs = unsafeToMinLen [1] :: MinLen (Succ Zero) [Int]
> let ys = xs `mlunion` xs
> ys
MinLen {unMinLen = [1,1]}

> :i ys
ys :: MinLen (Succ Zero) [Int]

Return the first element of a monomorphic container.

Safe version of headEx, only works on monomorphic containers wrapped in a MinLen (Succ nat).

Return the last element of a monomorphic container.

Safe version of lastEx, only works on monomorphic containers wrapped in a MinLen (Succ nat).

Returns all but the first element of a sequence, reducing its MinLen by 1.

Safe, only works on sequences wrapped in a MinLen (Succ nat).

Examples

> let xs = toMinLen [1,2,3] :: Maybe (MinLen (Succ Zero) [Int])
> fmap tailML xs
Just (MinLen {unMinLen = [2,3]})

Returns all but the last element of a sequence, reducing its MinLen by 1.

Safe, only works on sequences wrapped in a MinLen (Succ nat).

Examples

> let xs = toMinLen [1,2,3] :: Maybe (MinLen (Succ Zero) [Int])
> fmap initML xs
Just (MinLen {unMinLen = [1,2]})

olength (x <> y) >= olength x + olength y

Map each element of a monomorphic container to a semigroup, and combine the results.

Safe version of ofoldMap1Ex, only works on monomorphic containers wrapped in a MinLen (Succ nat).

Examples

> let xs = ("hello", 1 :: Integer) `mlcons` (" world", 2) `mlcons` (toMinLenZero [])
> ofoldMap1 fst xs
"hello world"

Join a monomorphic container, whose elements are Semigroups, together.

Safe, only works on monomorphic containers wrapped in a MinLen (Succ nat).

Examples

> let xs = "a" `mlcons` "b" `mlcons` "c" `mlcons` (toMinLenZero [])
> xs
MinLen {unMinLen = ["a","b","c"]}

> ofold1 xs
"abc"

Right-associative fold of a monomorphic container with no base element.

Safe version of ofoldr1Ex, only works on monomorphic containers wrapped in a MinLen (Succ nat).

foldr1 f = Prelude.foldr1 f . otoList

Examples

> let xs = "a" `mlcons` "b" `mlcons` "c" `mlcons` (toMinLenZero [])
> ofoldr1 (++) xs
"abc"

Strict left-associative fold of a monomorphic container with no base element.

Safe version of ofoldl1Ex', only works on monomorphic containers wrapped in a MinLen (Succ nat).

foldl1' f = Prelude.foldl1' f . otoList

Examples

> let xs = "a" `mlcons` "b" `mlcons` "c" `mlcons` (toMinLenZero [])
> ofoldl1' (++) xs
"abc"

Get the maximum element of a monomorphic container.

Safe version of maximumEx, only works on monomorphic containers wrapped in a MinLen (Succ nat).

Examples

> let xs = toMinLen [1,2,3] :: Maybe (MinLen (Succ Zero) [Int])
> fmap maximum xs
Just 3

Get the minimum element of a monomorphic container.

Safe version of minimumEx, only works on monomorphic containers wrapped in a MinLen (Succ nat).

Examples

> let xs = toMinLen [1,2,3] :: Maybe (MinLen (Succ Zero) [Int])
> fmap minimum xs
Just 1

Get the maximum element of a monomorphic container, using a supplied element ordering function.

Safe version of maximumByEx, only works on monomorphic containers wrapped in a MinLen (Succ nat).

Get the minimum element of a monomorphic container, using a supplied element ordering function.

Safe version of minimumByEx, only works on monomorphic containers wrapped in a MinLen (Succ nat).