Sunbelt Computer Software

This is an O(n*m) operation, where n and m are the lengths of the input lists.

list1 : 'T1 list

The first input list.

list2 : 'T2 list

The second input list.

Returns: ('T1 * 'T2) list

The resulting list of pairs.

Example

 let people = [ "Kirk"; "Spock"; "McCoy" ]
 let numbers = [ 1; 2 ]

 people |> List.allPairs numbers

 [ (1, "Kirk"); (1, "Spock"); (1, "McCoy"); (2, "Kirk"); (2, "Spock"); (2, "McCoy") ]

This is an O(n) operation, where n is the length of the first list.

list1 : 'T list

The first input list.

list2 : 'T list

The second input list.

Returns: 'T list

The resulting list.

Example

 List.append [ 1..3 ] [ 4..7 ]
 
 [ 4..7 ] |> List.append [ 1..3 ]

 [ 1; 2; 3; 4; 5; 6; 7 ]

This is an O(n) operation, where n is the length of the list.

list : ^T list

The input list.

Returns: ^T

The resulting average.

Example

 [1.0 .. 9.0] |> List.average

 5.0

This is an O(n) operation, where n is the length of the list.

projection : 'T -> ^U

The function to transform the list elements into the values to be averaged.

list : 'T list

The input list.

Returns: ^U

The resulting average.

Example

Calculate average age of persons by extracting their age from a record type.

 type People = { Name: string; Age: int }

 let getAgeAsFloat person = float person.Age

 let people = 
     [ { Name = "Kirk"; Age = 26 }
       { Name = "Spock"; Age = 90 }
       { Name = "McCoy"; Age = 37 } ]

 people |> List.averageBy getAgeAsFloat

 51.0

This is an O(n) operation, where n is the length of the list.

chooser : 'T -> 'U option

The function to be applied to the list elements.

list : 'T list

The input list.

Returns: 'U list

The resulting list comprising the values v where the chooser function returned Some(x).

Example

Using the identity function id (is defined like fun x -> x):

 
 let input1 = [ Some 1; None; Some 3; None ]

 input1 |> List.choose id

 [ 1; 3 ]

Example

 type Happiness =
     | AlwaysHappy
     | MostOfTheTimeGrumpy

 type People = { Name: string; Happiness: Happiness }

 let takeJustHappyPersons person =
     match person.Happiness with
     | AlwaysHappy -> Some person.Name
     | MostOfTheTimeGrumpy -> None

 let candidatesForTheTrip = 
     [ { Name = "SpongeBob"
         Happiness = AlwaysHappy }
       { Name = "Patrick"
         Happiness = AlwaysHappy }
       { Name = "Squidward"
         Happiness = MostOfTheTimeGrumpy } ]

 candidatesForTheTrip
 |> List.choose takeJustHappyPersons

 [ "SpongeBob"; "Patrick" ]

Example

 let input3: int option list = [] 

 input3 |> List.choose id
 Evaluates to:
 empty list

Example

 let input4: string option list = [None; None]

 input4 |> List.choose id
 Evaluates to
 empty list

Example

Using the identity function id (is defined like fun x -> x):

 
 let input5 = [ Some 1; None; Some 3; None ]

 input5 |> List.choose id  // evaluates [1; 3]

This is an O(n) operation, where n is the length of the list.

chunkSize : int

The maximum size of each chunk.

list : 'T list

The input list.

Returns: 'T list list

The list divided into chunks.

Example

 [ 1..10 ] |> List.chunkBySize 3

 [ [ 1; 2; 3 ]
   [ 4; 5; 6 ]
   [ 7; 8; 9 ]
   [ 10 ] ]

Example

 [ 1..5 ] |> List.chunkBySize 10

 [ [ 1; 2; 3; 4; 5 ] ]

This is an O(n) operation, where n is the total length of all resulting sublists.

mapping : 'T -> 'U list

The function to transform each input element into a sublist to be concatenated.

list : 'T list

The input list.

Returns: 'U list

The concatenation of the transformed sublists.

