Nonempty_list (p.preface.0.1.0.doc.preface.stdlib.Preface_stdlib.Nonempty

A Nonempty_list.t is a list that contains at least one element. Therefore, the head and tails functions are total and safe.

Type

Sourcetype 'a t = 'a Preface_core.Nonempty_list.t =

| Last of 'a
| :: of 'a * 'a t

Implementation

Functor

module Functor : Preface_specs.FUNCTOR with type 'a t = 'a t

Alt

module Alt : Preface_specs.ALT with type 'a t = 'a t

Applicative

Nonempty_list.t implements Preface_specs.APPLICATIVE and introduces an interface to define Preface_specs.TRAVERSABLE using Nonempty_list as an iterable structure.

module Applicative : 
  Preface_specs.Traversable.API_OVER_APPLICATIVE with type 'a t = 'a t

Selective

module Selective : Preface_specs.SELECTIVE with type 'a t = 'a t

Monad

Nonempty_list.t implements Preface_specs.MONAD and introduces an interface to define Preface_specs.TRAVERSABLE using Nonempty_list as an iterable structure.

module Monad : Preface_specs.Traversable.API_OVER_MONAD with type 'a t = 'a t

Comonad

module Comonad : Preface_specs.COMONAD with type 'a t = 'a t

Foldable

module Foldable : Preface_specs.FOLDABLE with type 'a t = 'a t

Delayed implementation

By setting the inner type type of Nonempty_list.t it is possible to get implementations for abstractions twithout type parameter.

Semigroup

Source

module Semigroup
  (T : Preface_specs.Types.T0) : 
  Preface_specs.SEMIGROUP with type t = T.t t

Addtional functions

Additional functions to facilitate practical work with Nonempty_list.t.

Sourceval pure : 'a -> 'a t

Create a value from 'a to 'a t.

Sourceval create : 'a -> 'a t

create x create a new non-empty list with x.

Sourceval from_list : 'a list -> 'a t option

Creates a non-empty list from a regular list.

Sourceval to_list : 'a t -> 'a list

Convert non-empty list to a regular list.

Sourceval hd : 'a t -> 'a

Returns the head of a non-empty list.

Sourceval tl : 'a t -> 'a t option

Returns the tail of a non-empty list.

Sourceval length : 'a t -> int

Returns the length of a non-empty list.

Sourceval cons : 'a -> 'a t -> 'a t

cons x xs is add x as head of xs.

Sourceval append : 'a t -> 'a t -> 'a t

append a b concat a and b.

Sourceval rev : 'a t -> 'a t

rev xs reverse xs.

Sourceval rev_append : 'a t -> 'a t -> 'a t

rev_append a b is a tail-recursive version of append (rev a) b.

Sourceval flatten : 'a t t -> 'a t

Concat a non-empty list of non-empty list

Sourceval iter : ('a -> unit) -> 'a t -> unit

List.iter for non-empty list.

Sourceval iteri : (int -> 'a -> unit) -> 'a t -> unit

List.iteri for non-empty list.

Sourceval map : ('a -> 'b) -> 'a t -> 'b t

List.map for non-empty list.

Sourceval mapi : (int -> 'a -> 'b) -> 'a t -> 'b t

List.mapi for non-empty list.

Sourceval reduce : ('a -> 'a -> 'a) -> 'a t -> 'a

reduce f xs reduce all value of xs into one.

Sourceval fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a

List.fold_left for non-empty list.

Sourceval fold_right : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b

List.fold_right for non-empty list.

Sourceval equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool

Equality between Nonempty_list.t.

Sourceval pp : (Format.formatter -> 'a -> unit) -> Format.formatter -> 'a t -> unit

Formatter for pretty-printing for Nonempty_list.t.