String (FSharp.Core)

Builds a new string whose characters are the results of applying the function mapping to each of the characters of the input string and concatenating the resulting strings.

mapping : char -> string: The function to produce a string from each character of the input string.
str : string: The input string.

Returns: string: The concatenated string.

The following samples shows how to interspace spaces in a text

 let input = "Stefan says: Hi!"

 input |> String.collect (sprintf "%c ")

val input: string

module String from Microsoft.FSharp.Core

val collect: mapping: (char -> string) -> str: string -> string

val sprintf: format: Printf.StringFormat<'T> -> 'T

The sample evaluates to "S t e f a n s a y s : H i ! "

How to show the ASCII representation of a very secret text

 "Secret" |> String.collect (fun chr -> int chr |> sprintf "%d ")

module String from Microsoft.FSharp.Core

val collect: mapping: (char -> string) -> str: string -> string

val chr: char

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

val sprintf: format: Printf.StringFormat<'T> -> 'T

The sample evaluates to "83 101 99 114 101 116 "

Returns a new string made by concatenating the given strings with separator sep, that is a1 + sep + ... + sep + aN.

sep : string: The separator string to be inserted between the strings of the input sequence.
strings : string seq: The sequence of strings to be concatenated.

Returns: string: A new string consisting of the concatenated strings separated by the separation string.

 let input1 = ["Stefan"; "says:"; "Hello"; "there!"]

 input1 |> String.concat " "  // evaluates "Stefan says: Hello there!"

 let input2 = [0..9] |> List.map string

 input2 |> String.concat ""    // evaluates "0123456789"
 input2 |> String.concat ", "  // evaluates "0, 1, 2, 3, 4, 5, 6, 7, 8, 9"

 let input3 = ["No comma"]

 input3 |> String.concat ","   // evaluates "No comma"

val input1: string list

module String from Microsoft.FSharp.Core

val concat: sep: string -> strings: string seq -> string

val input2: string list

Multiple items
module List from Microsoft.FSharp.Collections

--------------------
type List<'T> = | op_Nil | op_ColonColon of Head: 'T * Tail: 'T list interface IReadOnlyList<'T> interface IReadOnlyCollection<'T> interface IEnumerable interface IEnumerable<'T> member GetReverseIndex: rank: int * offset: int -> int member GetSlice: startIndex: int option * endIndex: int option -> 'T list static member Cons: head: 'T * tail: 'T list -> 'T list member Head: 'T member IsEmpty: bool member Item: index: int -> 'T with get ...

val map: mapping: ('T -> 'U) -> list: 'T list -> 'U list

Multiple items
val string: value: 'T -> string

--------------------
type string = System.String

val input3: string list

Tests if any character of the string satisfies the given predicate.

predicate : char -> bool: The function to test each character of the string.
str : string: The input string.

Returns: bool: True if any character returns true for the predicate and false otherwise.

Looking for uppercase characters

 open System

 "Yoda" |> String.exists Char.IsUpper  // evaluates true

 "nope" |> String.exists Char.IsUpper  // evaluates false

namespace System

Multiple items
type String = interface IEnumerable<char> interface IEnumerable interface ICloneable interface IComparable interface IComparable<string> interface IConvertible interface IEquatable<string> interface IParsable<string> interface ISpanParsable<string> new: value: nativeptr<char> -> unit + 8 overloads ...
<summary>Represents text as a sequence of UTF-16 code units.</summary>

--------------------
String(value: nativeptr<char>) : String
String(value: char array) : String
String(value: ReadOnlySpan<char>) : String
String(value: nativeptr<sbyte>) : String
String(c: char, count: int) : String
String(value: nativeptr<char>, startIndex: int, length: int) : String
String(value: char array, startIndex: int, length: int) : String
String(value: nativeptr<sbyte>, startIndex: int, length: int) : String
String(value: nativeptr<sbyte>, startIndex: int, length: int, enc: Text.Encoding) : String

val exists: predicate: (char -> bool) -> str: string -> bool

[<Struct>] type Char = member CompareTo: value: char -> int + 1 overload member Equals: obj: char -> bool + 1 overload member GetHashCode: unit -> int member GetTypeCode: unit -> TypeCode member ToString: unit -> string + 2 overloads static member ConvertFromUtf32: utf32: int -> string static member ConvertToUtf32: highSurrogate: char * lowSurrogate: char -> int + 1 overload static member GetNumericValue: c: char -> float + 1 overload static member GetUnicodeCategory: c: char -> UnicodeCategory + 1 overload static member IsAscii: c: char -> bool ...
<summary>Represents a character as a UTF-16 code unit.</summary>

Char.IsUpper(c: char) : bool
Char.IsUpper(s: string, index: int) : bool

Builds a new string containing only the characters of the input string for which the given predicate returns "true".

predicate : char -> bool: A function to test whether each character in the input sequence should be included in the output string.
str : string: The input string.

Returns: string: The resulting string.

Filtering out just alphanumeric characters

 open System

 let input = "0 1 2 3 4 5 6 7 8 9 a A m M"

 input |> String.filter Uri.IsHexDigit  // evaluates "123456789aA"

namespace System

val input: string

val filter: predicate: (char -> bool) -> str: string -> string