Example

For each positive number in the array we are generating all the previous positive numbers

 [1..4] |> List.collect (fun x -> [1..x])

This is an O(min(n,m)) operation, where n and m are the lengths of the lists.

comparer : 'T -> 'T -> int

A function that takes an element from each list and returns an int. If it evaluates to a non-zero value iteration is stopped and that value is returned.

list1 : 'T list

The first input list.

list2 : 'T list

The second input list.

Returns: int

Returns the first non-zero result from the comparison function. If the first list has a larger element, the return value is always positive. If the second list has a larger element, the return value is always negative. When the elements are equal in the two lists, 1 is returned if the first list is longer, 0 is returned if they are equal in length, and -1 is returned when the second list is longer.

Example

 let closerToNextDozen a b =
   (a % 12).CompareTo(b % 12)

 let input1 = [1; 10]
 let input2 = [1; 10]

 (input1, input2) ||> List.compareWith closerToNextDozen

Example

 let closerToNextDozen a b =
   (a % 12).CompareTo(b % 12)

 let input1 = [1; 5]
 let input2 = [1; 8]

 (input1, input2) ||> List.compareWith closerToNextDozen

Example

 let closerToNextDozen a b =
   (a % 12).CompareTo(b % 12)

 let input1 = [1; 11]
 let input2 = [1; 13]

 (input1, input2) ||> List.compareWith closerToNextDozen

Example

 let closerToNextDozen a b =
   (a % 12).CompareTo(b % 12)

 let input1 = [1; 2]
 let input2 = [1]

 (input1, input2) ||> List.compareWith closerToNextDozen

Example

 let closerToNextDozen a b =
   (a % 12).CompareTo(b % 12)

 let input1 = [1]
 let input2 = [1; 2]

 (input1, input2) ||> List.compareWith closerToNextDozen

This is an O(n) operation, where n is the total number of elements across all lists.

lists : 'T list seq

The input sequence of lists.

Returns: 'T list

The resulting concatenated list.

Example

 let input = [ [1;2]
               [3;4;5]
               [6;7;8;9] ]
 input |> List.concat  // evaluates [1; 2; 3; 4; 5; 6; 7; 8; 9]

This is an O(n) operation, where n is the length of the list.

value : 'T

The value to locate in the input list.

source : 'T list

The input list.

Returns: bool

True if the input list contains the specified element; false otherwise.

Example

 [1..9] |> List.contains 0

Example

 [1..9] |> List.contains 3

Example

 let input = [1, "SpongeBob"; 2, "Patrick"; 3, "Squidward"; 4, "Mr. Krabs"]

 input |> List.contains (2, "Patrick")

Example

 let input = [1, "SpongeBob"; 2, "Patrick"; 3, "Squidward"; 4, "Mr. Krabs"]

 input |> List.contains (22, "Patrick")

This is an O(n) operation, where n is the length of the list.

projection : 'T -> 'Key

A function transforming each item of the input list into a key to be compared against the others.

list : 'T list

The input list.

