Module `Relude_List`

include Relude_List_Instances;

let concat: list('a) => list('a) => list('a);

module SemigroupAny = Relude_List_Instances.SemigroupAny;

let concatNamed: prefix:SemigroupAny.t('a) => SemigroupAny.t('a) => SemigroupAny.t('a);
let empty: list('a);

module MonoidAny = Relude_List_Instances.MonoidAny;

let guard: bool => MonoidAny.t('a) => MonoidAny.t('a);
let power: MonoidAny.t('a) => int => MonoidAny.t('a);
let map: ('a => 'b) => BsBastet.List.Functor.t('a) => BsBastet.List.Functor.t('b);

module Functor = Relude_List_Instances.Functor;

module BsFunctorExtensions = Relude_List_Instances.BsFunctorExtensions;

let flipMap: Functor.t('a) => ('a => 'b) => Functor.t('b);
let void: Functor.t('a) => Functor.t(unit);
let voidRight: 'a => Functor.t('b) => Functor.t('a);
let voidLeft: Functor.t('a) => 'b => Functor.t('b);
let flap: Functor.t(('a => 'b)) => 'a => Functor.t('b);
let apply: BsBastet.List.Apply.t(('a => 'b)) => BsBastet.List.Apply.t('a) => BsBastet.List.Apply.t('b);

module Apply = Relude_List_Instances.Apply;

module BsApplyExtensions = Relude_List_Instances.BsApplyExtensions;

let applyFirst: Apply.t('a) => Apply.t('b) => Apply.t('a);
let applySecond: Apply.t('a) => Apply.t('b) => Apply.t('b);
let map2: ('a => 'b => 'c) => Apply.t('a) => Apply.t('b) => Apply.t('c);
let map3: ('a => 'b => 'c => 'd) => Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t('d);
let map4: ('a => 'b => 'c => 'd => 'e) => Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t('d) => Apply.t('e);
let map5: ('a => 'b => 'c => 'd => 'e => 'f) => Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t('d) => Apply.t('e) => Apply.t('f);
let tuple2: Apply.t('a) => Apply.t('b) => Apply.t(('a, 'b));
let tuple3: Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t(('a, 'b, 'c));
let tuple4: Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t('d) => Apply.t(('a, 'b, 'c, 'd));
let tuple5: Apply.t('a) => Apply.t('b) => Apply.t('c) => Apply.t('d) => Apply.t('e) => Apply.t(('a, 'b, 'c, 'd, 'e));
let mapTuple2: ('a => 'b => 'c) => (Apply.t('a), Apply.t('b)) => Apply.t('c);
let mapTuple3: ('a => 'b => 'c => 'd) => (Apply.t('a), Apply.t('b), Apply.t('c)) => Apply.t('d);
let mapTuple4: ('a => 'b => 'c => 'd => 'e) => (Apply.t('a), Apply.t('b), Apply.t('c), Apply.t('d)) => Apply.t('e);
let mapTuple5: ('a => 'b => 'c => 'd => 'e => 'f) => (Apply.t('a), Apply.t('b), Apply.t('c), Apply.t('d), Apply.t('e)) => Apply.t('f);
let pure: 'a => BsBastet.List.Applicative.t('a);

module Applicative = Relude_List_Instances.Applicative;

module BsApplicativeExtensions = Relude_List_Instances.BsApplicativeExtensions;

let liftA1: ('a => 'b) => Applicative.t('a) => Applicative.t('b);
let bind: BsBastet.List.Monad.t('a) => ('a => BsBastet.List.Monad.t('b)) => BsBastet.List.Monad.t('b);

module Monad = Relude_List_Instances.Monad;

module BsMonadExtensions = Relude_List_Instances.BsMonadExtensions;

let flatMap: ('a => Monad.t('b)) => Monad.t('a) => Monad.t('b);
let flatten: Monad.t(Monad.t('a)) => Monad.t('a);
let composeKleisli: ('a => Monad.t('b)) => ('b => Monad.t('c)) => 'a => Monad.t('c);
let flipComposeKleisli: ('b => Monad.t('c)) => ('a => Monad.t('b)) => 'a => Monad.t('c);
let liftM1: ('a => 'b) => Monad.t('a) => Monad.t('b);
let when_: Monad.t(bool) => Monad.t(unit) => Monad.t(unit);
let unless: Monad.t(bool) => Monad.t(unit) => Monad.t(unit);
let alt: BsBastet.List.Alt.t('a) => BsBastet.List.Alt.t('a) => BsBastet.List.Alt.t('a);

module Alt = Relude_List_Instances.Alt;

let orElse: fallback:Alt.t('a) => Alt.t('a) => Alt.t('a);

module Plus = Relude_List_Instances.Plus;

module Alternative = Relude_List_Instances.Alternative;

let foldLeft: ('a => 'b => 'a) => 'a => BsBastet.List.Foldable.t('b) => 'a;
let foldRight: ('a => 'b => 'b) => 'b => BsBastet.List.Foldable.t('a) => 'b;

module Foldable = Relude_List_Instances.Foldable;

module BsFoldableExtensions = Relude_List_Instances.BsFoldableExtensions;

let any: ('a => bool) => Foldable.t('a) => bool;
let all: ('a => bool) => Foldable.t('a) => bool;
let containsBy: ('a => 'a => bool) => 'a => Foldable.t('a) => bool;
let contains: (module BsBastet.Interface.EQ with type t = 'a) => 'a => Foldable.t('a) => bool;
let indexOfBy: ('a => 'a => bool) => 'a => Foldable.t('a) => option(int);
let indexOf: (module BsBastet.Interface.EQ with type t = 'a) => 'a => Foldable.t('a) => option(int);
let minBy: ('a => 'a => BsBastet.Interface.ordering) => Foldable.t('a) => option('a);
let min: (module BsBastet.Interface.ORD with type t = 'a) => Foldable.t('a) => option('a);
let maxBy: ('a => 'a => BsBastet.Interface.ordering) => Foldable.t('a) => option('a);
let max: (module BsBastet.Interface.ORD with type t = 'a) => Foldable.t('a) => option('a);
let countBy: ('a => bool) => Foldable.t('a) => int;
let length: Foldable.t('a) => int;
let size: Foldable.t('a) => int;
let count: Foldable.t('a) => int;
let forEach: ('a => unit) => Foldable.t('a) => unit;
let forEachWithIndex: ('a => int => unit) => Foldable.t('a) => unit;
let find: ('a => bool) => Foldable.t('a) => option('a);
let findWithIndex: ('a => int => bool) => Foldable.t('a) => option('a);
let toList: Foldable.t('a) => list('a);

module FoldableSemigroupExtensions = Relude_List_Instances.FoldableSemigroupExtensions;

module FoldableMonoidExtensions = Relude_List_Instances.FoldableMonoidExtensions;

let foldMap: (module BsBastet.Interface.MONOID with type t = 'a) => ('b => 'a) => Foldable.t('b) => 'a;
let foldWithMonoid: (module BsBastet.Interface.MONOID with type t = 'a) => Foldable.t('a) => 'a;
let intercalate: (module BsBastet.Interface.MONOID with type t = 'a) => 'a => Foldable.t('a) => 'a;

module FoldableApplicativeExtensions = Relude_List_Instances.FoldableApplicativeExtensions;

module FoldableMonadExtensions = Relude_List_Instances.FoldableMonadExtensions;

module FoldableEqExtensions = Relude_List_Instances.FoldableEqExtensions;

module FoldableOrdExtensions = Relude_List_Instances.FoldableOrdExtensions;

let unfold: ('a => option(('a, 'a))) => 'a => BsBastet.List.Unfoldable.t('a);

module Unfoldable = Relude_List_Instances.Unfoldable;

module Traversable = Relude_List_Instances.Traversable;

let eqBy: ('a => 'a => bool) => list('a) => list('a) => bool;
let eq: (module BsBastet.Interface.EQ with type t = 'a) => list('a) => list('a) => bool;

module Eq = Relude_List_Instances.Eq;

let showBy: ('a => string) => list('a) => string;
let show: (module BsBastet.Interface.SHOW with type t = 'a) => list('a) => string;

module Show = Relude_List_Instances.Show;

let fromArray: array('a) => Belt.List.t('a);
let toArray: Belt.List.t('a) => array('a);

module IsoArray = Relude_List_Instances.IsoArray;

include Relude_List_Base;

let cons: 'a => list('a) => list('a);
let prepend: 'a => list('a) => list('a);
let uncons: list('a) => option(('a, list('a)));
let append: 'a => list('a) => list('a);
let repeat: int => 'a => list('a);
let makeWithIndex: int => (int => 'a) => list('a);
let mapWithIndex: ('a => int => 'b) => list('a) => list('b);
let reverse: list('a) => list('a);
let shuffle: list('a) => list('a);
let isEmpty: list('a) => bool;
let isNotEmpty: list('a) => bool;
let at: int => list('a) => option('a);
let head: list('a) => option('a);
let tail: list('a) => option(list('a));
let tailOrEmpty: list('a) => list('a);
let init: list('a) => option(list('a));
let initOrEmpty: list('a) => list('a);
let last: list('a) => option('a);
let take: int => list('a) => list('a);
let takeExactly: int => list('a) => option(list('a));
let takeWhile: ('a => bool) => list('a) => list('a);
let drop: int => list('a) => list('a);
let dropExactly: int => list('a) => option(list('a));
let dropWhile: ('a => bool) => list('a) => list('a);
let filter: ('a => bool) => list('a) => list('a);
let keep: ('a => bool) => list('a) => list('a);
let filterWithIndex: ('a => int => bool) => list('a) => list('a);
let keepWithIndex: ('a => int => bool) => list('a) => list('a);
let filterNot: ('a => bool) => list('a) => list('a);
let reject: ('a => bool) => list('a) => list('a);
let filterNotWithIndex: ('a => int => bool) => list('a) => list('a);
let rejectWithIndex: ('a => int => bool) => list('a) => list('a);
let mapOption: ('a => option('b)) => list('a) => list('b);
let catOptions: list(option('a)) => list('a);
let partition: ('a => bool) => list('a) => (list('a), list('a));
let splitAt: int => list('a) => option((list('a), list('a)));
let prependToAll: 'a => list('a) => list('a);
let intersperse: 'a => list('a) => list('a);
let replicate: int => list('a) => list('a);
let zip: list('a) => list('b) => list(('a, 'b));
let zipWith: ('a => 'b => 'c) => list('a) => list('b) => list('c);
let zipWithIndex: list('a) => list(('a, int));
let unzip: list(('a, 'b)) => (list('a), list('b));
let sortWithInt: ('a => 'a => int) => list('a) => list('a);
let sortBy: ('a => 'a => BsBastet.Interface.ordering) => list('a) => list('a);
let sort: (module BsBastet.Interface.ORD with type t = 'a) => list('a) => list('a);
let distinctBy: ('a => 'a => bool) => list('a) => list('a);
let removeFirstBy: ('a => 'a => bool) => 'a => list('a) => list('a);
let removeEachBy: ('a => 'a => bool) => 'a => list('a) => list('a);
let distinct: (module BsBastet.Interface.EQ with type t = 'a) => list('a) => list('a);
let removeFirst: (module BsBastet.Interface.EQ with type t = 'a) => 'a => list('a) => list('a);
let removeEach: (module BsBastet.Interface.EQ with type t = 'a) => 'a => list('a) => list('a);
let replaceAt: int => 'a => list('a) => list('a);
let scanLeft: ('b => 'a => 'b) => 'b => list('a) => list('b);
let scanRight: ('a => 'b => 'b) => 'b => list('a) => list('b);
let insertAt: int => 'a => list('a) => list('a);
let updateAt: int => ('a => 'a) => list('a) => list('a);
let swapAt: int => int => list('a) => list('a);
let removeAt: int => list('a) => list('a);
let chunk: int => list('a) => list(list('a));

include Relude_List_Specializations;

module ListEqExtensions = Relude_List_Specializations.ListEqExtensions;

module ListOrdExtensions = Relude_List_Specializations.ListOrdExtensions;

module ListMonoidExtensions = Relude_List_Specializations.ListMonoidExtensions;

module String = Relude_List_Specializations.String;

module Int = Relude_List_Specializations.Int;

module Float = Relude_List_Specializations.Float;

module Option = Relude_List_Specializations.Option;

module Result = Relude_List_Specializations.Result;

module IO = Relude_List_Specializations.IO;

module Validation = Relude_List_Specializations.Validation;

module Infix: { ... };