Multiple items
type Uri = interface IEquatable<Uri> interface IFormattable interface ISpanFormattable interface ISerializable new: uriString: string -> unit + 6 overloads member Equals: comparand: obj -> bool + 1 overload member GetComponents: components: UriComponents * format: UriFormat -> string member GetHashCode: unit -> int member GetLeftPart: part: UriPartial -> string member IsBaseOf: uri: Uri -> bool ...
<summary>Provides an object representation of a uniform resource identifier (URI) and easy access to the parts of the URI.</summary>

--------------------
Uri(uriString: string) : Uri
Uri(uriString: string, creationOptions: inref<UriCreationOptions>) : Uri
Uri(uriString: string, uriKind: UriKind) : Uri
Uri(baseUri: Uri, relativeUri: string) : Uri
Uri(baseUri: Uri, relativeUri: Uri) : Uri

Uri.IsHexDigit(character: char) : bool

Filtering out just digits

 open System

 "hello" |> String.filter Char.IsDigit  // evaluates ""

namespace System

val filter: predicate: (char -> bool) -> str: string -> string

Char.IsDigit(c: char) : bool
Char.IsDigit(s: string, index: int) : bool

Tests if all characters in the string satisfy the given predicate.

predicate : char -> bool: The function to test each character of the string.
str : string: The input string.

Returns: bool: True if all characters return true for the predicate and false otherwise.

Looking for lowercase characters

 open System

 "all are lower" |> String.forall Char.IsLower  // evaluates false

 "allarelower" |> String.forall Char.IsLower    // evaluates true

namespace System

val forall: predicate: (char -> bool) -> str: string -> bool

Char.IsLower(c: char) : bool
Char.IsLower(s: string, index: int) : bool

Builds a new string whose characters are the results of applying the function initializer to each index from 0 to count-1 and concatenating the resulting strings.

count : int: The number of strings to initialize.
initializer : int -> string: The function to take an index and produce a string to be concatenated with the others.

Returns: string: The constructed string.

Enumerate digits ASCII codes

 String.init 10 (fun i -> int '0' + i |> sprintf "%d ")

module String from Microsoft.FSharp.Core

val init: count: int -> initializer: (int -> string) -> string

val i: int

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

val sprintf: format: Printf.StringFormat<'T> -> 'T

The sample evaluates to: "48 49 50 51 52 53 54 55 56 57 "

Applies the function action to each character in the string.

action : char -> unit: The function to be applied to each character of the string.
str : string: The input string.

Printing the ASCII code for each character in the string

 let input = "Hello"
 input |> String.iter (fun c -> printfn "%c %d" c (int c))

val input: string

module String from Microsoft.FSharp.Core

val iter: action: (char -> unit) -> str: string -> unit

val c: char

val printfn: format: Printf.TextWriterFormat<'T> -> 'T

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

The sample evaluates as unit, but prints:

Applies the function action to the index of each character in the string and the character itself.

action : int -> char -> unit: The function to apply to each character and index of the string.
str : string: The input string.

Numbering the characters and printing the associated ASCII code for each character in the input string

 let input = "Hello"
 input |> String.iteri (fun i c -> printfn "%d. %c %d" (i + 1) c (int c))

val input: string

module String from Microsoft.FSharp.Core

val iteri: action: (int -> char -> unit) -> str: string -> unit

val i: int

val c: char

val printfn: format: Printf.TextWriterFormat<'T> -> 'T

Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int

The sample evaluates as unit, but prints:

 1. H 72
 2. e 101
 3. l 108
 4. l 108
 5. o 111

Returns the length of the string.

str : string: The input string.

Returns: int: The number of characters in the string.

Getting the length of different strings

 String.length null   // evaluates 0
 String.length ""     // evaluates 0
 String.length "123"  // evaluates 3

module String from Microsoft.FSharp.Core

val length: str: string -> int

Builds a new string whose characters are the results of applying the function mapping to each of the characters of the input string.

mapping : char -> char: The function to apply to the characters of the string.
str : string: The input string.

Returns: string: The resulting string.

Changing case to upper for all characters in the input string

 open System

 let input = "Hello there!"

 input |> String.map Char.ToUpper  // evaluates "HELLO THERE!"

namespace System

val input: string

val map: mapping: (char -> char) -> str: string -> string

Char.ToUpper(c: char) : char
Char.ToUpper(c: char, culture: Globalization.CultureInfo) : char

Builds a new string whose characters are the results of applying the function mapping to each character and index of the input string.

mapping : int -> char -> char: The function to apply to each character and index of the string.
str : string: The input string.

Returns: string: The resulting string.

 input |> String.mapi (fun i c -> (i, c))

module String from Microsoft.FSharp.Core

val mapi: mapping: (int -> char -> char) -> str: string -> string

val i: int

val c: char

Evaluates to [ (0, 'O'); (1, 'K'); (2, '!') ].

Returns a string by concatenating count instances of str.

count : int: The number of copies of the input string will be copied.
str : string: The input string.

Returns: string: The concatenated string.

 "Do it!" |> String.replicate 3

module String from Microsoft.FSharp.Core

val replicate: count: int -> str: string -> string

Evaluates to "Do it!Do it!Do it!".