Returns: ('Key * int) list

The result list.

Example

Counting the number of occurrences of chars

 let input = ['H'; 'a'; 'p'; 'p'; 'y']

 input |> List.countBy id

This is an O(n) operation, where n is the length of the list.

list : 'T list

The input list.

Returns: 'T list

The result list.

Example

 let input = [6;1;2;3;1;4;5;5]

 input |> List.distinct

This is an O(n) operation, where n is the length of the list.

projection : 'T -> 'Key

A function transforming the list items into comparable keys.

list : 'T list

The input list.

Returns: 'T list

The result list.

Example

 let isEven x = 0 = x % 2

 let input = [6;1;2;3;1;4;5;5]

 input |> List.distinctBy isEven  // evaluates [6; 1]

This is an O(1) operation.

Returns: 'T list

This is an O(1) operation.

list : 'T list

The input list.

Returns: 'T

The only element of the list.

Example

 ["the chosen one"] |> List.exactlyOne // evaluates "the chosen one"

Example

 let input : string list = []

 input |> List.exactlyOne

Example

 [1..5] |> List.exactlyOne

This is an O(n+m) operation, where n is the length of the list and m is the length of the items to exclude.

itemsToExclude : 'T seq

A sequence whose elements that also occur in the input list will cause those elements to be removed from the result.

list : 'T list

A list whose elements that are not also in itemsToExclude will be returned.

Returns: 'T list

A list that contains the distinct elements of list that do not appear in itemsToExclude.

Example

 let input = [1, "Kirk"; 2, "Spock"; 3, "Kenobi"] 

 input |> List.except [3, "Kenobi"]

Example

 [0..10] |> List.except [1..5]  // evaluates [0; 6; 7; 8; 9; 10]

Example

 [1..5] |> List.except [0..10]  // evaluates []

The predicate is applied to the elements of the input list. If any application returns true then the overall result is true and no further elements are tested. Otherwise, false is returned. This is an O(n) operation in the worst case, where n is the length of the list.

predicate : 'T -> bool

The function to test the input elements.

list : 'T list

The input list.

Returns: bool

True if any element satisfies the predicate.

Example

 let input = [1, "Kirk"; 2, "Spock"; 3, "Kenobi"] 
 
 input |> List.exists (fun x -> x = (3, "Kenobi"))  // evaluates true
 
 input |> List.exists (fun (n, name) -> n > 5)      // evaluates false

The predicate is applied to matching elements in the two collections up to the lesser of the two lengths of the collections. If any application returns true then the overall result is true and no further elements are tested. Otherwise, if one collections is longer than the other then the ArgumentException exception is raised. Otherwise, false is returned. This is an O(n) operation in the worst case, where n is the length of the lists.

predicate : 'T1 -> 'T2 -> bool

The function to test the input elements.

list1 : 'T1 list

The first input list.

list2 : 'T2 list

The second input list.

Returns: bool

True if any pair of elements satisfy the predicate.

Example

Check if the sum of pairs (from 2 different lists) have at least one even number

 let anEvenSum a b  = 0 = (a + b) % 2
 
 ([1..4], [2..5]) 
 ||> List.exists2 anEvenSum     // evaluates false
 
 ([1..4], [2;4;5;6])
 ||> List.exists2 anEvenSum   // evaluates true

This is an O(n) operation, where n is the length of the list.

predicate : 'T -> bool

The function to test the input elements.

list : 'T list

The input list.

Returns: 'T list

A list containing only the elements that satisfy the predicate.

Example

 let input = [1, "Luke"; 2, "Kirk"; 3, "Kenobi"; 4, "Spock"]

 let isEven x = 0 = x % 2

 let isComingFromStarTrek (x,_) = isEven x
 
 input |> List.filter isComingFromStarTrek

This is an O(n) operation in the worst case, where n is the length of the list.

predicate : 'T -> bool

The function to test the input elements.

list : 'T list

The input list.

Returns: 'T

The first element that satisfies the predicate.

Example

 let isEven x  = 0 = x % 2

 let isGreaterThan x y = y > x

 let input = [1, "Luke"; 2, "Kirk"; 3, "Spock"; 4, "Kenobi"]
 
 input |> List.find (fun (x,_) -> isEven x)              // evaluates (2, "Kirk")
 input |> List.find (fun (x,_) -> x |> isGreaterThan 6)  // raises an exception

This is an O(n) operation, where n is the length of the list.

predicate : 'T -> bool

The function to test the input elements.

list : 'T list

The input list.

Returns: 'T

The last element that satisfies the predicate.

Example

 let isEven x  = 0 = x % 2

 let isGreaterThan x y = y > x

 let input = [1, "Luke"; 2, "Kirk"; 3, "Spock"; 4, "Kenobi"]
 
 input |> List.findBack (fun (x,_) -> isEven x)              // evaluates (4, "Kenobi")
 input |> List.findBack (fun (x,_) -> x |> isGreaterThan 6)  // raises an exception

This is an O(n) operation in the worst case, where n is the length of the list.

predicate : 'T -> bool

The function to test the input elements.

list : 'T list

The input list.

Returns: int

The index of the first element that satisfies the predicate.

Example

 let isEven x  = 0 = x % 2

 let isGreaterThan x y = y > x

 let input = [1, "Luke"; 2, "Kirk"; 3, "Spock"; 4, "Kenobi"]
 
 input |> List.findIndex (fun (x,_) -> isEven x)              // evaluates 1
 input |> List.findIndex (fun (x,_) -> x |> isGreaterThan 6)  // raises an exception

This is an O(n) operation, where n is the length of the list.

predicate : 'T -> bool

The function to test the input elements.

list : 'T list

The input list.

Returns: int

The index of the last element that satisfies the predicate.

Example

 let isEven x  = 0 = x % 2

 let isGreaterThan x y = y > x

 let input = [1, "Luke"; 2, "Kirk"; 3, "Spock"; 4, "Kenobi"]
 
 input |> List.findIndexBack (fun (x,_) -> isEven x)              // evaluates 3
 input |> List.findIndexBack (fun (x,_) -> x |> isGreaterThan 6)  // raises an exception

This is an O(n) operation, where n is the length of the list.

folder : 'State -> 'T -> 'State

The function to update the state given the input elements.

state : 'State

The initial state.

list : 'T list

The input list.

Returns: 'State

The final state value.

Example

Making the sum of squares for the first 5 natural numbers

 (0, [1..5]) ||> List.fold (fun s v -> s + v * v)  // evaluates 55

Example

Shopping for fruits hungry, you tend to take more of each as the hunger grows

 type Fruit = Apple | Pear | Orange

 type BagItem = { fruit: Fruit; quantity: int }

 let takeMore (previous: BagItem list) fruit = 
     let toTakeThisTime = 
         match previous with 
         | bagItem :: otherBagItems -> bagItem.quantity + 1 
         | [] -> 1 
     { fruit = fruit; quantity = toTakeThisTime } :: previous

 let inputs = [ Apple; Pear; Orange ]
 
 ([], inputs) ||> List.fold takeMore

  [{ fruit = Orange; quantity = 3 }
   { fruit = Pear; quantity = 2 }
   { fruit = Apple; quantity = 1 }]

This is an O(n) operation, where n is the length of the lists.

folder : 'State -> 'T1 -> 'T2 -> 'State

The function to update the state given the input elements.

state : 'State

The initial state.

list1 : 'T1 list

The first input list.

list2 : 'T2 list

The second input list.

Returns: 'State

The final state value.

Example

Count the number of times the coins match:
 type CoinToss = Head | Tails

 let inputs1 = [Tails; Head; Tails]
 let inputs2 = [Tails; Head; Head]

 (0, inputs1, inputs2) |||> List.fold2 (fun acc input1 input2 ->
     match (input1, input2) with
     | Head, Head -> acc + 1
     | Tails, Tails -> acc + 1
     | _ -> acc)

This is an O(n) operation, where n is the length of the list.

folder : 'T -> 'State -> 'State

The function to update the state given the input elements.

list : 'T list

The input list.

state : 'State

The initial state.

Returns: 'State

The state object after the folding function is applied to each element of the list.

Example

Making the sum of squares for the first 5 natural numbers

 ([1..5], 0) ||> List.foldBack (fun v acc -> acc + v * v)  // evaluates 55

Example

Shopping for fruits hungry, you tend to take more of each as the hunger grows

 type Fruit = Apple | Pear | Orange

 type BagItem = { fruit: Fruit; quantity: int }

 let takeMore fruit (previous: BagItem list) =
     let toTakeThisTime = 
         match previous with 
         | bagItem :: otherBagItems -> bagItem.quantity + 1 
         | [] -> 1 
     { fruit = fruit; quantity = toTakeThisTime } :: previous

 let input = [ Apple; Pear; Orange ]
 
 (input, []) ||> List.foldBack takeMore

  [{ fruit = Apple; quantity = 3 }
   { fruit = Pear; quantity = 2 }
   { fruit = Orange; quantity = 1 }]

This is an O(n) operation, where n is the length of the lists.

folder : 'T1 -> 'T2 -> 'State -> 'State

The function to update the state given the input elements.

list1 : 'T1 list

The first input list.

list2 : 'T2 list

The second input list.

state : 'State

The initial state.

Returns: 'State

The final state value.

Example

Count the positives, negatives and accumulate some text from back to front:
 type Count =
   { Positive: int
     Negative: int
     Text: string }

 let inputs1 = [ -1; -2; -3 ]
 let inputs2 = [ 3; 2; 1 ]
 let initialState = {Positive = 0; Negative = 0; Text = ""}

 (inputs1, inputs2, initialState) |||> List.foldBack2 (fun a b acc  ->
     let text = acc.Text + "(" + string a + "," + string b + ") "
     if a + b >= 0 then
         { acc with
             Positive = acc.Positive + 1
             Text = text }
     else
         { acc with
             Negative = acc.Negative + 1
             Text = text }
 )

 { Positive = 2
   Negative = 1
   Text = "(-3,1) (-2,2) (-1,3) " }

The predicate is applied to the elements of the input list. If any application returns false then the overall result is false and no further elements are tested. Otherwise, true is returned. This is an O(n) operation in the worst case, where n is the length of the list.

predicate : 'T -> bool

The function to test the input elements.

list : 'T list

The input list.

Returns: bool

True if all of the elements satisfy the predicate.

Example

 let isEven a = a % 2 = 0

 [2; 42] |> List.forall isEven // evaluates to true

 [1; 2] |> List.forall isEven // evaluates to false

The predicate is applied to matching elements in the two collections up to the lesser of the two lengths of the collections. If any application returns false then the overall result is false and no further elements are tested. Otherwise, if one collection is longer than the other then the ArgumentException exception is raised. Otherwise, true is returned. This is an O(n) operation in the worst case, where n is the length of the lists.

predicate : 'T1 -> 'T2 -> bool

The function to test the input elements.

list1 : 'T1 list

The first input list.

list2 : 'T2 list

The second input list.

Returns: bool

True if all of the pairs of elements satisfy the predicate.

Example

 let inputs1 = [1; 2; 3]
 let inputs2 = [1; 2; 3]

 (inputs1, inputs2) ||> List.forall2 (=)

Example

 let items1 = [2017; 1; 1]
 let items2 = [2019; 19; 8]

 (items1, items2) ||> List.forall2 (=)

Example

 let items1 = [1; 2; 3]
 let items2 = [1; 2]

 (items1, items2) ||> List.forall2 (=)

This is an O(n) operation, where n is the length of the list.

projection : 'T -> 'Key

A function that transforms an element of the list into a comparable key.

list : 'T list

The input list.

Returns: ('Key * 'T list) list

The result list.

Example

 let inputs = [1; 2; 3; 4; 5]

 inputs |> List.groupBy (fun n -> n % 2)

Lists are represented as linked lists so this is an O(1) operation.

list : 'T list

The input list.

Returns: 'T

The first element of the list.

Example

 let inputs = ["banana"; "pear"]

 inputs |> List.head

Example

 [] |> List.head

This is an O(n) operation, where n is the length of the list.

list : 'T list

The input list.

Returns: (int * 'T) list

The list of indexed elements.

Example

 let inputs = ["a"; "b"; "c"]

 inputs |> List.indexed

This is an O(n) operation, where n is the specified count.

length : int

The length of the list to generate.

initializer : int -> 'T

The function to generate an element from an index.

Returns: 'T list

The list of generated elements.

Example

 List.init 4 (fun v -> v + 5)

Example

 List.init -5 (fun v -> v + 5)

This is an O(n) operation, where n is the length of the list.

index : int

The index where the item should be inserted.

value : 'T

The value to insert.

source : 'T list

The input list.

Returns: 'T list

The result list.

Example

 let inputs = [ 0; 1; 2 ]

 inputs |> List.insertAt 1 9

This is an O(n+m) operation, where n is the length of the list and m is the number of elements to insert.

index : int

The index where the items should be inserted.

values : 'T seq

The values to insert.

source : 'T list

The input list.

Returns: 'T list

The result list.

Example

 let inputs = [ 0; 1; 2 ]

 inputs |> List.insertManyAt 1 [ 8; 9 ]
 Evaluates to [ 0; 8; 9; 1; 2 ].

This is an O(1) operation.

list : 'T list

The input list.

Returns: bool

True if the list is empty.

Example

 [ ] |> List.isEmpty

Example

 [ "pear"; "banana" ] |> List.isEmpty

Lists are represented as linked lists so this is an O(n) operation, where n is the index.

index : int

The index to retrieve.

list : 'T list

The input list.

Returns: 'T

The value at the given index.

Example

 let inputs = [ "a"; "b"; "c" ]

 inputs |> List.item 1

Example

 let inputs = [ "a"; "b"; "c" ]

 inputs |> List.item 4

This is an O(n) operation, where n is the length of the list.

action : 'T -> unit

The function to apply to elements from the input list.

list : 'T list

The input list.

Example

 let inputs = [ "a"; "b"; "c" ]

 inputs |> List.iter (printfn "%s")

 a
 b
 c

This is an O(n) operation, where n is the length of the lists.

action : 'T1 -> 'T2 -> unit

The function to apply to pairs of elements from the input lists.

list1 : 'T1 list

The first input list.

list2 : 'T2 list

The second input list.

Example

 let inputs1 = [ "a"; "b"; "c" ]
 let inputs2 = [ 1; 2; 3 ]

 (inputs1, inputs2) ||> List.iter2 (printfn "%s: %i")

 a: 1
 b: 2
 c: 3

This is an O(n) operation, where n is the length of the list.

action : int -> 'T -> unit

The function to apply to the elements of the list along with their index.

list : 'T list

The input list.

Example

 let inputs = [ "a"; "b"; "c" ]

 inputs |> List.iteri (fun i v -> printfn "{i}: {v}")

 0: a
 1: b
 2: c

This is an O(n) operation, where n is the length of the lists.

action : int -> 'T1 -> 'T2 -> unit

The function to apply to a pair of elements from the input lists along with their index.

list1 : 'T1 list

The first input list.

list2 : 'T2 list

The second input list.

Example

 let inputs1 = [ "a"; "b"; "c" ]
 let inputs2 = [ "banana"; "pear"; "apple" ]

 (inputs1, inputs2) ||> List.iteri2 (fun i s1 s2 -> printfn "Index %d: %s - %s" i s1 s2)

 Index 0: a - banana
 Index 1: b - pear
 Index 2: c - apple

Lists are represented as linked lists so this is an O(n) operation, where n is the length of the list.

list : 'T list

The input list.

Returns: 'T

The last element of the list.

Example

 [ "pear"; "banana" ] |> List.last

Example

 [ ] |> List.last

The notation list.Length is preferred. This is an O(n) operation, where n is the length of the list.This is an O(n) operation, where n is the length of the list.

list : 'T list

The input list.

Returns: int

The length of the list.

Example

 let inputs = [ "a"; "b"; "c" ]

 inputs |> List.length

This is an O(n) operation, where n is the length of the list.

mapping : 'T -> 'U

The function to transform elements from the input list.

list : 'T list

The input list.

Returns: 'U list

The list of transformed elements.

Example

 let inputs = [ "a"; "bbb"; "cc" ]

 inputs |> List.map (fun x -> x.Length)

This is an O(n) operation, where n is the length of the lists.

mapping : 'T1 -> 'T2 -> 'U

The function to transform pairs of elements from the input lists.

list1 : 'T1 list

The first input list.

list2 : 'T2 list

The second input list.

Returns: 'U list

The list of transformed elements.

Example

 let inputs1 = ["a"; "bad"; "good"]
 let inputs2 = [0; 2; 1]

 (inputs1, inputs2) ||> List.map2 (fun x y -> x.[y])

This is an O(n) operation, where n is the length of the lists.

mapping : 'T1 -> 'T2 -> 'T3 -> 'U

The function to transform triples of elements from the input lists.

list1 : 'T1 list

The first input list.

list2 : 'T2 list

The second input list.

list3 : 'T3 list

The third input list.

Returns: 'U list

The list of transformed elements.

Example

 let inputs1 = [ "a"; "t"; "ti" ]
 let inputs2 = [ "l"; "h"; "m" ]
 let inputs3 = [ "l"; "e"; "e" ]

 (inputs1, inputs2, inputs3) |||> List.map3 (fun x y z -> x + y + z)

This is an O(n) operation, where n is the length of the list.

mapping : 'State -> 'T -> 'Result * 'State

The function to transform elements from the input list and accumulate the final value.

state : 'State

The initial state.

list : 'T list

The input list.

Returns: 'Result list * 'State

The list of transformed elements, and the final accumulated value.

Example

Accumulate the charges, and double them as well

 type Charge =
     | In of int
     | Out of int

 let inputs = [ In 1; Out 2; In 3 ]

 let newCharges, balance =
     (0, inputs) ||> List.mapFold (fun acc charge ->
         match charge with
         | In i -> In (i*2), acc + i
         | Out o -> Out (o*2), acc - o)

This is an O(n) operation, where n is the length of the list.

mapping : 'T -> 'State -> 'Result * 'State

The function to transform elements from the input list and accumulate the final value.

list : 'T list

The input list.

state : 'State

The initial state.

Returns: 'Result list * 'State

The list of transformed elements, and the final accumulated value.

Example

Accumulate the charges from back to front, and double them as well

 type Charge =
     | In of int
     | Out of int

 let charges = [ In 1; Out 2; In 3 ]

 let newCharges, balance =
     (charges, 0) ||> List.mapFoldBack (fun charge acc ->
         match charge with
         | In i -> In (i*2), acc + i
         | Out o -> Out (o*2), acc - o)

This is an O(n) operation, where n is the length of the list.

mapping : int -> 'T -> 'U

The function to transform elements and their indices.

list : 'T list

The input list.

Returns: 'U list

The list of transformed elements.

Example

 let inputs = [ 10; 10; 10 ]

 inputs |> List.mapi (fun i x -> i + x)

This is an O(n) operation, where n is the length of the lists.

mapping : int -> 'T1 -> 'T2 -> 'U

The function to transform pairs of elements from the two lists and their index.

list1 : 'T1 list

The first input list.

list2 : 'T2 list

The second input list.

Returns: 'U list

The list of transformed elements.

Example

 let inputs1 = ["a"; "bad"; "good"]
 let inputs2 = [0; 2; 1]

 (inputs1, inputs2) ||> List.mapi2 (fun i x y -> i, x[y])

Raises ArgumentException if list is empty. This is an O(n) operation, where n is the length of the list.

list : 'T list

The input list.

Returns: 'T

The maximum element.

Example

 let inputs = [ 10; 12; 11 ]

 inputs |> List.max

Example

 let inputs = [ ]

 inputs |> List.max

Returns the first maximal element of the list if there are multiple equal maximum elements. Raises ArgumentException if list is empty. This is an O(n) operation, where n is the length of the list.

projection : 'T -> 'U

The function to transform the list elements into the type to be compared.

list : 'T list

The input list.

Returns: 'T

The maximum element.

Example

 let inputs = ["aaa"; "b"; "cccc"]

 inputs |> List.maxBy (fun s -> s.Length)

Example

 let inputs = []

 inputs |> List.maxBy (fun (s: string) -> s.Length)

Raises ArgumentException if list is empty This is an O(n) operation, where n is the length of the list.

list : 'T list

The input list.

Returns: 'T

The minimum value.

Example

 let inputs = [10; 12; 11]

 inputs |> List.min

Example

 let inputs = []

 inputs |> List.min