String

(Fn [(Ref String a), (Ref String b)] Bool)

(Fn [(Ref String a), (Ref String b)] Bool)

(Fn [(Ref String a), (Ref String b)] Bool)

(Fn [Int, Char] String)

(Fn [(Ref String a)] Bool)

                        (allocated? s)
                    

checks if a String returned by String.allocate is not NULL. This is a safeguard against out-of-memory conditions.

(Fn [(Ref String a)] Bool)

                        (alpha? s)
                    

checks whether a string contains only alphabetical characters (a-Z).

(Fn [(Ref String a)] Bool)

                        (alphanum? s)
                    

checks whether a string is alphanumerical.

(Fn [(Ref String a), (Ref String b)] String)

(Fn [(Ref String a)] String)

                        (ascii-to-lower s)
                    

converts each character in this string to lower case using tolower() from standard C library. Note: this will only work for ASCII characters.

(Fn [(Ref String a)] String)

                        (ascii-to-upper s)
                    

converts each character in this string to upper case using toupper() from standard C library. Note: this will only work for ASCII characters.

(Fn [(Ref String a), Int] Char)

(Fn [(Ref String a)] (Array Char))

(Fn [(Ref String a)] String)

                        (chomp s)
                    

trims a newline from the end of a string.

(Fn [(Ref String a)] String)

                        (collapse-whitespace s)
                    

collapses groups of whitespace into single spaces.

(Fn [(Ref (Array String) a)] String)

                        (concat strings)
                    

Returns a new string which is the concatenation of the provided strings.

(Fn [(Ref String a), Char] Bool)

                        (contains? s c)
                    

Checks whether the string s contains the character c.

(Fn [(Ref String a)] String)

(Fn [(Ref String a), Char] Int)

                        (count-char s c)
                    

Returns the number of occurrences of c in the string s.

(Fn [(Ref String a)] (Ptr CChar))

(Fn [String] ())

(Fn [(Ref String a)] Bool)

                        (empty? s)
                    

Check if the string is the empty string.

(Fn [(Ref String a), (Ref String b)] Bool)

                        (ends-with? s sub)
                    

Check if the string s ends with the string sub.

(Fn [(Ref String a), (Ref String b)] String)

(Fn [(Ref (Array Byte) a)] String)

(Fn [(Ref (Array Char) a)] String)

(Fn [(Ptr CChar)] String)

(Fn [(Ref String a)] Int)

                        (hash k)
                    

(Fn [(Ref String a)] Char)

                        (head s)
                    

Returns the character at start of string.

(Fn [(Ref String a)] Bool)

                        (hex? s)
                    

checks whether a string is hexadecimal.

(Fn [(Ref String a), (Ref String b)] Bool)

                        (in? s sub)
                    

checks whether a string contains another string.

(Fn [(Ref String a), Char] Int)

(Fn [(Ref String a), Char, Int] Int)

(Fn [(Ref String a), (Ref (Array String) b)] String)

                        (join sep strings)
                    

Returns a new string which is the concatenation of the provided strings separated by string sep.

(Fn [Char, (Ref (Array String) a)] String)

                        (join-with-char sep strings)
                    

Returns a new string which is the concatenation of the provided strings separated by char sep.

(Fn [(Ref String a)] Int)

(Fn [(Ref String a)] (Array String))

                        (lines s)
                    

splits a string into lines.

(Fn [(Ref String a)] Bool)

                        (lower? s)
                    

checks whether a string is all lowercase.

(Fn [(Ref String a)] Bool)

                        (num? s)
                    

checks whether a string is numerical.

(Fn [Int, Char, (Ref String a)] String)

                        (pad-left len pad s)
                    

Pads the left of a string with len bytes using the padding pad.

(Fn [Int, Char, (Ref String a)] String)

                        (pad-right len pad s)
                    

Pads the right of a string with len bytes using the padding pad.

(Fn [(Ref String a), Int] String)

                        (prefix s a)
                    

Return the first a characters of the string s.

(Fn [(Ref String a)] String)

(Fn [Int] String)

                        (random-sized n)
                    

(Fn [Int, (Ref String a)] String)

                        (repeat n inpt)
                    

Returns a new string which is inpt repeated n times.

(Fn [(Ref String a)] String)

                        (reverse s)
                    

Produce a new string which is s reversed.

(Fn [(Ref String a), Int, Int] String)

                        (slice s a b)
                    

Return part of a string, beginning at index a and ending at index b.

(Fn [(Ref String a), (Ref (Array Char) b)] (Array String))

                        (split-by s separators)
                    

splits a string by separators.

(Fn [(Ref String a), (Ref String b)] Bool)

                        (starts-with? s sub)
                    

Check if the string s begins with the string sub.

(Fn [(Ref String a)] String)

(Fn [(Ref String a), Int, Char] ())

(Fn [(Ref String a), Int, (Ref String b)] ())

(Fn [(Ref String a), Int] String)

                        (suffix s b)
                    

Returns the suffix string starting at the bth character.

(Fn [(Ref (Array String) a)] Int)

                        (sum-length strings)
                    

Returns the sum of lengths from an array of Strings.

(Fn [(Ref String a)] String)

(Fn [(Ref String a)] (Array Byte))

(Fn [(Ref String a)] String)

                        (trim s)
                    

trims whitespace from both sides of a string.

(Fn [(Ref String a)] String)

                        (trim-left s)
                    

trims whitespace from the left of a string.

(Fn [(Ref String a)] String)

                        (trim-right s)
                    

trims whitespace from the right of a string.

(Fn [(Ref String a)] Bool)

                        (upper? s)
                    

checks whether a string is all uppercase.

(Fn [(Ref String a)] (Array String))

                        (words s)
                    

splits a string into words.

(Fn [] String)

                        (zero)
                    

The empty string.