Thank you for your comment

Beau­tiful Racket / explainers

Stringlike types

Racket’s string­like types include strings, symbols, iden­ti­fiers, keywords, and path strings. They are “string­like” in the sense that they all consist of a sequence of Unicode char­ac­ters, and can easily be converted among one another.

Strings

A stan­dard string is enclosed in "double quotes". A literal double-quote char­acter can be escaped as \".

"one string"
"two \"strings\""
1
2
"one string"
"two \"strings\""
copy to clipboard

By default, strings will print as literal expres­sions (meaning, their printed form can be reused as input). To print strings in the usual friendly way, use display or displayln. To print strings in the raw style used on the REPL, use print or println:

"one literal string"
"two literal \"strings\""
(display "one displayed string\n")
(displayln "two displayed \"strings\"")
(print "one printed string\n")
(println "two printed \"strings\"")
1
2
3
4
5
6
"one literal string"
"two literal \"strings\""
(display "one displayed string\n")
(displayln "two displayed \"strings\"")
(print "one printed string\n")
(println "two printed \"strings\"")
copy to clipboard
"one literal string"
"two literal \"strings\""
one displayed string
two displayed "strings"
"one printed string\n""two printed \"strings\""
1
2
3
4
5
"one literal string"
"two literal \"strings\""
one displayed string
two displayed "strings"
"one printed string\n""two printed \"strings\""
copy to clipboard

Strings can also include the usual escape char­ac­ters to repre­sent ASCII white­space, like \t for tab and \n for line­feed, as well as special classes of escape char­ac­ters like \x for hex numbers and \u for Unicode char­ac­ters. (See the Racket docs for the full list.)

Racket also has the usual string-manip­u­la­tion func­tions—string-split, string-join, string-append, format, etc.—that do what you’d expect.

Further

Here strings & @-expres­sions

To make multi­line strings inside a program, two options.

You can use a here string, which is intro­duced by #<< and a delim­iter name, followed by the string starting on the next line, ending with the delim­iter on its own line:

(define str #<<here-string-delimiter
A wonderful
multiline string
that goes on
seemingly
forever.
here-string-delimiter
) ; contrary to usual Racket style,
  ; the closing paren of a here string must go on a new line

(display str)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
(define str #<<here-string-delimiter
A wonderful
multiline string
that goes on
seemingly
forever.
here-string-delimiter
) ; contrary to usual Racket style,
  ; the closing paren of a here string must go on a new line

(display str)
copy to clipboard
A wonderful
multiline string
that goes on
seemingly
forever.
1
2
3
4
5
A wonderful
multiline string
that goes on
seemingly
forever.
copy to clipboard

You can also use an @-expres­sion, which is a special textual kind of S-expres­sion, by adding the at-exp meta­lan­guage to the #lang line:

#lang at-exp br ; note `at-exp` here

(define str @string-append{
A wonderful
multiline string
that goes on
seemingly
forever.})

(display str) ; same result as above
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
#lang at-exp br ; note `at-exp` here

(define str @string-append{
A wonderful
multiline string
that goes on
seemingly
forever.})

(display str) ; same result as above
copy to clipboard

A nice advan­tage of @-expres­sions over here strings is that they can include normally eval­u­ated subex­pres­sions, the results of which are spliced into the string. These subex­pres­sions are prefixed with another @:

#lang at-exp br

(define base 2)
(define pow 8)

(define str @string-append{
A wonderful
multiline string
that goes on
@(number->string (expt base pow)) years.})

(display str)
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
#lang at-exp br

(define base 2)
(define pow 8)

(define str @string-append{
A wonderful
multiline string
that goes on
@(number->string (expt base pow)) years.})

(display str)
copy to clipboard
A wonderful
multiline string
that goes on
256 years.
1
2
3
4
A wonderful
multiline string
that goes on
256 years.
copy to clipboard

Further

Symbols

A symbol is like a string, but written with a single ' prefix rather than surrounding double quotes. A symbol cannot contain spaces unless the whole symbol is surrounded with | vertical bars |:

"string"
'symbol
"two-word string"
'|two-word symbol|
1
2
3
4
"string"
'symbol
"two-word string"
'|two-word symbol|
copy to clipboard

Symbols have one special prop­erty that strings do not: they are interned, meaning Racket guar­an­tees that all instances of a partic­ular symbol refer to only one object in memory. There­fore, it’s a good habit to use symbols when you need high-speed equality checking, because symbols can be compared with eq?, which is much faster than the equal? required by strings:

(equal? "string" "string") ; slower
(equal? 'symbol 'symbol) ; slower
(eq? 'symbol 'symbol) ; wicked fast
1
2
3
(equal? "string" "string") ; slower
(equal? 'symbol 'symbol) ; slower
(eq? 'symbol 'symbol) ; wicked fast
copy to clipboard

string->symbol and symbol->string are avail­able for explicit conver­sions.

Further

Iden­ti­fiers

An iden­ti­fier is a name that appears in a program. For its behavior, see iden­ti­fiers. Within a datum, an iden­ti­fier is repre­sented with a symbol:

(define foo "see")
(define bar "saw")
(string-append foo bar) ; "seesaw"
'(string-append foo bar) ; '(string-append foo bar)
(andmap symbol? '(string-append foo bar)) ; #t
1
2
3
4
5
(define foo "see")
(define bar "saw")
(string-append foo bar) ; "seesaw"
'(string-append foo bar) ; '(string-append foo bar)
(andmap symbol? '(string-append foo bar)) ; #t
copy to clipboard

Here, (string-append foo bar) is an S-expres­sion consisting of a list containing three iden­ti­fiers. When eval­u­ated normally, it becomes "seesaw". When converted to a datum, it becomes a list of three symbols (= 'string-append, 'foo, 'bar).

Conversely, when a datum is eval­u­ated, symbols inside are treated as iden­ti­fiers. For instance, when the three symbols 'cons, 'foo, and 'bar are grouped into a list and eval­u­ated, they are treated as iden­ti­fiers:

(define foo "see")
(define bar "saw")
(define datum (list 'cons 'foo 'bar))
(evaluate datum) ; '("see" . "saw")
1
2
3
4
(define foo "see")
(define bar "saw")
(define datum (list 'cons 'foo 'bar))
(evaluate datum) ; '("see" . "saw")
copy to clipboard

In these situ­a­tions, if you really want a symbol in the result, then put two ' prefixes on the orig­inal item:

(define foo "see")
(define bar "saw")
(define datum (list 'cons ''foo ''bar))
(evaluate datum) ; '(foo . bar)
1
2
3
4
(define foo "see")
(define bar "saw")
(define datum (list 'cons ''foo ''bar))
(evaluate datum) ; '(foo . bar)
copy to clipboard

Most strings can be converted into iden­ti­fiers, though there are some reserved char­ac­ters and special conven­tions. For instance, strings repre­senting numbers cannot be used as iden­ti­fiers.

Further

Keywords

A keyword is used to intro­duce a keyword argu­ment either in a func­tion defi­n­i­tion or a call to that func­tion. Below, #:base and #:pow are keywords:

(define (f #:base x #:pow y)
  (expt x y))
(f #:base 2 #:pow 8) ; 256
1
2
3
(define (f #:base x #:pow y)
  (expt x y))
(f #:base 2 #:pow 8) ; 256
copy to clipboard

It’s usually only neces­sary to think about keywords as data if you’re writing macros or other special oper­a­tions that program­mat­i­cally manip­u­late keyword argu­ments, in which case you can use string->keyword and keyword->string to convert.

(define (f #:base x #:pow y)
  (expt x y))
(f #:base 2 #:pow 8) ; 256
(keyword-apply f '(#:base #:pow) '(2 8) empty) ; 256
(keyword-apply f (list
                  (string->keyword "base")
                  (string->keyword "pow")) '(2 8) empty) ; 256
1
2
3
4
5
6
7
(define (f #:base x #:pow y)
  (expt x y))
(f #:base 2 #:pow 8) ; 256
(keyword-apply f '(#:base #:pow) '(2 8) empty) ; 256
(keyword-apply f (list
                  (string->keyword "base")
                  (string->keyword "pow")) '(2 8) empty) ; 256
copy to clipboard

For more about the use of keyword argu­ments, see func­tions.

Further

Comments

A line comment begins with ;. A multi­line comment is delim­ited with #| and |#. A single S-expres­sion can be commented with #;.

; comment
"not a comment"
#|
a nice
multiline
comment
|#
(list 1 2 #;(list 'comment) 3 4)
1
2
3
4
5
6
7
8
; comment
"not a comment"
#|
a nice
multiline
comment
|#
(list 1 2 #;(list 'comment) 3 4)
copy to clipboard
"not a comment"
'(1 2 3 4)
1
2
"not a comment"
'(1 2 3 4)
copy to clipboard

Path strings

A path string is not a distinct type, but rather the subset of strings that can be converted into a valid path. Many Racket func­tions that manip­u­late paths will accept either a path or a path string, so it’s often not neces­sary to manu­ally convert the input argu­ment with string->path:

(file-exists? (string->path "/usr/bin/racket")) ; #t
(file-exists? "/usr/bin/racket") ; #t
1
2
(file-exists? (string->path "/usr/bin/racket")) ; #t
(file-exists? "/usr/bin/racket") ; #t
copy to clipboard

Paths

A path repre­sents a file loca­tion. Paths are similar to strings. But it’s slightly misleading to cate­go­rize them as “string­like”, because they’re made of a sequence of bytes rather than Unicode char­ac­ters. In Racket, this is called a byte string. It’s a distinct data type from an ordi­nary Unicode string.

In prac­tice, many paths can be converted to an ordi­nary string and back to a path. So as a conve­nience, Racket offers path->string and string->path:

"/usr/bin/racket"
(string->path "/usr/bin/racket")
(path->string (string->path "/usr/bin/racket"))
1
2
3
"/usr/bin/racket"
(string->path "/usr/bin/racket")
(path->string (string->path "/usr/bin/racket"))
copy to clipboard
"/usr/bin/racket"
#<path:/usr/bin/racket>
"/usr/bin/racket"
1
2
3
"/usr/bin/racket"
#<path:/usr/bin/racket>
"/usr/bin/racket"
copy to clipboard

But some paths can’t be converted to a string without losing data. In general, path->string is intended for making user-read­able versions of paths. It’s unwise to manip­u­late paths by converting them to strings and back again. Better to use Racket’s dedi­cated path-manip­u­la­tion func­tions.

Further

← prev next →