Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://docs.racket-lang.org/reference/strings.html below:

4.4 Strings

Strings (Unicode) in The Racket Guide introduces strings.

A string is a fixed-length array of characters.

A string can be mutable or immutable. When an immutable string is provided to a procedure like string-set!, the exn:fail:contract exception is raised. String constants generated by the default reader (see Reading Strings) are immutable, and they are interned in read-syntax mode. Use immutable? to check whether a string is immutable.

Two strings are equal? when they have the same length and contain the same sequence of characters.

A string can be used as a single-valued sequence (see Sequences). The characters of the string serve as elements of the sequence. See also in-string.

See Reading Strings for information on reading strings and Printing Strings for information on printing strings.

See also: immutable?, symbol->string, bytes->string/utf-8.

Returns #t if v is a string, #f otherwise.

See also immutable-string? and mutable-string?.

Examples:

Returns a new mutable string of length k where each position in the string is initialized with the character char.

Example:

Returns a new mutable string whose length is the number of provided chars, and whose positions are initialized with the given chars.

Example:

> (string #\A #\p #\p #\l #\e)

"Apple"

Returns an immutable string with the same content as str, returning str itself if str is immutable.

Examples:

Returns the length of str.

Example:

Returns the character at position

in

. The first position in the string corresponds to

, so the position

must be less than the length of the string, otherwise the

exception is raised.

Example:

Changes the character position

in

to

. The first position in the string corresponds to

, so the position

must be less than the length of the string, otherwise the

exception is raised.

Examples:

Returns a new mutable string that is

characters long, and that contains the same characters as

from

inclusive to

exclusive. The first position in a string corresponds to

, so the

and

arguments must be less than or equal to the length of

, and

must be greater than or equal to

, otherwise the

exception is raised.

Examples:

Changes the characters of

starting at position

to match the characters in

from

(inclusive) to

(exclusive), where the first position in a string corresponds to

. The strings

and

can be the same string, and in that case the destination region can overlap with the source region; the destination characters after the copy match the source characters from before the copy. If any of

,

, or

are out of range (taking into account the sizes of the strings and the source and destination regions), the

exception is raised.

Examples:

Changes dest so that every position in the string is filled with char.

Examples:

Returns a new mutable string that is as long as the sum of the given

s’ lengths, and that contains the concatenated characters of the given

s. If no

s are provided, the result is a zero-length string.

Example:

The same as

, but the result is an immutable string.

Examples:

Added in version 7.5.0.14 of package base.

Returns a new list of characters corresponding to the content of

. That is, the length of the list is

, and the sequence of characters in

is the same sequence in the result list.

Example:

Returns a new mutable string whose content is the list of characters in

. That is, the length of the string is

, and the sequence of characters in

is the same sequence in the result string.

Example:

Creates a string of

characters by applying

to the integers from

to

in order. If

is the resulting string, then

is the character produced by

.

Example:

Returns

if all of the arguments are

.

Examples:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Returns

if the arguments are lexicographically sorted increasing, where individual characters are ordered by

,

otherwise.

Examples:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Like

, but checks whether the arguments are nondecreasing.

Examples:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Like

, but checks whether the arguments are decreasing.

Examples:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Like

, but checks whether the arguments are nonincreasing.

Examples:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Returns

if all of the arguments are

after locale-insensitive case-folding via

.

Examples:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Like

, but checks whether the arguments would be in increasing order if each was first case-folded using

(which is locale-insensitive).

Examples:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Like

, but checks whether the arguments would be nondecreasing after case-folding.

Examples:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Like

, but checks whether the arguments would be decreasing after case-folding.

Examples:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Like

, but checks whether the arguments would be nonincreasing after case-folding.

Examples:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Returns a string whose characters are the upcase conversion of the characters in

. The conversion uses Unicode’s locale-independent conversion rules that map code-point sequences to code-point sequences (instead of simply mapping a 1-to-1 function on code points over the string), so the string produced by the conversion can be longer than the input string.

Examples:

Examples:

Like

, but the titlecase conversion only for the first character in each sequence of cased characters in

(ignoring case-ignorable characters).

Examples:

Examples:

Returns a string that is the Unicode normalized form D of string. If the given string is already in the corresponding Unicode normal form, the string may be returned directly as the result (instead of a newly allocated string).

Example:

Example:

Example:

Example:

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Like

, but the sort order compares strings in a locale-specific way, based on the value of

. In particular, the sort order may not be simply a lexicographic extension of character ordering.

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Like

, but strings are compared using rules that are both locale-specific and case-insensitive (depending on what “case-insensitive” means for the current locale).

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Changed in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.

Returns the number of characters (i.e., code points) in the string that form a Unicode grapheme cluster starting at start, assuming that start is the start of a grapheme cluster and extending no further than the character before end. The result is 0 if start equals end.

The start and end arguments must be valid indices as for substring, otherwise the exn:fail:contract exception is raised.

See also char-grapheme-cluster-step.

Examples:

Added in version 8.6.0.2 of package base.

Returns the number of grapheme clusters in

.

The start and end arguments must be valid indices as for substring, otherwise the exn:fail:contract exception is raised.

Examples:

Added in version 8.6.0.2 of package base.

Examples:

Appends the strings in

, inserting

between each pair of strings in

.

,

, and

are analogous to the inputs of

: they specify an alternate separator between the last two strings, a prefix string, and a suffix string respectively.

Examples:

> (string-join '("one" "two" "three" "four"))

"one two three four"

> (string-join '("one" "two" "three" "four") ", ")

"one, two, three, four"

> (string-join '("one" "two" "three" "four") " potato ")

"one potato two potato three potato four"

> (string-join '("x" "y" "z") ", "                #:before-first "Todo: "                #:before-last " and "                #:after-last ".")

"Todo: x, y and z."

Normalizes spaces in the input

by trimming it (using

and

) and replacing all whitespace sequences in the result with

, which defaults to a single space.

Example:

The result of (string-normalize-spaces str sep space) is the same as (string-join (string-split str sep ....) space).

Returns

with all occurrences of

replaced with by

. If

is a string, it is matched literally (as opposed to being used as a

).

By default, all occurrences are replaced, but only the first match is replaced if all? is #f.

Example:

Splits the input

on

, returning a list of substrings of

that are separated by

, defaulting to splitting the input on whitespaces. The input is first trimmed using

(see

), unless

is

. Empty matches are handled in the same way as for

. As a special case, if

is the empty string after trimming, the result is

instead of

.

Like string-trim, provide sep to use a different separator, and repeat? controls matching repeated sequences.

Examples:

Trims the input

by removing prefix and suffix

, which defaults to whitespace. A string

is matched literally (as opposed to being used as a

).

Use #:left? #f or #:right? #f to suppress trimming the corresponding side. When repeat? is #f (the default), only one match is removed from each side; when repeat? is true, all initial or trailing matches are trimmed (which is an alternative to using a regular expression sep that contains +).

Examples:

> (string-trim "  foo bar  baz \r\n\t")

"foo bar  baz"

> (string-trim "  foo bar  baz \r\n\t" " " #:repeat? #t)

"foo bar  baz \r\n\t"

> (string-trim "aaaxaayaa" "aa")

"axaay"

Returns #t if x is a string and is not empty; returns #f otherwise.

Added in version 6.3 of package base.

Checks whether

includes at any location, starts with, or ends with the second argument, respectively. The

function returns the first position within

where

is found, if any, while

reports only whether it was found.

Examples:

Added in version 6.3 of package base.
Changed in version 8.15.0.7: Added string-find.

The racket/format library provides functions for converting Racket values to strings. In addition to features like padding and numeric formatting, the functions have the virtue of being shorter than format (with format string), number->string, or string-append.

Converts each

to a string in

mode—

that is, like

—

then concatenates the results with

between consecutive items, and then pads or truncates the string to be at least

characters and at most

characters.

Examples:

> (~a "north")

"north"

> (~a 'south)

"south"

> (~a #"east")

"east"

> (~a #\w "e" 'st)

"west"

> (~a (list "red" 'green #"blue"))

"(red green blue)"

> (~a 17)

"17"

> (~a #e1e20)

"100000000000000000000"

> (~a pi)

"3.141592653589793"

> (~a (expt 6.1 87))

"2.1071509386211452e+68"

The ~a function is primarily useful for strings, numbers, and other atomic data. The ~v and ~s functions are better suited to compound data.

Let s be the concatenated string forms of the vs plus separators. If s is longer than max-width characters, it is truncated to exactly max-width characters. If s is shorter than min-width characters, it is padded to exactly min-width characters. Otherwise s is returned unchanged. If min-width is greater than max-width, an exception is raised.

If s is longer than max-width characters, it is truncated and the end of the string is replaced with limit-marker. If limit-marker is longer than max-width, an exception is raised. If limit-prefix? is #t, the beginning of the string is truncated instead of the end.

Examples:

> (~a "abcde" #:max-width 5)

"abcde"

> (~a "abcde" #:max-width 4)

"abcd"

> (~a "abcde" #:max-width 4 #:limit-marker "*")

"abc*"

> (~a "abcde" #:max-width 4 #:limit-marker "...")

"a..."

> (~a "The quick brown fox" #:max-width 15 #:limit-marker "")

"The quick brown"

> (~a "The quick brown fox" #:max-width 15 #:limit-marker "...")

"The quick br..."

> (~a "The quick brown fox" #:max-width 15 #:limit-marker "..." #:limit-prefix? #f)

"The quick br..."

If s is shorter than min-width, it is padded to at least min-width characters. If align is 'left, then only right padding is added; if align is 'right, then only left padding is added; and if align is 'center, then roughly equal amounts of left padding and right padding are added.

Padding is specified as a non-empty string. Left padding consists of left-pad-string repeated in its entirety as many times as possible followed by a prefix of left-pad-string to fill the remaining space. In contrast, right padding consists of a suffix of right-pad-string followed by a number of copies of right-pad-string in its entirety. Thus left padding starts with the start of left-pad-string and right padding ends with the end of right-pad-string.

Examples:

> (~a "apple" #:min-width 20 #:align 'left)

"apple               "

> (~a "pear" #:min-width 20 #:align 'left #:right-pad-string " .")

"pear . . . . . . . ."

> (~a "plum" #:min-width 20 #:align 'right #:left-pad-string ". ")

". . . . . . . . plum"

> (~a "orange" #:min-width 20 #:align 'center                 #:left-pad-string "- " #:right-pad-string " -")

"- - - -orange- - - -"

Use width to set both max-width and min-width simultaneously, ensuring that the resulting string is exactly width characters long:

> (~a "terse" #:width 6)

"terse "

> (~a "loquacious" #:width 6)

"loquac"

Like

, but each value is converted like

, the default separator is

, and the default limit marker is

.

Examples:

> (~v "north")

"\"north\""

> (~v 'south)

"'south"

> (~v #"east")

"#\"east\""

> (~v #\w)

"#\\w"

> (~v (list "red" 'green #"blue"))

"'(\"red\" green #\"blue\")"

Use ~v to produce text that talks about Racket values.

Example:

"The even numbers in '(0 1 2 3 4 5 6 7 8 9) are '(0 2 4 6 8)."

Like

, but each value is converted like

, the default separator is

, and the default limit marker is

.

Examples:

> (~s "north")

"\"north\""

> (~s 'south)

"south"

> (~s #"east")

"#\"east\""

> (~s #\w)

"#\\w"

> (~s (list "red" 'green #"blue"))

"(\"red\" green #\"blue\")"

Like

, but each value is converted like

, the default separator is

, and the default limit marker is

.

Examples:

> (~e "north")

"\"north\""

> (~e 'south)

"'south"

> (~e #"east")

"#\"east\""

> (~e #\w)

"#\\w"

> (~e (list "red" 'green #"blue"))

"'(\"red\" green #\"blue\")"

Converts the rational number x to a string in either positional or exponential notation, depending on notation. The exactness or inexactness of x does not affect its formatting.

The optional arguments control number formatting:

• notation — determines whether the number is printed in positional or exponential notation. If notation is a function, it is applied to x to get the notation to be used.

  Examples:

  > (~r 12345)

  "12345"

  > (~r 12345 #:notation 'exponential)

  "1.2345e+04"

  '("17" "289" "4.913e+03" "8.3521e+04")

• precision — controls the number of digits after the decimal point (or more accurately, the radix point). When x is formatted in exponential form, precision applies to the significand.

  If precision is a natural number, then up to precision digits are displayed, but trailing zeroes are dropped, and if all digits after the decimal point are dropped the decimal point is also dropped. If precision is (list '= digits), then exactly digits digits after the decimal point are used, and the decimal point is never dropped.

  Examples:

  > (~r pi)

  "3.141593"

  > (~r pi #:precision 4)

  "3.1416"

  > (~r pi #:precision 0)

  "3"

  > (~r 1.5 #:precision 4)

  "1.5"

  > (~r 1.5 #:precision '(= 4))

  "1.5000"

  > (~r 50 #:precision 2)

  "50"

  > (~r 50 #:precision '(= 2))

  "50.00"

  > (~r 50 #:precision '(= 0))

  "50."

• decimal-sep specifies what decimal separator is printed.

  Examples:

  > (~r 123.456)

  "123.456"

  > (~r 123.456 #:decimal-sep ",")

  "123,456"

• groups controls how digits of the integral part of the number are separated into groups. Rightmost numbers of groups are used to group rightmost digits of the integral part. The leftmost number of groups is used repeatedly to group leftmost digits. The group-sep argument specifies which separator to use between digit groups.

  Examples:

  > (~r 1234567890 #:groups '(3) #:group-sep ",")

  "1,234,567,890"

  > (~r 1234567890 #:groups '(3 2) #:group-sep ",")

  "12,345,678,90"

  > (~r 1234567890 #:groups '(1 3 2) #:group-sep "_")

  "1_2_3_4_5_678_90"

• min-width — if x would normally be printed with fewer than min-width digits (including the decimal point but not including the sign indicator), the digits are left-padded using pad-string.

  Examples:

  > (~r 17)

  "17"

  > (~r 17 #:min-width 4)

  "  17"

  > (~r -42 #:min-width 4)

  "-  42"

  > (~r 1.5 #:min-width 4)

  " 1.5"

  > (~r 1.5 #:precision 4 #:min-width 10)

  "       1.5"

  > (~r 1.5 #:precision '(= 4) #:min-width 10)

  "    1.5000"

  > (~r #e1e10 #:min-width 6)

  "10000000000"

• pad-string — specifies the string used to pad the number to at least min-width characters (not including the sign indicator). The padding is placed between the sign and the normal digits of x.

  Examples:

  > (~r 17 #:min-width 4 #:pad-string "0")

  "0017"

  > (~r -42 #:min-width 4 #:pad-string "0")

  "-0042"

• sign — controls how the sign of the number is indicated:

  • If sign is #f (the default), no sign output is generated if x is either positive or zero, and a minus sign is prefixed if x is negative.

    Example:

    > (for/list ([x '(17 0 -42)]) (~r x))

    '("17" "0" "-42")

  • If sign is '+, no sign output is generated if x is zero, a plus sign is prefixed if x is positive, and a minus sign is prefixed if x is negative.

    Example:

    > (for/list ([x '(17 0 -42)]) (~r x #:sign '+))

    '("+17" "0" "-42")

  • If sign is '++, a plus sign is prefixed if x is zero or positive, and a minus sign is prefixed if x is negative.

    Example:

    > (for/list ([x '(17 0 -42)]) (~r x #:sign '++))

    '("+17" "+0" "-42")

  • If sign is 'parens, no sign output is generated if x is zero or positive, and the number is enclosed in parentheses if x is negative.

    Example:

    > (for/list ([x '(17 0 -42)]) (~r x #:sign 'parens))

    '("17" "0" "(42)")

  • If sign is (list pos-ind zero-ind neg-ind), then pos-ind, zero-ind, and neg-ind are used to indicate positive, zero, and negative numbers, respectively. Each indicator is either a string to be used as a prefix or a list containing two strings: a prefix and a suffix.

    Example:

    > (let ([sign-table '(("" " up") "an even " ("" " down"))])     (for/list ([x '(17 0 -42)]) (~r x #:sign sign-table)))

    '("17 up" "an even 0" "42 down")

    The default behavior is equivalent to '("" "" "-"); the 'parens mode is equivalent to '("" "" ("(" ")")).

• base — controls the base that x is formatted in. If base is a number greater than 10, then lower-case letters are used. If base is (list 'up base*) and base* is greater than 10, then upper-case letters are used.

  Examples:

  > (~r 100 #:base 7)

  "202"

  > (~r 4.5 #:base 2)

  "100.1"

  > (~r 3735928559 #:base 16)

  "deadbeef"

  > (~r 3735928559 #:base '(up 16))

  "DEADBEEF"

  > (~r 3735928559 #:base '(up 16) #:notation 'exponential)

  "D.EADBEF*16^+07"

• format-exponent — determines how the exponent is displayed.

  If format-exponent is a string, the exponent is displayed with an explicit sign (as with a sign of '++) and at least two digits, separated from the significand by the “exponent marker” format-exponent:

  > (~r 1234 #:notation 'exponential #:format-exponent "E")

  "1.234E+03"

  If format-exponent is #f, the “exponent marker” is "e" if base is 10 and a string involving base otherwise:

  > (~r 1234 #:notation 'exponential)

  "1.234e+03"

  > (~r 1234 #:notation 'exponential #:base 8)

  "2.322*8^+03"

  If format-exponent is a procedure, it is applied to the exponent and the resulting string is appended to the significand:

  > (~r 1234 #:notation 'exponential            #:format-exponent (lambda (e) (format "E~a" e)))

  "1.234E3"

Changed in version 8.5.0.5 of package base: Added #:groups, #:group-sep and #:decimal-sep.

Like

,

, and

, but each

is formatted like

,

, and

, respectively.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4