|
|
|
![\"+\"](\"finger.png\")
[Identifiers and Binding](binding.html) (later in this guide) explains more about identifiers.\n ( ) \\[ \\] { } \" , ' \\` ; # \\| \\\\\nand except for the sequences of characters that make number constants, almost any sequence of non-whitespace characters forms an ‹id›. For example substring is an identifier. Also, string-append and a+b are identifiers, as opposed to arithmetic expressions. Here are several more examples:\n> ```racket\n> +\n> integer?\n> pass/fail\n> Hfuhruhurr&Uumellmahaye\n> john-jacob-jingleheimer-schmidt\n> a-b-c+1-2-3\n> ```"}
{"text": "#### 2.2.4 Function Calls (Procedure Applications)\nWe have already seen many function calls, which are called procedure applications in more traditional terminology. The syntax of a function call is\n> > > [Function Calls](application.html) (later in this guide) explains more about function calls.\n> ( ‹id› ‹expr›\\* )\nwhere the number of ‹expr›s determines the number of arguments supplied to the function named by ‹id›.\nThe [racket](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) language pre-defines many function identifiers, such as [substring](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=strings.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._substring%2529%2529&version=8.18.0.13) and [string-append](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=strings.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._string-append%2529%2529&version=8.18.0.13). More examples are below.\nIn example Racket code throughout the documentation, uses of pre-defined names are hyperlinked to the reference manual. So, you can click on an identifier to get full details about its use."}
{"text": "# 2.2 Simple Definitions and Expressions\n> ```racket\n> > ( string-append \"rope\" \"twine\" \"yarn\" ) ; append strings\n> \"ropetwineyarn\"\n> > ( substring \"corduroys\" 0 4 ) ; extract a substring\n> \"cord\"\n> > ( string-prefix? \"shoelace\" \"shoe\" ) ; recognize string prefix/suffix\n> #t\n> > ( string-suffix? \"shoelace\" \"shoe\" )\n> #f\n> > ( string? \"Ceci n'est pas une string.\" ) ; recognize strings\n> #t\n> > ( string? 1 )\n> #f\n> > ( sqrt 16 ) ; find a square root\n> 4\n> > ( sqrt -1 6 )\n> 0+4i\n> > ( + 1 2 ) ; add numbers\n> 3\n> > ( - 2 1 ) ; subtract numbers\n> 1\n> > ( < 2 1 ) ; compare numbers> #f\n> > ( >= 2 1 )\n> #t\n> > ( number? \"c'est une number\" ) ; recognize numbers\n> #f\n> > ( number? 1 )\n> #t\n> > ( equal? 6 \"half dozen\" ) ; compare anything\n> #f\n> > ( equal? 6 6 )\n> #t\n> > ( equal? \"half dozen\" \"half dozen\" )\n> #t\n> ```"}
{"text": "#### 2.2.5 Conditionals with [if](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._if%2529%2529&version=8.18.0.13), [and](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._and%2529%2529&version=8.18.0.13), [or](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._or%2529%2529&version=8.18.0.13), and [cond](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._cond%2529%2529&version=8.18.0.13)\nThe next simplest kind of expression is an [if](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._if%2529%2529&version=8.18.0.13) conditional:\n> ( if ‹expr› ‹expr› ‹expr› )\n> > > [Conditionals](conditionals.html) (later in this guide) explains more about conditionals."}
{"text": "# 2.2 Simple Definitions and Expressions\nThe first ‹expr› is always evaluated. If it produces a non-#f value, then the second ‹expr› is evaluated for the result of the whole [if](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._if%2529%2529&version=8.18.0.13) expression, otherwise the third ‹expr› is evaluated for the result.\nExample:\n> ```racket\n> > ( if ( > 2 3 ) \"2 is bigger than 3\" \"2 is smaller than 3\" )\n> \"2 is smaller than 3\"\n> ```\n> |
|
|
[Combining Tests: and and or](conditionals.html#%28part._and%2Bor%29) (later in this guide) explains more about [and](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._and%2529%2529&version=8.18.0.13) and [or](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._or%2529%2529&version=8.18.0.13).\n> ```racket\n> ( and ‹ expr › * )\n> ( or ‹ expr › * )\n> ```"}
{"text": "# 2.2 Simple Definitions and Expressions\nThe [and](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._and%2529%2529&version=8.18.0.13) form short-circuits: it stops and returns #f when an expression produces #f, otherwise it keeps going. The [or](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._or%2529%2529&version=8.18.0.13) form similarly short-circuits when it encounters a true result.\nExamples:\n> ```racket\n> ( define ( reply-non-string s ) ( if ( and ( string? s ) ( string-prefix? s \"hello \" ) ) \"hi!\" \"huh?\" ) )\n> > ( reply-non-string \"hello racket\" )\n> \"hi!\"\n> > ( reply-non-string 17 )\n> \"huh?\"\n> ```\nNote that in the above grammar, the [and](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._and%2529%2529&version=8.18.0.13) and [or](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._or%2529%2529&version=8.18.0.13) forms work with any number of expressions.\nExamples:"}
{"text": "# 2.2 Simple Definitions and Expressions\n> ```racket\n> ( define ( reply-only-enthusiastic s ) ( if ( and ( string? s ) ( string-prefix? s \"hello \" ) ( string-suffix? s \"!\" ) ) \"hi!\" \"huh?\" ) )\n> > ( reply-only-enthusiastic \"hello racket!\" )\n> \"hi!\"\n> > ( reply-only-enthusiastic \"hello racket\" )\n> \"huh?\"\n> ```\nAnother common pattern of nested [if](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._if%2529%2529&version=8.18.0.13)s involves a sequence of tests, each with its own result:\n> ```racket\n> ( define ( reply-more s )\n> ( if ( string-prefix? s \"hello \" )\n> \"hi!\"\n> ( if ( string-prefix? s \"goodbye \" )\n> \"bye!\"\n> ( if ( string-suffix? s \"?\" )\n> \"I don't know\"\n> \"huh?\" ) ) ) )\n> ```\nThe shorthand for a sequence of tests is the [cond](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._cond%2529%2529&version=8.18.0.13) form:\n> > > [Chaining Tests: cond](conditionals.html#%28part._cond%29) (later in this guide) explains more about [cond](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._cond%2529%2529&version=8.18.0.13).\n> ( cond {\\[ ‹expr› ‹expr›\\* \\]}\\* )"}
{"text": "# 2.2 Simple Definitions and Expressions\nA [cond](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._cond%2529%2529&version=8.18.0.13) form contains a sequence of clauses between square brackets. In each clause, the first ‹expr› is a test expression. If it produces true, then the clause’s remaining ‹expr›s are evaluated, and the last one in the clause provides the answer for the entire [cond](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._cond%2529%2529&version=8.18.0.13) expression; the rest of the clauses are ignored. If the test ‹expr› produces #f, then the clause’s remaining ‹expr›s are ignored, and evaluation continues with the next clause. The last clause can use [else](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._else%2529%2529&version=8.18.0.13) as a synonym for a #t test expression.\nUsing [cond](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._cond%2529%2529&version=8.18.0.13), the reply-more function can be more clearly written as follows:\n> ```\n(define (reply-more s)"}
{"text": "# 2.2 Simple Definitions and Expressions\n> ( cond\n> [ ( string-prefix? s \"hello \" )\n> \"hi!\" ]\n> [ ( string-prefix? s \"goodbye \" )\n> \"bye!\" ]\n> [ ( string-suffix? s \"?\" )\n> \"I don't know\" ]\n> [ else \"huh?\" ] ) )\n> ( reply-more \"hello racket\" )\n> \"hi!\"\n> > ( reply-more \"goodbye cruel world\" )\n> \"bye!\"\n> > ( reply-more \"what is your favorite color?\" )\n> \"I don't know\"\n> > ( reply-more \"mine is lime green\" )\n> \"huh?\"\n```\nThe use of square brackets for cond clauses is a convention. In Racket, parentheses and square brackets are actually interchangeable, as long as ( is matched with ) and \\[ is matched with \\]. Using square brackets in a few key places makes Racket code even more readable.\n\n#### 2.2.6 Function Calls, Again\n\nIn our earlier grammar of function calls, we oversimplified. The actual syntax of a function call allows an arbitrary expression for the function, instead of just an ‹id›:\n\n> > > Function Calls (later in this guide) explains more about function calls.\n\n> ( ‹expr› ‹expr›\\* )\n\nThe first ‹expr› is often an ‹id›, such as string-append or +, but it can be anything that evaluates to a function. For example, it can be a conditional expression:\n\n> |
|
|
Functions: lambda (later in this guide) explains more about lambda.\n\n> ```racket\n> > ( define a 1 )\n> > ( define b 2 )\n> > ( + a b )\n> 3\n> ```\n\nIt turns out that having to name all your functions can be tedious, too. For example, you might have a function twice that takes a function and an argument. Using twice is convenient if you already have a name for the function, such as sqrt:\n\n> |
|
|
|
|
|
|
|
|
[Internal Definitions](define.html#%28part._intdefs%29) (later in this guide) explains more about local (internal) definitions.\n\n> ```racket\n> ( define ( ‹ id › ‹ id › * ) ‹ definition › * ‹ expr › + )\n> ( lambda ( ‹ id › * ) ‹ definition › * ‹ expr › + )\n> ```\n\nDefinitions at the start of a function body are local to the function body.\n\nExamples:\n\n> ```racket\n> ( define ( converse s ) ( define ( starts? s2 ) ; local to converse ( define spaced-s2 ( string-append s2 \" \" ) ) ; local to starts? ( string-prefix? s spaced-s2 ) ) ( cond [ ( starts? \"hello\" ) \"hi!\" ] [ ( starts? \"goodbye\" ) \"bye!\" ] [ else \"huh?\" ] ) )\n> > ( converse \"hello world\" )\n> \"hi!\"\n> > ( converse \"hellonearth\" )\n> \"huh?\"\n> > ( converse \"goodbye friends\" )\n> \"bye!\"\n> > ( converse \"urp\" )\n> \"huh?\"\n> > starts? ; outside of converse , so...\n> starts?: undefined;\n> cannot reference an identifier before its definition\n> in module: top-level\n> ```\n\nAnother way to create local bindings is the [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) form. An advantage of [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) is that it can be used in any expression position. Also, [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) binds many identifiers at once, instead of requiring a separate [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) for each identifier.\n\n> > > [Internal Definitions](define.html#%28part._intdefs%29) (later in this guide) explains more about [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) and [let*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%252A%2529%2529&version=8.18.0.13).\n\n> ( let ( {\\[ ‹id› ‹expr› \\]}\\* ) ‹expr›+ )\n\nEach binding clause is an ‹id› and an ‹expr› surrounded by square brackets, and the expressions after the clauses are the body of the [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13). In each clause, the ‹id› is bound to the result of the ‹expr› for use in the body.\n\n> ```racket\n> > ( let ( [ x ( random 4 ) ] [ o ( random 4 ) ] ) ( cond [ ( > x o ) \"X wins\" ] [ ( > o x ) \"O wins\" ] [ else \"cat's game\" ] ) )\n> \"cat's game\"\n> ```\n\nThe bindings of a [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) form are available only in the body of the [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13), so the binding clauses cannot refer to each other. The [let*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%252A%2529%2529&version=8.18.0.13) form, in contrast, allows later clauses to use earlier bindings:\n\n> ```racket\n> > ( let* ( [ x ( random 4 ) ] [ o ( random 4 ) ] [ diff ( number->string ( abs ( - x o ) ) ) ] ) ( cond [ ( > x o ) ( string-append \"X wins by \" diff ) ] [ ( > o x ) ( string-append \"O wins by \" diff ) ] [ else \"cat's game\" ] ) )\n> \"O wins by 2\"\n> ```\n\n------------------------------------------------------------------------\n\n# 2.3 Lists, Iteration, and Recursion\n\n### 2.3 Lists, Iteration, and Recursion\n\nRacket is a dialect of the language Lisp, whose name originally stood for “LISt Processor.” The built-in list datatype remains a prominent feature of the language.\n\nThe [list](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._list%2529%2529&version=8.18.0.13) function takes any number of values and returns a list containing the values:\n\n> ```racket\n> > ( list \"red\" \"green\" \"blue\" )\n> '(\"red\" \"green\" \"blue\")\n> > ( list 1 2 3 4 5 )\n> '(1 2 3 4 5)\n> ```\n\n> > > A list usually prints with ', but the printed form of a list depends on its content. See [Pairs and Lists](pairs.html) for more information.\n\nAs you can see, a list result prints in the [REPL](intro.html#%28tech._repl%29) as a quote ' and then a pair of parentheses wrapped around the printed form of the list elements. There’s an opportunity for confusion here, because parentheses are used for both expressions, such as ([list](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._list%2529%2529&version=8.18.0.13) \"red\" \"green\" \"blue\"), and printed results, such as '(\"red\" \"green\" \"blue\"). In addition to the quote, parentheses for results are printed in blue in the documentation and in DrRacket, whereas parentheses for expressions are brown.\n\nMany predefined functions operate on lists. Here are a few examples:\n\n> ```racket\n> > ( length ( list \"hop\" \"skip\" \"jump\" ) ) ; count the elements\n> 3\n> > ( list-ref ( list \"hop\" \"skip\" \"jump\" ) 0 ) ; extract by position\n> \"hop\"\n> > ( list-ref ( list \"hop\" \"skip\" \"jump\" ) 1 )\n> \"skip\"\n> > ( append ( list \"hop\" \"skip\" ) ( list \"jump\" ) ) ; combine lists\n> '(\"hop\" \"skip\" \"jump\")\n> > ( reverse ( list \"hop\" \"skip\" \"jump\" ) ) ; reverse order\n> '(\"jump\" \"skip\" \"hop\")\n> > ( member \"fall\" ( list \"hop\" \"skip\" \"jump\" ) ) ; check for an element\n> #f\n> ```\n\n#### 2.3.1 Predefined List Loops\n\nIn addition to simple operations like [append](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._append%2529%2529&version=8.18.0.13), Racket includes functions that iterate over the elements of a list. These iteration functions play a role similar to [for](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%2529%2529&version=8.18.0.13) in Java, Racket, and other languages. The body of a Racket iteration is packaged into a function to be applied to each element, so the [lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13) form becomes particularly handy in combination with iteration functions.\n\nDifferent list-iteration functions combine iteration results in different ways. The [map](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._map%2529%2529&version=8.18.0.13) function uses the per-element results to create a new list:\n\n> ```racket\n> > ( map sqrt ( list 1 4 9 16 ) )\n> '(1 2 3 4)\n> > ( map ( lambda ( i ) ( string-append i \"!\" ) ) ( list \"peanuts\" \"popcorn\" \"crackerjack\" ) )\n> '(\"peanuts!\" \"popcorn!\" \"crackerjack!\")\n> ```\n\nThe [andmap](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._andmap%2529%2529&version=8.18.0.13) and [ormap](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._ormap%2529%2529&version=8.18.0.13) functions combine the results by [and](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._and%2529%2529&version=8.18.0.13)ing or [or](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._or%2529%2529&version=8.18.0.13)ing:\n\n> ```racket\n> > ( andmap string? ( list \"a\" \"b\" \"c\" ) )\n> #t\n> > ( andmap string? ( list \"a\" \"b\" 6 ) )\n> #f\n> > ( ormap number? ( list \"a\" \"b\" 6 ) )\n> #t\n> ```\n\nThe [map](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._map%2529%2529&version=8.18.0.13), [andmap](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._andmap%2529%2529&version=8.18.0.13), and [ormap](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._ormap%2529%2529&version=8.18.0.13) functions can all handle multiple lists, instead of just a single list. The lists must all have the same length, and the given function must accept one argument for each list:\n\n> ```racket\n> > ( map ( lambda ( s n ) ( substring s 0 n ) ) ( list \"peanuts\" \"popcorn\" \"crackerjack\" ) ( list 6 3 7 ) )\n> '(\"peanut\" \"pop\" \"cracker\")\n> ```\n\nThe [filter](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Flist..rkt%2529._filter%2529%2529&version=8.18.0.13) function keeps elements for which the body result is true, and discards elements for which it is #f:\n\n> ```racket\n> > ( filter string? ( list \"a\" \"b\" 6 ) )\n> '(\"a\" \"b\")\n> > ( filter positive? ( list 1 -2 6 7 0 ) )\n> '(1 6 7)\n> ```\n\nThe [foldl](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Flist..rkt%2529._foldl%2529%2529&version=8.18.0.13) function generalizes some iteration functions. It uses the per-element function to both process an element and combine it with the “current” value, so the per-element function takes an extra first argument. Also, a starting “current” value must be provided before the lists:\n\n> ```racket\n> > ( foldl ( lambda ( elem v ) ( + v ( * elem elem ) ) ) 0 ' ( 1 2 3 ) )\n> 14\n> ```\n\nDespite its generality, [foldl](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Flist..rkt%2529._foldl%2529%2529&version=8.18.0.13) is not as popular as the other functions. One reason is that [map](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._map%2529%2529&version=8.18.0.13), [ormap](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._ormap%2529%2529&version=8.18.0.13), [andmap](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._andmap%2529%2529&version=8.18.0.13), and [filter](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Flist..rkt%2529._filter%2529%2529&version=8.18.0.13) cover the most common kinds of list loops.\n\nRacket provides a general list comprehension form [for/list](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%252Flist%2529%2529&version=8.18.0.13), which builds a list by iterating through sequences. List comprehensions and related iteration forms are described in [Iterations and Comprehensions](for.html).\n\n#### 2.3.2 List Iteration from Scratch\n\nAlthough [map](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._map%2529%2529&version=8.18.0.13) and other iteration functions are predefined, they are not primitive in any interesting sense. You can write equivalent iterations using a handful of list primitives.\n\nSince a Racket list is a linked list, the two core operations on a non-empty list are\n\n- [first](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._first%2529%2529&version=8.18.0.13): get the first thing in the list; and\n\n- [rest](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._rest%2529%2529&version=8.18.0.13): get the rest of the list.\n\nExamples:\n\n> ```racket\n> > ( first ( list 1 2 3 ) )\n> 1\n> > ( rest ( list 1 2 3 ) )\n> '(2 3)\n> ```\n\nTo create a new node for a linked list—that is, to add to the front of the list—use the [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13) function, which is short for “construct.” To get an empty list to start with, use the [empty](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._empty%2529%2529&version=8.18.0.13) constant:\n\n> ```racket\n> > empty\n> '()\n> > ( cons \"head\" empty )\n> '(\"head\")\n> > ( cons \"dead\" ( cons \"head\" empty ) )\n> '(\"dead\" \"head\")\n> ```\n\nTo process a list, you need to be able to distinguish empty lists from non-empty lists, because [first](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._first%2529%2529&version=8.18.0.13) and [rest](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._rest%2529%2529&version=8.18.0.13) work only on non-empty lists. The [empty?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._empty%7E3f%2529%2529&version=8.18.0.13) function detects empty lists, and [cons?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._cons%7E3f%2529%2529&version=8.18.0.13) detects non-empty lists:\n\n> ```racket\n> > ( empty? empty )\n> #t\n> > ( empty? ( cons \"head\" empty ) )\n> #f\n> > ( cons? empty )\n> #f\n> > ( cons? ( cons \"head\" empty ) )\n> #t\n> ```\n\nWith these pieces, you can write your own versions of the [length](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._length%2529%2529&version=8.18.0.13) function, [map](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._map%2529%2529&version=8.18.0.13) function, and more.\n\nExamples:\n\n> ```racket\n> ( define ( my-length lst ) ( cond [ ( empty? lst ) 0 ] [ else ( + 1 ( my-length ( rest lst ) ) ) ] ) )\n> > ( my-length empty )\n> 0\n> > ( my-length ( list \"a\" \"b\" \"c\" ) )\n> 3\n> ```\n\n> ```\n(define (my-map f lst)\n> ( cond\n> [ ( empty? lst ) empty ]\n> [ else ( cons ( f ( first lst ) )\n> ( my-map f ( rest lst ) ) ) ] ) )\n \n> ( my-map string-upcase ( list \"ready\" \"set\" \"go\" ) )\n> '(\"READY\" \"SET\" \"GO\")\n```"}
{"text": "# 2.2 Simple Definitions and Expressions\nIf the derivation of the above definitions is mysterious to you, consider reading How to Design Programs. If you are merely suspicious of the use of recursive calls instead of a looping construct, then read on."}
{"text": "#### 2.3.3 Tail Recursion\nBoth the my-length and my-map functions run in O(n) space for a list of length n. This is easy to see by imagining how (my-length (list \"a\" \"b\" \"c\")) must evaluate:\n> ```racket\n> ( my-length ( list \"a\" \"b\" \"c\" ) )\n> = ( + 1 ( my-length ( list \"b\" \"c\" ) ) )\n> = ( + 1 ( + 1 ( my-length ( list \"c\" ) ) ) )\n> = ( + 1 ( + 1 ( + 1 ( my-length ( list ) ) ) ) )\n> = ( + 1 ( + 1 ( + 1 0 ) ) )\n> = ( + 1 ( + 1 1 ) )\n> = ( + 1 2 )\n> = 3\n> ```\nFor a list with n elements, evaluation will stack up n (+ 1 ...) additions, and then finally add them up when the list is exhausted.\nYou can avoid piling up additions by adding along the way. To accumulate a length this way, we need a function that takes both a list and the length of the list seen so far; the code below uses a local function iter that accumulates the length in an argument len:\n> ```racket\n> ( define ( my-length lst )\n> ; local function iter :\n> ( define ( iter lst len )\n> ( cond\n> [ ( empty? lst ) len ]\n> [ else ( iter ( rest lst ) ( + len 1 ) ) ] ) )\n> ; body of my-length calls iter :\n> ( iter lst 0 ) )\n> ```\nNow evaluation looks like this:\n> ```racket\n> ( my-length ( list \"a\" \"b\" \"c\" ) )\n> = ( iter ( list \"a\" \"b\" \"c\" ) 0 )\n> = ( iter ( list \"b\" \"c\" ) 1 )\n> = ( iter ( list \"c\" ) 2 )\n> = ( iter ( list ) 3 )\n> 3\n> ```"}
{"text": "# 2.2 Simple Definitions and Expressions\nThe revised my-length runs in constant space, just as the evaluation steps above suggest. That is, when the result of a function call, like (iter (list \"b\" \"c\") 1), is exactly the result of some other function call, like (iter (list \"c\") 2), then the first one doesn’t have to wait around for the second one, because that takes up space for no good reason.\nThis evaluation behavior is sometimes called tail-call optimization, but it’s not merely an “optimization” in Racket; it’s a guarantee about the way the code will run. More precisely, an expression in tail position with respect to another expression does not take extra computation space over the other expression.\nIn the case of my-map, O(n) space complexity is reasonable, since it has to generate a result of size O(n). Nevertheless, you can reduce the constant factor by accumulating the result list. The only catch is that the accumulated list will be backwards, so you’ll have to reverse it at the very end:\n> > > Attempting to reduce a constant factor like this is usually not worthwhile, as discussed below.\n> ```racket\n> ( define ( my-map f lst )\n> ( define ( iter lst backward-result )\n> ( cond\n> [ ( empty? lst ) ( reverse backward-result ) ]\n> [ else ( iter ( rest lst )\n> ( cons ( f ( first lst ) )\n> backward-result ) ) ] ) )\n> ( iter lst empty ) )\n> ```\nIt turns out that if you write\n> ```racket\n> ( define ( my-map f lst )\n> ( for/list ( [ i lst ] )\n> ( f i ) ) )\n> ```"}
{"text": "# 2.2 Simple Definitions and Expressions\nthen the for/list form in the function is expanded to essentially the same code as the iter local definition and use. The difference is merely syntactic convenience."}
{"text": "#### 2.3.4 Recursion versus Iteration\nThe my-length and my-map examples demonstrate that iteration is just a special case of recursion. In many languages, it’s important to try to fit as many computations as possible into iteration form. Otherwise, performance will be bad, and moderately large inputs can lead to stack overflow. Similarly, in Racket, it is sometimes important to make sure that tail recursion is used to avoid O(n) space consumption when the computation is easily performed in constant space.\nAt the same time, recursion does not lead to particularly bad performance in Racket, and there is no such thing as stack overflow; you can run out of memory if a computation involves too much context, but exhausting memory typically requires orders of magnitude deeper recursion than would trigger a stack overflow in other languages. These considerations, combined with the fact that tail-recursive programs automatically run the same as a loop, lead Racket programmers to embrace recursive forms rather than avoid them.\nSuppose, for example, that you want to remove consecutive duplicates from a list. While such a function can be written as a loop that remembers the previous element for each iteration, a Racket programmer would more likely just write the following:\n> ```\n(define (remove-dups l)\n> ( cond\n> [ ( empty? l ) empty ]\n> [ ( empty? ( rest l ) ) l ]\n> [ else\n> ( let ( [ i ( first l ) ] )\n> ( if ( equal? i ( first ( rest l ) ) )\n> ( remove-dups ( rest l ) )\n> ( cons i ( remove-dups ( rest l ) ) ) ) ) ] ) )"}
{"text": "# 2.2 Simple Definitions and Expressions\n> ( remove-dups ( list \"a\" \"b\" \"b\" \"b\" \"c\" \"c\" ) )\n> '(\"a\" \"b\" \"c\")```\nIn general, this function consumes O(n) space for an input list of length n, but that’s fine, since it produces an O(n) result. If the input list happens to be mostly consecutive duplicates, then the resulting list can be much smaller than O(n)—and remove-dups will also use much less than O(n) space! The reason is that when the function discards duplicates, it returns the result of a remove-dups call directly, so the tail-call “optimization” kicks in:\n> ```racket\n> ( remove-dups ( list \"a\" \"b\" \"b\" \"b\" \"b\" \"b\" ) )\n> = ( cons \"a\" ( remove-dups ( list \"b\" \"b\" \"b\" \"b\" \"b\" ) ) )\n> = ( cons \"a\" ( remove-dups ( list \"b\" \"b\" \"b\" \"b\" ) ) )\n> = ( cons \"a\" ( remove-dups ( list \"b\" \"b\" \"b\" ) ) )\n> = ( cons \"a\" ( remove-dups ( list \"b\" \"b\" ) ) )\n> = ( cons \"a\" ( remove-dups ( list \"b\" ) ) )\n> = ( cons \"a\" ( list \"b\" ) )\n> = ( list \"a\" \"b\" )\n> ```\n------------------------------------------------------------------------"}
{"text": "# 2.4 Pairs, Lists, and Racket Syntax"}
{"text": "### 2.4 Pairs, Lists, and Racket Syntax\nThe [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13) function actually accepts any two values, not just a list for the second argument. When the second argument is not [empty](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._empty%2529%2529&version=8.18.0.13) and not itself produced by [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13), the result prints in a special way. The two values joined with [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13) are printed between parentheses, but with a dot (i.e., a period surrounded by whitespace) in between:\n> ```racket\n> > ( cons 1 2 )\n> '(1 . 2)\n> > ( cons \"banana\" \"split\" )\n> '(\"banana\" . \"split\")\n> ```"}
{"text": "# 2.4 Pairs, Lists, and Racket Syntax\nThus, a value produced by [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13) is not always a list. In general, the result of [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13) is a pair. The more traditional name for the [cons?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._cons%7E3f%2529%2529&version=8.18.0.13) function is [pair?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._pair%7E3f%2529%2529&version=8.18.0.13), and we’ll use the traditional name from now on."}
{"text": "# 2.4 Pairs, Lists, and Racket Syntax\nThe name [rest](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._rest%2529%2529&version=8.18.0.13) also makes less sense for non-list pairs; the more traditional names for [first](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._first%2529%2529&version=8.18.0.13) and [rest](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Flist..rkt%2529._rest%2529%2529&version=8.18.0.13) are [car](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._car%2529%2529&version=8.18.0.13) and [cdr](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cdr%2529%2529&version=8.18.0.13), respectively. (Granted, the traditional names are also nonsense. Just remember that “a” comes before “d,” and [cdr](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cdr%2529%2529&version=8.18.0.13) is pronounced “could-er.”)\nExamples:"}
{"text": "# 2.4 Pairs, Lists, and Racket Syntax\n> ```racket\n> > ( car ( cons 1 2 ) )\n> 1\n> > ( cdr ( cons 1 2 ) )\n> 2\n> > ( pair? empty )\n> #f\n> > ( pair? ( cons 1 2 ) )\n> #t\n> > ( pair? ( list 1 2 3 ) )\n> #t\n> ```\nRacket’s pair datatype and its relation to lists is essentially a historical curiosity, along with the dot notation for printing and the funny names [car](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._car%2529%2529&version=8.18.0.13) and [cdr](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cdr%2529%2529&version=8.18.0.13). Pairs are deeply wired into the culture, specification, and implementation of Racket, however, so they survive in the language.\nYou are perhaps most likely to encounter a non-list pair when making a mistake, such as accidentally reversing the arguments to [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13):\n> ```racket\n> > ( cons ( list 2 3 ) 1 )\n> '((2 3) . 1)\n> > ( cons 1 ( list 2 3 ) )\n> '(1 2 3)\n> ```"}
{"text": "# 2.4 Pairs, Lists, and Racket Syntax\nNon-list pairs are used intentionally, sometimes. For example, the [make-hash](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=hashtables.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._make-hash%2529%2529&version=8.18.0.13) function takes a list of pairs, where the [car](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._car%2529%2529&version=8.18.0.13) of each pair is a key and the [cdr](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cdr%2529%2529&version=8.18.0.13) is an arbitrary value.\nThe only thing more confusing to new Racketeers than non-list pairs is the printing convention for pairs where the second element is a pair, but is not a list:\n> ```racket\n> > ( cons 0 ( cons 1 2 ) )\n> '(0 1 . 2)\n> ```\nIn general, the rule for printing a pair is as follows: use the dot notation unless the dot is immediately followed by an open parenthesis. In that case, remove the dot, the open parenthesis, and the matching close parenthesis. Thus, '(0 . (1 . 2)) becomes '(0 1 . 2), and '(1 . (2 . (3 . ()))) becomes '(1 2 3)."}
{"text": "#### 2.4.1 Quoting Pairs and Symbols with [quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._quote%2529%2529&version=8.18.0.13)\nA list prints with a quote mark before it, but if an element of a list is itself a list, then no quote mark is printed for the inner list:\n> ```racket\n> > ( list ( list 1 ) ( list 2 3 ) ( list 4 ) )\n> '((1) (2 3) (4))\n> ```\nFor nested lists, especially, the [quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._quote%2529%2529&version=8.18.0.13) form lets you write a list as an expression in essentially the same way that the list prints:\n> ```racket\n> > ( quote ( \"red\" \"green\" \"blue\" ) )\n> '(\"red\" \"green\" \"blue\")\n> > ( quote ( ( 1 ) ( 2 3 ) ( 4 ) ) )\n> '((1) (2 3) (4))\n> > ( quote ( ) )\n> '()\n> ```\nThe [quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._quote%2529%2529&version=8.18.0.13) form works with the dot notation, too, whether the quoted form is normalized by the dot-parenthesis elimination rule or not:\n> ```racket\n> > ( quote ( 1 . 2 ) )\n> '(1 . 2)\n> > ( quote ( 0 . ( 1 . 2 ) ) )\n> '(0 1 . 2)\n> ```\nNaturally, lists of any kind can be nested:"}
{"text": "# 2.4 Pairs, Lists, and Racket Syntax\n> ```racket\n> > ( list ( list 1 2 3 ) 5 ( list \"a\" \"b\" \"c\" ) )\n> '((1 2 3) 5 (\"a\" \"b\" \"c\"))\n> > ( quote ( ( 1 2 3 ) 5 ( \"a\" \"b\" \"c\" ) ) )\n> '((1 2 3) 5 (\"a\" \"b\" \"c\"))\n> ```\nIf you wrap an identifier with [quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._quote%2529%2529&version=8.18.0.13), then you get output that looks like an identifier, but with a ' prefix:\n> ```racket\n> > ( quote jane-doe )\n> 'jane-doe\n> ```\nA value that prints like a quoted identifier is a symbol. In the same way that parenthesized output should not be confused with expressions, a printed symbol should not be confused with an identifier. In particular, the symbol ([quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._quote%2529%2529&version=8.18.0.13) map) has nothing to do with the map identifier or the predefined function that is bound to [map](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fmap..rkt%2529._map%2529%2529&version=8.18.0.13), except that the symbol and the identifier happen to be made up of the same letters."}
{"text": "# 2.4 Pairs, Lists, and Racket Syntax\nIndeed, the intrinsic value of a symbol is nothing more than its character content. In this sense, symbols and strings are almost the same thing, and the main difference is how they print. The functions [symbol->string](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=symbols.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._symbol-%7E3estring%2529%2529&version=8.18.0.13) and [string->symbol](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=symbols.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._string-%7E3esymbol%2529%2529&version=8.18.0.13) convert between them.\nExamples:\n> ```racket\n> > map\n> #![\"+\"](\"magnify.png\")
[Reading Numbers](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=reader.html%23%2528part._parse-number%2529&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) documents the fine points of the syntax of numbers.\nExamples:\n> ```racket\n> > 0.5\n> 0.5\n> > #e0.5\n> 1/2\n> > #x03BB\n> 955\n> ```\nComputations that involve an inexact number produce inexact results, so that inexactness acts as a kind of taint on numbers. Beware, however, that Racket offers no “inexact booleans,” so computations that branch on the comparison of inexact numbers can nevertheless produce exact results. The procedures [exact->inexact](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._exact-%7E3einexact%2529%2529&version=8.18.0.13) and [inexact->exact](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._inexact-%7E3eexact%2529%2529&version=8.18.0.13) convert between the two types of numbers.\nExamples:\n> ```racket\n> > ( / 1 2 )\n> 1/2\n> > ( / 1 2.0 )\n> 0.5\n> > ( if ( = 3.0 2.999 ) 1 2 )\n> 2\n> > ( inexact->exact 0.1 )\n> 3602879701896397/36028797018963968\n> ```"}
{"text": "# 3.2 Numbers\nInexact results are also produced by procedures such as [sqrt](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._sqrt%2529%2529&version=8.18.0.13), [log](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._log%2529%2529&version=8.18.0.13), and [sin](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._sin%2529%2529&version=8.18.0.13) when an exact result would require representing real numbers that are not rational. Racket can represent only rational numbers and complex numbers with rational parts.\nExamples:\n> ```racket\n> > ( sin 0 ) ; rational...\n> 0\n> > ( sin 1/2 ) ; not rational...\n> 0.479425538604203\n> ```\nIn terms of performance, computations with small integers are typically the fastest, where “small” means that the number fits into one bit less than the machine’s word-sized representation for signed numbers. Computation with very large exact integers or with non-integer exact numbers can be much more expensive than computation with inexact numbers.\n> ```\n(define (sigma f a b)\n> ( if ( = a b )\n> 0\n> ( + ( f a ) ( sigma f ( + a 1 ) b ) ) ) )"}
{"text": "# 3.2 Numbers\n> ( time ( round ( sigma ( lambda ( x ) ( / 1 x ) ) 1 2000 ) ) )\n> cpu time: 21 real time: 3 gc time: 0\n> 8\n> > ( time ( round ( sigma ( lambda ( x ) ( / 1.0 x ) ) 1 2000 ) ) )\n> cpu time: 0 real time: 0 gc time: 0\n> 8.0\n```\n(Unicode)\t→\t\n(-> integer → char 65)```\n\n\nThe above example says that, within a something-else form, a thing is either an identifier or a keyword.\n\n------------------------------------------------------------------------\n\n# 4.2 Identifiers and Binding\n\n### 4.2 Identifiers and Binding\n\nThe context of an expression determines the meaning of identifiers that appear in the expression. In particular, starting a module with the language [racket](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13), as in\n\n> [#lang](Module_Syntax.html#%28part._hash-lang%29) [racket](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13)\n\nmeans that, within the module, the identifiers described in this guide start with the meaning described here: [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13) refers to the function that creates a pair, [car](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._car%2529%2529&version=8.18.0.13) refers to the function that extracts the first element of a pair, and so on.\n\n> > > [Symbols](symbols.html) introduces the syntax of identifiers.\n\nForms like [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13), [lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13), and [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) associate a meaning with one or more identifiers; that is, they bind identifiers. The part of the program for which the binding applies is the scope of the binding. The set of bindings in effect for a given expression is the expression’s environment.\n\nFor example, in\n\n> ```racket\n> #lang racket\n> ( define f\n> ( lambda ( x )\n> ( let ( [ y 5 ] )\n> ( + x y ) ) ) )\n> ( f 10 )\n> ```\n\nthe [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) is a binding of f, the [lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13) has a binding for x, and the [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) has a binding for y. The scope of the binding for f is the entire module; the scope of the x binding is ([let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) (\\[y 5\\]) ([+](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._%252B%2529%2529&version=8.18.0.13) x y)); and the scope of the y binding is just ([+](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._%252B%2529%2529&version=8.18.0.13) x y). The environment of ([+](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._%252B%2529%2529&version=8.18.0.13) x y) includes bindings for y, x, and f, as well as everything in [racket](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13).\n\nA module-level [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) can bind only identifiers that are not already defined or [require](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._require%2529%2529&version=8.18.0.13)d into the module. A local [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) or other binding forms, however, can give a new local binding for an identifier that already has a binding; such a binding shadows the existing binding.\n\nExamples:\n\n> ```racket\n> ( define f ( lambda ( append ) ( define cons ( append \"ugly\" \"confusing\" ) ) ( let ( [ append ' this-was ] ) ( list append cons ) ) ) )\n> > ( f list )\n> '(this-was (\"ugly\" \"confusing\"))\n> ```\n\nSimilarly, a module-level [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) can [shadow](#%28tech._shadow%29) a binding from the module’s language. For example, ([define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13) 1) in a [racket](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) module shadows the [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13) that is provided by [racket](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13). Intentionally shadowing a language binding is rarely a good idea—especially for widely used bindings like [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13)—but shadowing relieves a programmer from having to avoid every obscure binding that is provided by a language.\n\nEven identifiers like [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) and [lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13) get their meanings from bindings, though they have transformer bindings (which means that they indicate syntactic forms) instead of value bindings. Since [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) has a transformer binding, the identifier define cannot be used by itself to get a value. However, the normal binding for define can be shadowed.\n\nExamples:\n\n> ```racket\n> > define\n> eval:1:0: define: bad syntax\n> in: define\n> > ( let ( [ define 5 ] ) define )\n> 5\n> ```\n\nAgain, shadowing standard bindings in this way is rarely a good idea, but the possibility is an inherent part of Racket’s flexibility.\n\n------------------------------------------------------------------------\n\n# 4.3 Function Calls\n\n### 4.3 Function Calls (Procedure Applications)\n\nAn expression of the form\n\n> > | |\n> > |--------------------------|\n> > | (proc-expr arg-expr ...) |\n\nis a function call—also known as a procedure application—when proc-expr is not an identifier that is bound as a syntax transformer (such as [if](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._if%2529%2529&version=8.18.0.13) or [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13)).\n\n#### 4.3.1 Evaluation Order and Arity\n\nA function call is evaluated by first evaluating the proc-expr and all arg-exprs in order (left to right). Then, if proc-expr produces a function that accepts as many arguments as supplied arg-exprs, the function is called. Otherwise, an exception is raised.\n\nExamples:\n\n> ```racket\n> > ( cons 1 null )\n> '(1)\n> > ( + 1 2 3 )\n> 6\n> > ( cons 1 2 3 )\n> cons: arity mismatch;\n> the expected number of arguments does not match the given\n> number\n> expected: 2\n> given: 3\n> > ( 1 2 3 )\n> application: not a procedure;\n> expected a procedure that can be applied to arguments\n> given: 1\n> ```\n\nSome functions, such as [cons](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._cons%2529%2529&version=8.18.0.13), accept a fixed number of arguments. Some functions, such as [+](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._%252B%2529%2529&version=8.18.0.13) or [list](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._list%2529%2529&version=8.18.0.13), accept any number of arguments. Some functions accept a range of argument counts; for example [substring](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=strings.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._substring%2529%2529&version=8.18.0.13) accepts either two or three arguments. A function’s arity is the number of arguments that it accepts.\n\n#### 4.3.2 Keyword Arguments\n\nSome functions accept keyword arguments in addition to by-position arguments. For that case, an arg can be an arg-keyword arg-expr sequence instead of just a arg-expr:\n\n> > > [Keywords](keywords.html) introduces keywords.\n\n> > ```\n(proc-expr arg ...)\n \narg = arg-expr\n | arg-keyword arg-expr\n```"}
{"text": "# 3.2 Numbers\nFor example,\n> (go \"super.rkt\" #:mode 'fast)\ncalls the function bound to go with \"super.rkt\" as a by-position argument, and with 'fast as an argument associated with the #:mode keyword. A keyword is implicitly paired with the expression that follows it.\nSince a keyword by itself is not an expression, then\n> (go \"super.rkt\" #:mode #:fast)\nis a syntax error. The #:mode keyword must be followed by an expression to produce an argument value, and #:fast is not an expression.\nThe order of keyword args determines the order in which arg-exprs are evaluated, but a function accepts keyword arguments independent of their position in the argument list. The above call to go can be equivalently written\n> (go #:mode 'fast \"super.rkt\")\n> > > Procedure Applications and #%app in The Racket Reference provides more on procedure applications."}
{"text": "#### 4.3.3 The apply Function\nThe syntax for function calls supports any number of arguments, but a specific call always specifies a fixed number of arguments. As a result, a function that takes a list of arguments cannot directly apply a function like + to all of the items in a list:\n> ```\n(define (avg lst) ; doesn’t work...\n> ( / ( + lst ) ( length lst ) ) )\n> ( avg ' ( 1 2 3 ) )\n> +: contract violation\n> expected: number?\n> given: '(1 2 3)```\n> ```\n(define (avg lst) ; doesn’t always work...\n> ( / ( + ( list-ref lst 0 ) ( list-ref lst 1 ) ( list-ref lst 2 ) )\n> ( length lst ) ) )\n> ( avg ' ( 1 2 3 ) )\n> 2\n> > ( avg ' ( 1 2 ) )\n> list-ref: index too large for list\n> index: 2\n> in: '(1 2)"}
{"text": "# 3.2 Numbers\n```\nThe apply function offers a way around this restriction. It takes a function and a list argument, and it applies the function to the values in the list:\n\n> |
|
|
|
|
|
The apply Function describes apply.\nExamples:\n> ```racket\n> ( define max-mag ( lambda nums ( apply max ( map magnitude nums ) ) ) )\n> > ( max 1 -2 0 )\n> 1\n> > ( max-mag 1 -2 0 )\n> 2\n> ```\nThe lambda form also supports required arguments combined with a rest-id:\n> > ```\n(lambda (arg-id ...+ . rest-id)\n> > body ...+ )```\nThe result of this form is a function that requires at least as many arguments as arg-ids, and also accepts any number of additional arguments.\nExamples:\n> ```racket\n> ( define max-mag ( lambda ( num . nums ) ( apply max ( map magnitude ( cons num nums ) ) ) ) )\n> > ( max-mag 1 -2 0 )\n> 2\n> > ( max-mag )\n> max-mag: arity mismatch;\n> the expected number of arguments does not match the given\n> number\n> expected: at least 1\n> given: 0\n> ```\nA rest-id variable is sometimes called a rest argument, because it accepts the “rest” of the function arguments. A function with a rest argument is sometimes called a variadic function, with elements in the rest argument called variadic arguments."}
{"text": "#### 4.4.2 Declaring Optional Arguments\nInstead of just an identifier, an argument (other than a rest argument) in a [lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13) form can be specified with an identifier and a default value:\n> > ```\n(lambda gen-formals\n> > body ...+ )\ngen-formals = (arg ...)\n | rest-id\n | (arg ...+ . rest-id)\narg = arg-id\n | [arg-id default-expr]\n```\nAn argument of the form \\[arg-id default-expr\\] is optional. When the argument is not supplied in an application, default-expr produces the default value. The default-expr can refer to any preceding arg-id, and every following arg-id must have a default as well.\n\nExamples:\n\n> ```racket\n> ( define greet ( lambda ( given [ surname \"Smith\" ] ) ( string-append \"Hello, \" given \" \" surname ) ) )\n> > ( greet \"John\" )\n> \"Hello, John Smith\"\n> > ( greet \"John\" \"Doe\" )\n> \"Hello, John Doe\"\n> ```\n\n> ```\n(define greet\n> ( lambda ( given [ surname ( if ( equal? given \"John\" )\n> \"Doe\"\n> \"Smith\" ) ] )\n> ( string-append \"Hello, \" given \" \" surname ) ) )\n \n> ( greet \"John\" )\n> \"Hello, John Doe\"\n> > ( greet \"Adam\" )\n> \"Hello, Adam Smith\"```\n\n\n#### 4.4.3 Declaring Keyword Arguments\n\nA [lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13) form can declare an argument to be passed by keyword, instead of position. Keyword arguments can be mixed with by-position arguments, and default-value expressions can be supplied for either kind of argument:\n\n> > > [Keyword Arguments](application.html#%28part._keyword-args%29) introduces function calls with keywords.\n\n> > ```\n(lambda gen-formals\n> > body ...+ )\n \ngen-formals = (arg ...)\n | rest-id\n | (arg ...+ . rest-id)\n \narg = arg-id\n | [arg-id default-expr]\n | arg-keyword arg-id\n | arg-keyword [arg-id default-expr]\n```"}
{"text": "# 3.2 Numbers\nAn argument specified as arg-keyword arg-id is supplied by an application using the same arg-keyword. The position of the keyword–identifier pair in the argument list does not matter for matching with arguments in an application, because it will be matched to an argument value by keyword instead of by position.\n> |
|
|
The apply Function introduces keyword-apply.\nExamples:\n> ```racket\n> ( define ( trace-wrap f ) ( make-keyword-procedure ( lambda ( kws kw-args . rest ) ( printf \"Called with ~s ~s ~s\\n\" kws kw-args rest ) ( keyword-apply f kws kw-args rest ) ) ) )\n> > ( ( trace-wrap greet ) \"John\" #:hi \"Howdy\" )\n> Called with (#:hi) (\"Howdy\") (\"John\")\n> \"Howdy, John Smith\"\n> ```\n> > > Procedure Expressions: lambda and case-lambda in The Racket Reference provides more on function expressions."}
{"text": "#### 4.4.4 Arity-Sensitive Functions: case-lambda\nThe case-lambda form creates a function that can have completely different behaviors depending on the number of arguments that are supplied. A case-lambda expression has the form\n> > ```\n(case-lambda\n> > [ formals body ...+ ]\n> > ... )\nformals = (arg-id ...)\n | rest-id\n | (arg-id ...+ . rest-id)```\nwhere each \\[formals body ...+\\] is analogous to ([lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13) formals body ...+). Applying a function produced by [case-lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._case-lambda%2529%2529&version=8.18.0.13) is like applying a [lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13) for the first case that matches the number of given arguments.\nExamples:"}
{"text": "# 3.2 Numbers\n> ```racket\n> ( define greet ( case-lambda [ ( name ) ( string-append \"Hello, \" name ) ] [ ( given surname ) ( string-append \"Hello, \" given \" \" surname ) ] ) )\n> > ( greet \"John\" )\n> \"Hello, John\"\n> > ( greet \"John\" \"Smith\" )\n> \"Hello, John Smith\"\n> > ( greet )\n> greet: arity mismatch;\n> the expected number of arguments does not match the given\n> number\n> given: 0\n> ```\nA [case-lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._case-lambda%2529%2529&version=8.18.0.13) function cannot directly support optional or keyword arguments.\n------------------------------------------------------------------------"}
{"text": "# 4.5 Definitions: define"}
{"text": "### 4.5 Definitions: [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13)\nA basic definition has the form\n> > | |\n> > |--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | ([define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) id expr) |\nin which case id is bound to the result of expr.\nExamples:\n> ```racket\n> ( define salutation ( list-ref ' ( \"Hi\" \"Hello\" ) ( random 2 ) ) )\n> > salutation\n> \"Hi\"\n> ```"}
{"text": "#### 4.5.1 Function Shorthand\nThe [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) form also supports a shorthand for function definitions:\n> > | |\n> > |-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | ([define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) (id arg ...) body ...+) |\nwhich is a shorthand for"}
{"text": "### 4.5 Definitions: [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13)\n> ([define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) id ([lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13) (arg [...](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=stx-patterns.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fstxcase-scheme..rkt%2529._......%2529%2529&version=8.18.0.13)) body ...+))\nExamples:\n> ```racket\n> ( define ( greet name ) ( string-append salutation \", \" name ) )\n> > ( greet \"John\" )\n> \"Hi, John\"\n> ```\n> ```\n(define (greet first [surname \"Smith\"] #:hi [hi salutation])\n> ( string-append hi \", \" first \" \" surname ) )\n> ( greet \"John\" )\n> \"Hi, John Smith\"\n> > ( greet \"John\" #:hi \"Hey\" )\n> \"Hey, John Smith\"\n> > ( greet \"John\" \"Doe\" )\n> \"Hi, John Doe\""}
{"text": "### 4.5 Definitions: [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13)\n```\nThe function shorthand via define also supports a rest argument (i.e., a final argument to collect extra arguments in a list):\n\n> > | |\n> > |---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | (define (id arg ... . rest-id) body ...+) |\n\nwhich is a shorthand\n\n> (define id (lambda (arg ... . rest-id) body ...+))\n\nExamples:\n\n> ```racket\n> ( define ( avg . l ) ( / ( apply + l ) ( length l ) ) )\n> > ( avg 1 2 3 )\n> 2\n> ```\n\n#### 4.5.2 Curried Function Shorthand\n\nConsider the following make-add-suffix function that takes a string and returns another function that takes a string:\n\n> |
|
|
|
|
|
|
|
|
| (define (head args) body ...+) | |||||||||||||||||||||||||
|
[Definitions: define, define-syntax, ...](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) provides more on definitions.\n\n#### 4.5.4 Internal Definitions\n\nWhen the grammar for a syntactic form specifies body, then the corresponding form can be either a definition or an expression. A definition as a body is an internal definition.\n\nExpressions and internal definitions in a body sequence can be mixed, as long as the last body is an expression.\n\nFor example, the syntax of [lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13) is\n\n> > ```\n(lambda gen-formals\n> > body ...+ )\n```"}
{"text": "### 4.5 Definitions: [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13)\nso the following are valid instances of the grammar:\n> ```racket\n> ( lambda ( f ) ; no definitions\n> ( printf \"running\\n\" )\n> ( f 0 ) )\n> ( lambda ( f ) ; one definition\n> ( define ( log-it what )\n> ( printf \"~a\\n\" what ) )\n> ( log-it \"running\" )\n> ( f 0 )\n> ( log-it \"done\" ) )\n> ( lambda ( f n ) ; two definitions\n> ( define ( call n )\n> ( if ( zero? n )\n> ( log-it \"done\" )\n> ( begin\n> ( log-it \"running\" )\n> ( f n )\n> ( call ( - n 1 ) ) ) ) )\n> ( define ( log-it what )\n> ( printf \"~a\\n\" what ) )\n> ( call n ) )\n> ```\nInternal definitions in a particular body sequence are mutually recursive; that is, any definition can refer to any other definition—as long as the reference isn’t actually evaluated before its definition takes place. If a definition is referenced too early, an error occurs.\nExamples:\n> ```racket\n> ( define ( weird ) ( define x x ) x )\n> > ( weird )\n> x: undefined;\n> cannot use before initialization\n> ```\nA sequence of internal definitions using just define is easily translated to an equivalent letrec form (as introduced in the next section). However, other definition forms can appear as a body, including define-values, struct (see Programmer-Defined Datatypes) or define-syntax (see Macros)."}
{"text": "### 4.5 Definitions: [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13)\n> > > Internal Definitions in The Racket Reference documents the fine points of internal definitions.\n------------------------------------------------------------------------"}
{"text": "# 4.6 Local Binding"}
{"text": "### 4.6 Local Binding\nAlthough internal defines can be used for local binding, Racket provides three forms that give the programmer more control over bindings: let, let*, and letrec."}
{"text": "#### 4.6.1 Parallel Binding: let\n> > > Local Binding: let, let*, letrec, ... in The Racket Reference also documents let.\nA let form binds a set of identifiers, each to the result of some expression, for use in the let body:\n> > | |\n> > |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | (let (\\[id expr\\] ...) body ...+) |\nThe ids are bound “in parallel.” That is, no id is bound in the right-hand side expr for any id, but all are available in the body. The ids must be different from each other.\nExamples:\n> ```racket\n> > ( let ( [ me \"Bob\" ] ) me )\n> \"Bob\"\n> > ( let ( [ me \"Bob\" ] [ myself \"Robert\" ] [ I \"Bobby\" ] ) ( list me myself I ) )\n> '(\"Bob\" \"Robert\" \"Bobby\")\n> > ( let ( [ me \"Bob\" ] [ me \"Robert\" ] ) me )\n> eval:3:0: let: duplicate identifier\n> at: me\n> in: (let ((me \"Bob\") (me \"Robert\")) me)\n> ```\nThe fact that an id’s expr does not see its own binding is often useful for wrappers that must refer back to the old value:\n> ```racket\n> > ( let ( [ + ( lambda ( x y ) ( if ( string? x ) ( string-append x y ) ( + x y ) ) ) ] ) ; use original + ( list ( + 1 2 ) ( + \"see\" \"saw\" ) ) )\n> '(3 \"seesaw\")\n> ```\nOccasionally, the parallel nature of let bindings is convenient for swapping or rearranging a set of bindings:"}
{"text": "# 4.6 Local Binding\n> ```racket\n> > ( let ( [ me \"Tarzan\" ] [ you \"Jane\" ] ) ( let ( [ me you ] [ you me ] ) ( list me you ) ) )\n> '(\"Jane\" \"Tarzan\")\n> ```\nThe characterization of let bindings as “parallel” is not meant to imply concurrent evaluation. The exprs are evaluated in order, even though the bindings are delayed until all exprs are evaluated."}
{"text": "#### 4.6.2 Sequential Binding: let*\n> > > Local Binding: let, let*, letrec, ... in The Racket Reference also documents let*.\nThe syntax of let* is the same as let:\n> > | |\n> > |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | (let* (\\[id expr\\] ...) body ...+) |\nThe difference is that each id is available for use in later exprs, as well as in the body. Furthermore, the ids need not be distinct, and the most recent binding is the visible one.\nExamples:\n> ```racket\n> > ( let* ( [ x ( list \"Burroughs\" ) ] [ y ( cons \"Rice\" x ) ] [ z ( cons \"Edgar\" y ) ] ) ( list x y z ) )\n> '((\"Burroughs\") (\"Rice\" \"Burroughs\") (\"Edgar\" \"Rice\" \"Burroughs\"))\n> > ( let* ( [ name ( list \"Burroughs\" ) ] [ name ( cons \"Rice\" name ) ] [ name ( cons \"Edgar\" name ) ] ) name )\n> '(\"Edgar\" \"Rice\" \"Burroughs\")\n> ```\nIn other words, a let* form is equivalent to nested let forms, each with a single binding:\n> ```racket\n> > ( let ( [ name ( list \"Burroughs\" ) ] ) ( let ( [ name ( cons \"Rice\" name ) ] ) ( let ( [ name ( cons \"Edgar\" name ) ] ) name ) ) )\n> '(\"Edgar\" \"Rice\" \"Burroughs\")\n> ```"}
{"text": "#### 4.6.3 Recursive Binding: letrec\n> > > Local Binding: let, let*, letrec, ... in The Racket Reference also documents letrec.\nThe syntax of letrec is also the same as let:\n> > | |\n> > |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | (letrec (\\[id expr\\] ...) body ...+) |\nWhile let makes its bindings available only in the bodys, and let* makes its bindings available to any later binding expr, letrec makes its bindings available to all other exprs—even earlier ones. In other words, letrec bindings are recursive.\nThe exprs in a letrec form are most often lambda forms for recursive and mutually recursive functions:\n> ```racket\n> > ( letrec ( [ swing ( lambda ( t ) ( if ( eq? ( car t ) ' tarzan ) ( cons ' vine ( cons ' tarzan ( cddr t ) ) ) ( cons ( car t ) ( swing ( cdr t ) ) ) ) ) ] ) ( swing ' ( vine tarzan vine vine ) ) )\n> '(vine vine tarzan vine)\n> ```"}
{"text": "# 4.6 Local Binding\n> ```racket\n> > ( letrec ( [ tarzan-near-top-of-tree? ( lambda ( name path depth ) ( or ( equal? name \"tarzan\" ) ( and ( directory-exists? path ) ( tarzan-in-directory? path depth ) ) ) ) ] [ tarzan-in-directory? ( lambda ( dir depth ) ( cond [ ( zero? depth ) #f ] [ else ( ormap ( λ ( elem ) ( tarzan-near-top-of-tree? ( path-element → string elem ) ( build-path dir elem ) ( - depth 1 ) ) ) ( directory-list dir ) ) ] ) ) ] ) ( tarzan-near-top-of-tree? \"tmp\" ( find-system-path ' temp-dir ) 4 ) )\n> #f\n> ```\nWhile the exprs of a letrec form are typically lambda expressions, they can be any expression. The expressions are evaluated in order, and after each value is obtained, it is immediately associated with its corresponding id. If an id is referenced before its value is ready, an error is raised, just as for internal definitions.\n> ```racket\n> > ( letrec ( [ quicksand quicksand ] ) quicksand )\n> quicksand: undefined;\n> cannot use before initialization\n> ```"}
{"text": "#### 4.6.4 Named let\nA named let is an iteration and recursion form. It uses the same syntactic keyword let as for local binding, but an identifier after the let (instead of an immediate open parenthesis) triggers a different parsing.\n> > ```\n(let proc-id ([arg-id init-expr] ...)\n> > body ...+ )```\nA named [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) form is equivalent to\n> ```racket\n> ( ( letrec ( [ proc-id ( lambda ( arg-id ... )\n> body ...+ ) ] )\n> proc-id )\n> init-expr ... )\n> ```\nThat is, a named [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) binds a function identifier that is visible only in the function’s body, and it implicitly calls the function with the values of some initial expressions.\nExamples:\n> ```racket\n> ( define ( duplicate pos lst ) ( let dup ( [ i 0 ] [ lst lst ] ) ( cond [ ( = i pos ) ( cons ( car lst ) lst ) ] [ else ( cons ( car lst ) ( dup ( + i 1 ) ( cdr lst ) ) ) ] ) ) )\n> > ( duplicate 1 ( list \"apple\" \"cheese burger!\" \"banana\" ) )\n> '(\"apple\" \"cheese burger!\" \"cheese burger!\" \"banana\")\n> ```"}
{"text": "#### 4.6.5 Multiple Values: [let-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._let-values%2529%2529&version=8.18.0.13), [let*-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%252A-values%2529%2529&version=8.18.0.13), [letrec-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._letrec-values%2529%2529&version=8.18.0.13)\n> > > [Local Binding: let, let*, letrec, ...](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) also documents multiple-value binding forms."}
{"text": "# 4.6 Local Binding\nIn the same way that [define-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._define-values%2529%2529&version=8.18.0.13) binds multiple results in a definition (see [Multiple Values and define-values](define.html#%28part._multiple-values%29)), [let-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._let-values%2529%2529&version=8.18.0.13), [let*-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%252A-values%2529%2529&version=8.18.0.13), and [letrec-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._letrec-values%2529%2529&version=8.18.0.13) bind multiple results locally.\n> > ```\n(let-values ([(id ...) expr] ...)\n> > body ...+ )\n```\n> > ```\n(let*-values ([(id ...) expr] ...)\n> > body ...+ )```\n\n\n> > ```\n(letrec-values ([(id ...) expr] ...)\n> > body ...+ )\n```"}
{"text": "# 4.6 Local Binding\nEach expr must produce as many values as corresponding ids. The binding rules are the same for the forms without -values forms: the ids of let-values are bound only in the bodys, the ids of let*-valuess are bound in exprs of later clauses, and the ids of letrec-values are bound for all exprs.\nExample:\n> ```racket\n> > ( let-values ( [ ( q r ) ( quotient/remainder 14 3 ) ] ) ( list q r ) )\n> '(4 2)\n> ```\n------------------------------------------------------------------------"}
{"text": "# 4.7 Conditionals"}
{"text": "### 4.7 Conditionals\nMost functions used for branching, such as < and string?, produce either #t or #f. Racket’s branching forms, however, treat any value other than #f as true. We say a true value to mean any value other than #f.\nThis convention for “true value” meshes well with protocols where #f can serve as failure or to indicate that an optional value is not supplied. (Beware of overusing this trick, and remember that an exception is usually a better mechanism to report failure.)\nFor example, the member function serves double duty; it can be used to find the tail of a list that starts with a particular item, or it can be used to simply check whether an item is present in a list:\n> ```racket\n> > ( member \"Groucho\" ' ( \"Harpo\" \"Zeppo\" ) )\n> #f\n> > ( member \"Groucho\" ' ( \"Harpo\" \"Groucho\" \"Zeppo\" ) )\n> '(\"Groucho\" \"Zeppo\")\n> > ( if ( member \"Groucho\" ' ( \"Harpo\" \"Zeppo\" ) ) ' yep ' nope )\n> 'nope\n> > ( if ( member \"Groucho\" ' ( \"Harpo\" \"Groucho\" \"Zeppo\" ) ) ' yep ' nope )\n> 'yep\n> ```"}
{"text": "#### 4.7.1 Simple Branching: if\n> > > Conditionals: if, cond, and, and or in The Racket Reference also documents if.\nIn an if form,\n> > | |\n> > |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | (if test-expr then-expr else-expr) |\nthe test-expr is always evaluated. If it produces any value other than #f, then then-expr is evaluated. Otherwise, else-expr is evaluated.\nAn if form must have both a then-expr and an else-expr; the latter is not optional. To perform (or skip) side-effects based on a test-expr, use when or unless, which we describe later in Sequencing."}
{"text": "#### 4.7.2 Combining Tests: and and or\n> > > Conditionals: if, cond, and, and or in The Racket Reference also documents and and or.\nRacket’s and and or are syntactic forms, rather than functions. Unlike a function, the and and or forms can skip evaluation of later expressions if an earlier one determines the answer.\n> > | |\n> > |--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | (and expr ...) |\nAn and form produces #f if any of its exprs produces #f. Otherwise, it produces the value of its last expr. As a special case, (and) produces #t.\n> > | |\n> > |------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | (or expr ...) |\nThe or form produces #f if all of its exprs produce #f. Otherwise, it produces the first non-#f value from its exprs. As a special case, (or) produces #f.\nExamples:\n> ```racket\n> > ( define ( got-milk? lst ) ( and ( not ( null? lst ) ) ( or ( eq? ' milk ( car lst ) ) ( got-milk? ( cdr lst ) ) ) ) ) ; recurs only if needed\n> > ( got-milk? ' ( apple banana ) )\n> #f\n> > ( got-milk? ' ( apple milk banana ) )\n> #t\n> ```"}
{"text": "# 4.7 Conditionals\nIf evaluation reaches the last expr of an and or or form, then the expr’s value directly determines the and or or result. Therefore, the last expr is in tail position, which means that the above got-milk? function runs in constant space.\n> > > Tail Recursion introduces tail calls and tail positions."}
{"text": "#### 4.7.3 Chaining Tests: cond\nThe cond form chains a series of tests to select a result expression. To a first approximation, the syntax of cond is as follows:\n> > > Conditionals: if, cond, and, and or in The Racket Reference also documents cond.\n> > ```\n(cond [test-expr body ...+]\n> > ... )```\nEach test-expr is evaluated in order. If it produces #f, the corresponding bodys are ignored, and evaluation proceeds to the next test-expr. As soon as a test-expr produces a true value, the associated bodys are evaluated to produce the result for the [cond](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._cond%2529%2529&version=8.18.0.13) form, and no further test-exprs are evaluated."}
{"text": "# 4.7 Conditionals\nThe last test-expr in a [cond](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._cond%2529%2529&version=8.18.0.13) can be replaced by [else](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._else%2529%2529&version=8.18.0.13). In terms of evaluation, [else](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._else%2529%2529&version=8.18.0.13) serves as a synonym for #t, but it clarifies that the last clause is meant to catch all remaining cases. If [else](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._else%2529%2529&version=8.18.0.13) is not used, then it is possible that no test-exprs produce a true value; in that case, the result of the [cond](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=if.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._cond%2529%2529&version=8.18.0.13) expression is [# |
|
|
|
|
|
|
|
|
[Assignment: set! and set!-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) also documents [set!-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._set%2521-values%2529%2529&version=8.18.0.13).\n\nThe [set!-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._set%2521-values%2529%2529&version=8.18.0.13) form assigns to multiple variables at once, given an expression that produces an appropriate number of values:\n\n> > | |\n> > |---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | ([set!-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._set%2521-values%2529%2529&version=8.18.0.13) (id ...) expr) |\n\nThis form is equivalent to using [let-values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._let-values%2529%2529&version=8.18.0.13) to receive multiple results from expr, and then assigning the results individually to the ids using [set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._set%2521%2529%2529&version=8.18.0.13).\n\nExamples:\n\n> ```racket\n> ( define game ( let ( [ w 0 ] [ l 0 ] ) ( lambda ( win? ) ( if win? ( set! w ( + w 1 ) ) ( set! l ( + l 1 ) ) ) ( begin0 ( values w l ) ; swap sides... ( set!-values ( w l ) ( values l w ) ) ) ) ) )\n> > ( game #t )\n> 1 0\n> > ( game #t )\n> 1 1\n> > ( game #f )\n> 1 2\n> ```\n\n------------------------------------------------------------------------\n\n# 4.10 Quoting: quote and '\n\n### 4.10 Quoting: [quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._quote%2529%2529&version=8.18.0.13) and ’\n\n> > > [Literals: quote and #%datum](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) also documents [quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._quote%2529%2529&version=8.18.0.13).\n\nThe [quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._quote%2529%2529&version=8.18.0.13) form produces a constant:\n\n> > | |\n> > |---------------|\n> > | (quote datum) |\n\nThe syntax of a datum is technically specified as anything that the [read](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=Reading.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._read%2529%2529&version=8.18.0.13) function parses as a single element. The value of the [quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._quote%2529%2529&version=8.18.0.13) form is the same value that [read](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=Reading.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._read%2529%2529&version=8.18.0.13) would produce given datum.\n\nThe datum can be a symbol, a boolean, a number, a (character or byte) string, a character, a keyword, an empty list, a pair (or list) containing more such values, a vector containing more such values, a hash table containing more such values, or a box containing another such value.\n\nExamples:\n\n> ```racket\n> > ( quote apple )\n> 'apple\n> > ( quote #t )\n> #t\n> > ( quote 42 )\n> 42\n> > ( quote \"hello\" )\n> \"hello\"\n> > ( quote ( ) )\n> '()\n> > ( quote ( ( 1 2 3 ) # ( \"z\" x ) . the-end ) )\n> '((1 2 3) #(\"z\" x) . the-end)\n> > ( quote ( 1 2 . ( 3 ) ) )\n> '(1 2 3)\n> ```\n\nAs the last example above shows, the datum does not have to match the normalized printed form of a value. A datum cannot be a printed representation that starts with #\\<, so it cannot be [#[Reading Quotes](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=reader.html%23%2528part._parse-quote%2529&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) provides more on the ' shorthand.\n\nExamples:\n\n> ```racket\n> > ' apple\n> 'apple\n> > ' \"hello\"\n> \"hello\"\n> > ' ( 1 2 3 )\n> '(1 2 3)\n> > ( display ' ( you can ' me ) )\n> (you can (quote me))\n> ```\n\n------------------------------------------------------------------------\n\n# 4.11 Quasiquoting: quasiquote and lsquo\n\n### 4.11 Quasiquoting: [quasiquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._quasiquote%2529%2529&version=8.18.0.13) and ‘\n\n> > > [Quasiquoting: quasiquote, unquote, and unquote-splicing](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) also documents [quasiquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._quasiquote%2529%2529&version=8.18.0.13).\n\nThe [quasiquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._quasiquote%2529%2529&version=8.18.0.13) form is similar to [quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._quote%2529%2529&version=8.18.0.13):\n\n> > | |\n> > |---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | ([quasiquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._quasiquote%2529%2529&version=8.18.0.13) datum) |\n\nHowever, for each ([unquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote%2529%2529&version=8.18.0.13) expr) that appears within the datum, the expr is evaluated to produce a value that takes the place of the [unquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote%2529%2529&version=8.18.0.13) sub-form.\n\nExample:\n\n> ```racket\n> > ( quasiquote ( 1 2 ( unquote ( + 1 2 ) ) ( unquote ( - 5 1 ) ) ) )\n> '(1 2 3 4)\n> ```\n\nThis form can be used to write functions that build lists according to certain patterns.\n\nExamples:\n\n> ```racket\n> > ( define ( deep n ) ( cond [ ( zero? n ) 0 ] [ else ( quasiquote ( ( unquote n ) ( unquote ( deep ( - n 1 ) ) ) ) ) ] ) )\n> > ( deep 8 )\n> '(8 (7 (6 (5 (4 (3 (2 (1 0))))))))\n> ```\n\nOr even to cheaply construct expressions programmatically. (Of course, 9 times out of 10, you should be using a [macro](macros.html) to do this (the 10th time being when you’re working through a textbook like [PLAI](https://www.cs.brown.edu/~sk/Publications/Books/ProgLangs/)).)\n\nExamples:\n\n> ```racket\n> > ( define ( build-exp n ) ( add-lets n ( make-sum n ) ) )\n> > ( define ( add-lets n body ) ( cond [ ( zero? n ) body ] [ else ( quasiquote ( let ( [ ( unquote ( n->var n ) ) ( unquote n ) ] ) ( unquote ( add-lets ( - n 1 ) body ) ) ) ) ] ) )\n> > ( define ( make-sum n ) ( cond [ ( = n 1 ) ( n->var 1 ) ] [ else ( quasiquote ( + ( unquote ( n->var n ) ) ( unquote ( make-sum ( - n 1 ) ) ) ) ) ] ) )\n> > ( define ( n->var n ) ( string->symbol ( format \"x~a\" n ) ) )\n> > ( build-exp 3 )\n> '(let ((x3 3)) (let ((x2 2)) (let ((x1 1)) (+ x3 (+ x2 x1)))))\n> ```\n\nThe [unquote-splicing](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote-splicing%2529%2529&version=8.18.0.13) form is similar to [unquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote%2529%2529&version=8.18.0.13), but its expr must produce a list, and the [unquote-splicing](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote-splicing%2529%2529&version=8.18.0.13) form must appear in a context that produces either a list or a vector. As the name suggests, the resulting list is spliced into the context of its use.\n\nExample:\n\n> ```racket\n> > ( quasiquote ( 1 2 ( unquote-splicing ( list ( + 1 2 ) ( - 5 1 ) ) ) 5 ) )\n> '(1 2 3 4 5)\n> ```\n\nUsing splicing we can revise the construction of our example expressions above to have just a single [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) expression and a single [+](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._%252B%2529%2529&version=8.18.0.13) expression.\n\nExamples:\n\n> ```racket\n> > ( define ( build-exp n ) ( add-lets n ( quasiquote ( + ( unquote-splicing ( build-list n ( λ ( x ) ( n->var ( + x 1 ) ) ) ) ) ) ) ) )\n> > ( define ( add-lets n body ) ( quasiquote ( let ( unquote ( build-list n ( λ ( n ) ( quasiquote [ ( unquote ( n->var ( + n 1 ) ) ) ( unquote ( + n 1 ) ) ] ) ) ) ) ( unquote body ) ) ) )\n> > ( define ( n->var n ) ( string->symbol ( format \"x~a\" n ) ) )\n> > ( build-exp 3 )\n> '(let ((x1 1) (x2 2) (x3 3)) (+ x1 x2 x3))\n> ```\n\nIf a [quasiquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._quasiquote%2529%2529&version=8.18.0.13) form appears within an enclosing [quasiquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._quasiquote%2529%2529&version=8.18.0.13) form, then the inner [quasiquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._quasiquote%2529%2529&version=8.18.0.13) effectively cancels one layer of [unquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote%2529%2529&version=8.18.0.13) and [unquote-splicing](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote-splicing%2529%2529&version=8.18.0.13) forms, so that a second [unquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote%2529%2529&version=8.18.0.13) or [unquote-splicing](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote-splicing%2529%2529&version=8.18.0.13) is needed.\n\nExamples:\n\n> ```racket\n> > ( quasiquote ( 1 2 ( quasiquote ( unquote ( + 1 2 ) ) ) ) )\n> '(1 2 (quasiquote (unquote (+ 1 2))))\n> > ( quasiquote ( 1 2 ( quasiquote ( unquote ( unquote ( + 1 2 ) ) ) ) ) )\n> '(1 2 (quasiquote (unquote 3)))\n> > ( quasiquote ( 1 2 ( quasiquote ( ( unquote ( + 1 2 ) ) ( unquote ( unquote ( - 5 1 ) ) ) ) ) ) )\n> '(1 2 (quasiquote ((unquote (+ 1 2)) (unquote 4))))\n> ```\n\nThe evaluations above will not actually print as shown. Instead, the shorthand form of [quasiquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._quasiquote%2529%2529&version=8.18.0.13) and [unquote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote%2529%2529&version=8.18.0.13) will be used: \\` (i.e., a backquote) and , (i.e., a comma). The same shorthands can be used in expressions:\n\nExample:\n\n> ```racket\n> > ` ( 1 2 ` ( , ( + 1 2 ) , , ( - 5 1 ) ) )\n> '(1 2 `(,(+ 1 2) ,4))\n> ```\n\nThe shorthand form of [unquote-splicing](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=quasiquote.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._unquote-splicing%2529%2529&version=8.18.0.13) is ,@:\n\nExample:\n\n> ```racket\n> > ` ( 1 2 ,@ ( list ( + 1 2 ) ( - 5 1 ) ) )\n> '(1 2 3 4)\n> ```\n\n------------------------------------------------------------------------\n\n# 4.12 Simple Dispatch: case\n\n### 4.12 Simple Dispatch: [case](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=case.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._case%2529%2529&version=8.18.0.13)\n\nThe [case](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=case.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._case%2529%2529&version=8.18.0.13) form dispatches to a clause by matching the result of an expression to the values for the clause:\n\n> > ```\n(case expr\n> > [ ( datum ...+ ) body ...+ ]\n> > ... )\n```"}
{"text": "# 4.7 Conditionals\n(parameter)\t→```\n> > > The term “parameter” is sometimes used to refer to the arguments of a function, but “parameter” in Racket has the more specific meaning described here.\nFor example, the [error-print-width](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=exns.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._error-print-width%2529%2529&version=8.18.0.13) parameter controls how many characters of a value are printed in an error message:\n> ```racket\n> > ( parameterize ( [ error-print-width 5 ] ) ( car ( expt 10 1024 ) ) )\n> car: contract violation\n> expected: pair?\n> given: 10...\n> > ( parameterize ( [ error-print-width 10 ] ) ( car ( expt 10 1024 ) ) )\n> car: contract violation\n> expected: pair?\n> given: 1000000...\n> ```\nMore generally, parameters implement a kind of dynamic binding. The [make-parameter](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._make-parameter%2529%2529&version=8.18.0.13) function takes any value and returns a new parameter that is initialized to the given value. Applying the parameter as a function returns its current value:\n> ```racket\n> > ( define location ( make-parameter \"here\" ) )\n> > ( location )\n> \"here\"\n> ```"}
{"text": "# 4.7 Conditionals\nIn a [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) form, each parameter-expr must produce a parameter. During the evaluation of the bodys, each specified parameter is given the result of the corresponding value-expr. When control leaves the [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) form—either through a normal return, an exception, or some other escape—the parameter reverts to its earlier value:\n> ```racket\n> > ( parameterize ( [ location \"there\" ] ) ( location ) )\n> \"there\"\n> > ( location )\n> \"here\"\n> > ( parameterize ( [ location \"in a house\" ] ) ( list ( location ) ( parameterize ( [ location \"with a mouse\" ] ) ( location ) ) ( location ) ) )\n> '(\"in a house\" \"with a mouse\" \"in a house\")\n> > ( parameterize ( [ location \"in a box\" ] ) ( car ( location ) ) )\n> car: contract violation\n> expected: pair?\n> given: \"in a box\"\n> > ( location )\n> \"here\"\n> ```"}
{"text": "# 4.7 Conditionals\nThe [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) form is not a binding form like [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13); each use of location above refers directly to the original definition. A [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) form adjusts the value of a parameter during the whole time that the [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) body is evaluated, even for uses of the parameter that are textually outside of the [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) body:"}
{"text": "# 4.7 Conditionals\n> ```racket\n> > ( define ( would-you-could-you? ) ( and ( not ( equal? ( location ) \"here\" ) ) ( not ( equal? ( location ) \"there\" ) ) ) )\n> > ( would-you-could-you? )\n> #f\n> > ( parameterize ( [ location \"on a bus\" ] ) ( would-you-could-you? ) )\n> #t\n> ```\nIf a use of a parameter is textually inside the body of a [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) but not evaluated before the [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) form produces a value, then the use does not see the value installed by the [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) form:\n> ```racket\n> > ( let ( [ get ( parameterize ( [ location \"with a fox\" ] ) ( lambda ( ) ( location ) ) ) ] ) ( get ) )\n> \"here\"\n> ```"}
{"text": "# 4.7 Conditionals\nThe current binding of a parameter can be adjusted imperatively by calling the parameter as a function with a value. If a [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) has adjusted the value of the parameter, then directly applying the parameter procedure affects only the value associated with the active [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13):\n> ```racket\n> > ( define ( try-again! where ) ( location where ) )\n> > ( location )\n> \"here\"\n> > ( parameterize ( [ location \"on a train\" ] ) ( list ( location ) ( begin ( try-again! \"in a boat\" ) ( location ) ) ) )\n> '(\"on a train\" \"in a boat\")\n> > ( location )\n> \"here\"\n> ```"}
{"text": "# 4.7 Conditionals\nUsing [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) is generally preferable to updating a parameter value imperatively—for much the same reasons that binding a fresh variable with [let](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=let.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fletstx-scheme..rkt%2529._let%2529%2529&version=8.18.0.13) is preferable to using [set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._set%2521%2529%2529&version=8.18.0.13) (see [Assignment: set!](set_.html)).\nIt may seem that variables and [set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._set%2521%2529%2529&version=8.18.0.13) can solve many of the same problems that parameters solve. For example, lokation could be defined as a string, and [set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._set%2521%2529%2529&version=8.18.0.13) could be used to adjust its value:"}
{"text": "# 4.7 Conditionals\n> ```racket\n> > ( define lokation \"here\" )\n> > ( define ( would-ya-could-ya? ) ( and ( not ( equal? lokation \"here\" ) ) ( not ( equal? lokation \"there\" ) ) ) )\n> > ( set! lokation \"on a bus\" )\n> > ( would-ya-could-ya? )\n> #t\n> ```\nParameters, however, offer several crucial advantages over [set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._set%2521%2529%2529&version=8.18.0.13):\n- The [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) form helps automatically reset the value of a parameter when control escapes due to an exception. Adding exception handlers and other forms to rewind a [set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._set%2521%2529%2529&version=8.18.0.13) is relatively tedious."}
{"text": "# 4.7 Conditionals\n- Parameters work nicely with tail calls (see [Tail Recursion](Lists__Iteration__and_Recursion.html#%28part._tail-recursion%29)). The last body in a [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) form is in [tail position](Lists__Iteration__and_Recursion.html#%28tech._tail._position%29) with respect to the [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) form.\n- Parameters work properly with threads (see [Threads](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=threads.html&version=8.18.0.13)). The [parameterize](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=parameters.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmore-scheme..rkt%2529._parameterize%2529%2529&version=8.18.0.13) form adjusts the value of a parameter only for evaluation in the current thread, which avoids race conditions with other threads.\n------------------------------------------------------------------------"}
{"text": "# 5 Programmer-Defined Datatypes"}
{"text": "## 5 Programmer-Defined Datatypes\n> > > [Structures](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=structures.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) also documents structure types.\nNew datatypes are normally created with the [struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13) form, which is the topic of this chapter. The class-based object system, which we defer to [Classes and Objects](classes.html), offers an alternate mechanism for creating new datatypes, but even classes and objects are implemented in terms of structure types."}
{"text": "### 5.1 Simple Structure Types: [struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13)\n> > > [Defining Structure Types: struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) also documents [struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13).\nTo a first approximation, the syntax of [struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13) is"}
{"text": "### 5.1 Simple Structure Types: [struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13)\n> > | |\n> > |--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > | ([struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13) struct-id (field-id ...)) |\nExamples:\n> ([struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13) posn (x y))"}
{"text": "### 5.1 Simple Structure Types: [struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13)\nThe [struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13) form binds struct-id and a number of identifiers that are built from struct-id and the field-ids:\n- struct-id : a constructor function that takes as many arguments as the number of field-ids, and returns an instance of the structure type.\n Example:\n > ```racket\n > > ( posn 1 2 )\n > # |
|
|
| ([struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13) glass (width height) #:transparent) |
|
|
| ([struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._struct%2529%2529&version=8.18.0.13) lead (width height)) |
|
|
| ([planet](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._planet%2529%2529&version=8.18.0.13) rel-string (user-string pkg-string vers ...)) | |||||||||||||||||||||||||
|
| ([submod](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._submod%2529%2529&version=8.18.0.13) base element ...+) | ||||||||||||||||||||||||||||||
|
| ([only-in](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._only-in%2529%2529&version=8.18.0.13) require-spec id-maybe-renamed ...) | ||||||||||
|
See [Programmer-Defined Datatypes](define-struct.html) for information on [define-struct](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define-struct.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define-struct%2529%2529&version=8.18.0.13).\n\n> > > | |\n> > > |-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > > | ([all-defined-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._all-defined-out%2529%2529&version=8.18.0.13)) |\n> >\n> > The [all-defined-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._all-defined-out%2529%2529&version=8.18.0.13) shorthand exports all bindings that are defined within the exporting module (as opposed to imported).\n> >\n> > Use of the [all-defined-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._all-defined-out%2529%2529&version=8.18.0.13) shorthand is generally discouraged, because it makes less clear the actual exports for a module, and because Racket programmers get into the habit of thinking that definitions can be added freely to a module without affecting its public interface (which is not the case when [all-defined-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._all-defined-out%2529%2529&version=8.18.0.13) is used).\n\n> > > | |\n> > > |-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > > | ([all-from-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._all-from-out%2529%2529&version=8.18.0.13) module-path) |\n> >\n> > The [all-from-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._all-from-out%2529%2529&version=8.18.0.13) shorthand exports all bindings in the module that were imported using a require-spec that is based on module-path.\n> >\n> > Although different module-paths could refer to the same file-based module, re-exporting with [all-from-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._all-from-out%2529%2529&version=8.18.0.13) is based specifically on the module-path reference, and not the module that is actually referenced.\n\n> > > | |\n> > > |-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > > | ([except-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._except-out%2529%2529&version=8.18.0.13) provide-spec id ...) |\n> >\n> > Like provide-spec, but omitting the export of each id, where id is the external name of the binding to omit.\n\n> > > | |\n> > > |--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n> > > | ([prefix-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._prefix-out%2529%2529&version=8.18.0.13) prefix-id provide-spec) |\n> >\n> > Like provide-spec, but adding prefix-id to the beginning of the external name for each exported binding.\n\n------------------------------------------------------------------------\n\n# 6.6 Assignment and Redefinition\n\n### 6.6 Assignment and Redefinition\n\nThe use of [set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._set%2521%2529%2529&version=8.18.0.13) on variables defined within a module is limited to the body of the defining module. That is, a module is allowed to change the value of its own definitions, and such changes are visible to importing modules. However, an importing context is not allowed to change the value of an imported binding.\n\nExamples:\n\n> ```racket\n> > ( module m racket ( provide counter increment! ) ( define counter 0 ) ( define ( increment! ) ( set! counter ( add1 counter ) ) ) )\n> > ( require ' m )\n> > counter\n> 0\n> > ( increment! )\n> > counter\n> 1\n> > ( set! counter -1 )\n> set!: cannot mutate module-required identifier\n> at: counter\n> in: (set! counter -1)\n> ```\n\nAs the above example illustrates, a module can always grant others the ability to change its exports by providing a mutator function, such as increment!.\n\nThe prohibition on assignment of imported variables helps support modular reasoning about programs. For example, in the module,\n\n> ```racket\n> ( module m racket\n> ( provide rx:fish fishy-string? )\n> ( define rx:fish #rx\"fish\" )\n> ( define ( fishy-string? s )\n> ( regexp-match? rx:fish s ) ) )\n> ```\n\nthe function fishy-string? will always match strings that contain “fish”, no matter how other modules use the rx:fish binding. For essentially the same reason that it helps programmers, the prohibition on assignment to imports also allows many programs to be executed more efficiently.\n\nAlong the same lines, when a module contains no [set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._set%2521%2529%2529&version=8.18.0.13) of a particular identifier that is defined within the module, then the identifier is considered a constant that cannot be changed—not even by re-declaring the module.\n\nConsequently, re-declaration of a module is not generally allowed. For file-based modules, simply changing the file does not lead to a re-declaration in any case, because file-based modules are loaded on demand, and the previously loaded declarations satisfy future requests. It is possible to use Racket’s reflection support to re-declare a module, however, and non-file modules can be re-declared in the [REPL](intro.html#%28tech._repl%29); in such cases, the re-declaration may fail if it involves the re-definition of a previously constant binding.\n\n> ```racket\n> > ( module m racket ( define pie 3.141597 ) )\n> > ( require ' m )\n> > ( module m racket ( define pie 3 ) )\n> define-values: assignment disallowed;\n> cannot re-define a constant\n> constant: pie\n> in module:'m\n> ```\n\nFor exploration and debugging purposes, the Racket reflective layer provides a [compile-enforce-module-constants](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=eval.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._compile-enforce-module-constants%2529%2529&version=8.18.0.13) parameter to disable the enforcement of constants.\n\n> ```racket\n> > ( compile-enforce-module-constants #f )\n> > ( module m2 racket ( provide pie ) ( define pie 3.141597 ) )\n> > ( require ' m2 )\n> > ( module m2 racket ( provide pie ) ( define pie 3 ) )\n> > ( compile-enforce-module-constants #t )\n> > pie\n> 3\n> ```\n\n------------------------------------------------------------------------\n\n# 6.7 Modules and Macros\n\n### 6.7 Modules and Macros\n\nRacket’s module system cooperates closely with Racket’s [macro](macros.html#%28tech._macro%29) system for adding new syntactic forms to Racket. For example, in the same way that importing [racket/base](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) introduces syntax for [require](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._require%2529%2529&version=8.18.0.13) and [lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13), importing other modules can introduce new syntactic forms (in addition to more traditional kinds of imports, such as functions or constants).\n\nWe introduce macros in more detail later, in [Macros](macros.html), but here’s a simple example of a module that defines a pattern-based macro:\n\n> ```racket\n> ( module noisy racket\n> ( provide define-noisy )\n> ( define-syntax-rule ( define-noisy ( id arg ... ) body )\n> ( define ( id arg ... )\n> ( show-arguments ' id ( list arg ... ) )\n> body ) )\n> ( define ( show-arguments name args )\n> ( printf \"calling ~s with arguments ~e\" name args ) ) )\n> ```\n\nThe define-noisy binding provided by this module is a [macro](macros.html#%28tech._macro%29) that acts like [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) for a function, but it causes each call to the function to print the arguments that are provided to the function:\n\n> ```racket\n> > ( require ' noisy )\n> > ( define-noisy ( f x y ) ( + x y ) )\n> > ( f 1 2 )\n> calling f with arguments '(1 2)\n> 3\n> ```\n\nRoughly, the define-noisy form works by replacing\n\n> ```racket\n> ( define-noisy ( f x y )\n> ( + x y ) )\n> ```\n\nwith\n\n> ```racket\n> ( define ( f x y )\n> ( show-arguments ' f ( list x y ) )\n> ( + x y ) )\n> ```\n\nSince show-arguments isn’t provided by the noisy module, however, this literal textual replacement is not quite right. The actual replacement correctly tracks the origin of identifiers like show-arguments, so they can refer to other definitions in the place where the macro is defined—even if those identifiers are not available at the place where the macro is used.\n\nThere’s more to the macro and module interaction than identifier binding. The [define-syntax-rule](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=stx-patterns.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fmisc..rkt%2529._define-syntax-rule%2529%2529&version=8.18.0.13) form is itself a macro, and it expands to compile-time code that implements the transformation from define-noisy into [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13). The module system keeps track of which code needs to run at compile and which needs to run normally, as explained more in [Compile and Run-Time Phases](stx-phases.html) and [Module Instantiations and Visits](macro-module.html).\n\n------------------------------------------------------------------------\n\n# 6.8 Protected Exports\n\n### 6.8 Protected Exports\n\nSometimes, a module needs to export bindings to other modules that are at the same trust level as the exporting module, while at the same time preventing access from untrusted modules. Such exports should use the [protect-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._protect-out%2529%2529&version=8.18.0.13) form in [provide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._provide%2529%2529&version=8.18.0.13). For example, [ffi/unsafe](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=foreign&rel=index.html&version=8.18.0.13) exports all of its unsafe bindings as protected in this sense.\n\nLevels of trust are implemented with [code inspectors](code-inspectors_protect.html#%28tech._code._inspector%29) (see [Code Inspectors for Trusted and Untrusted Code](code-inspectors_protect.html)). Only modules loaded with an equally strong code inspector as an exporting module can use protected bindings from the exporting module. Operations like [dynamic-require](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=Module_Names_and_Loading.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._dynamic-require%2529%2529&version=8.18.0.13) are granted access depending on the current code inspector as determined by [current-code-inspector](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=modprotect.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._current-code-inspector%2529%2529&version=8.18.0.13).\n\nWhen a module re-exports a protected binding, it does not need to use [protect-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._protect-out%2529%2529&version=8.18.0.13) again. Access is always determined by the code inspector of the module that originally defines a protected binding. When using a protected binding within a module, take care to either provide new bindings from the module with [protect-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._protect-out%2529%2529&version=8.18.0.13) or ensure that no provided bindings expose functionality that was meant to be protected in the first place.\n\n------------------------------------------------------------------------\n\n# 7 Contracts\n\n## 7 Contracts\n\nThis chapter provides a gentle introduction to Racket’s contract system.\n\n> > > [Contracts](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=contracts.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) provides more on contracts.\n\n| |\n|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [7.1 Contracts and Boundaries](contract-boundaries.html) |\n| [7.1.1 Contract Violations](contract-boundaries.html#%28part._contracts-amount0%29) |\n| [7.1.2 Experimenting with Contracts and Modules](contract-boundaries.html#%28part._.Experimenting_with_.Contracts_and_.Modules%29) |\n| [7.1.3 Experimenting with Nested Contract Boundaries](contract-boundaries.html#%28part._contracts-intro-nested%29) |\n| [7.2 Simple Contracts on Functions](contract-func.html) |\n| [7.2.1 Styles of ->](contract-func.html#%28part._.Styles_of_-_%29) |\n| [7.2.2 Using define/contract and ->](contract-func.html#%28part._simple-nested%29) |\n| [7.2.3 any and any/c](contract-func.html#%28part._any_and_any_c%29) |\n| [7.2.4 Rolling Your Own Contracts](contract-func.html#%28part._contracts-own%29) |\n| [7.2.5 Contracts on Higher-order Functions](contract-func.html#%28part._.Contracts_on_.Higher-order_.Functions%29) |\n| [7.2.6 Contract Messages with “???”](contract-func.html#%28part._contracts-flat-named-contracts%29) |\n| [7.2.7 Dissecting a contract error message](contract-func.html#%28part._contracts-dissecting-contract-errors%29) |\n| [7.3 Contracts on Functions in General](contracts-general-functions.html) |\n| [7.3.1 Optional Arguments](contracts-general-functions.html#%28part._contracts-optional%29) |\n| [7.3.2 Rest Arguments](contracts-general-functions.html#%28part._contracts-rest-args%29) |\n| [7.3.3 Keyword Arguments](contracts-general-functions.html#%28part._contracts-keywords%29) |\n| [7.3.4 Optional Keyword Arguments](contracts-general-functions.html#%28part._contracts-optional-keywords%29) |\n| [7.3.5 Contracts for case-lambda](contracts-general-functions.html#%28part._contracts-case-lambda%29) |\n| [7.3.6 Argument and Result Dependencies](contracts-general-functions.html#%28part._contracts-arrow-d%29) |\n| [7.3.7 Checking State Changes](contracts-general-functions.html#%28part._contracts-arrow-d-eval-order%29) |\n| [7.3.8 Multiple Result Values](contracts-general-functions.html#%28part._contracts-multiple%29) |\n| [7.3.9 Fixed but Statically Unknown Arities](contracts-general-functions.html#%28part._contracts-no-domain%29) |\n| [7.4 Contracts: A Thorough Example](contracts-first.html) |\n| [7.5 Contracts on Structures](contracts-struct.html) |\n| [7.5.1 Guarantees for a Specific Value](contracts-struct.html#%28part._contracts-single-struct%29) |\n| [7.5.2 Guarantees for All Values](contracts-struct.html#%28part._contracts-define-struct%29) |\n| [7.5.3 Checking Properties of Data Structures](contracts-struct.html#%28part._contracts-lazy-contracts%29) |\n| [7.6 Abstract Contracts using #:exists and #:∃](contracts-exists.html) |\n| [7.7 Additional Examples](contracts-examples.html) |\n| [7.7.1 A Customer-Manager Component](contracts-examples.html#%28part._.A_.Customer-.Manager_.Component%29) |\n| [7.7.2 A Parameteric (Simple) Stack](contracts-examples.html#%28part._.A_.Parameteric__.Simple__.Stack%29) |\n| [7.7.3 A Dictionary](contracts-examples.html#%28part._.A_.Dictionary%29) |\n| [7.7.4 A Queue](contracts-examples.html#%28part._.A_.Queue%29) |\n| [7.8 Building New Contracts](Building_New_Contracts.html) |\n| [7.8.1 Contract Struct Properties](Building_New_Contracts.html#%28part._.Contract_.Struct_.Properties%29) |\n| [7.8.2 With all the Bells and Whistles](Building_New_Contracts.html#%28part._.With_all_the_.Bells_and_.Whistles%29) |\n| [7.9 Gotchas](contracts-gotchas.html) |\n| [7.9.1 Contracts and eq?](contracts-gotchas.html#%28part._.Contracts_and_eq_%29) |\n| [7.9.2 Contract boundaries and define/contract](contracts-gotchas.html#%28part._contracts-gotcha-nested%29) |\n| [7.9.3 Exists Contracts and Predicates](contracts-gotchas.html#%28part._contracts-exists-gotcha%29) |\n| [7.9.4 Defining Recursive Contracts](contracts-gotchas.html#%28part._.Defining_.Recursive_.Contracts%29) |\n| [7.9.5 Mixing set! and contract-out](contracts-gotchas.html#%28part._.Mixing_set__and_contract-out%29) |\n\n------------------------------------------------------------------------\n\n# 7.1 Contracts and Boundaries\n\n### 7.1 Contracts and Boundaries\n\nLike a contract between two business partners, a software contract is an agreement between two parties. The agreement specifies obligations and guarantees for each “product” (or value) that is handed from one party to the other.\n\nA contract thus establishes a boundary between the two parties. Whenever a value crosses this boundary, the contract monitoring system performs contract checks, making sure the partners abide by the established contract.\n\nIn this spirit, Racket encourages contracts mainly at module boundaries. Specifically, programmers may attach contracts to [provide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._provide%2529%2529&version=8.18.0.13) clauses and thus impose constraints and promises on the use of exported values. For example, the export specification\n\n> ```racket\n> #lang racket\n> ( provide ( contract-out [ amount positive? ] ) )\n> ( define amount ... )\n> ```\n\npromises to all clients of the above module that the value of amount will always be a positive number. The contract system monitors the module’s obligation carefully. Every time a client refers to amount, the monitor checks that the value of amount is indeed a positive number.\n\nThe contracts library is built into the Racket language, but if you wish to use racket/base, you can explicitly require the contracts library like this:\n\n> ```racket\n> #lang racket/base\n> ( require racket/contract ) ; now we can write contracts\n> ( provide ( contract-out [ amount positive? ] ) )\n> ( define amount ... )\n> ```\n\n#### 7.1.1 Contract Violations\n\nIf we bind amount to a number that is not positive,\n\n> ```racket\n> #lang racket\n> ( provide ( contract-out [ amount positive? ] ) )\n> ( define amount 0 )\n> ```\n\nthen, when the module is required, the monitoring system signals a violation of the contract and blames the module for breaking its promises.\n\nAn even bigger mistake would be to bind amount to a non-number value:\n\n> ```racket\n> #lang racket\n> ( provide ( contract-out [ amount positive? ] ) )\n> ( define amount ' amount )\n> ```\n\nIn this case, the monitoring system will apply [positive?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._positive%7E3f%2529%2529&version=8.18.0.13) to a symbol, but [positive?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._positive%7E3f%2529%2529&version=8.18.0.13) reports an error, because its domain is only numbers. To make the contract capture our intentions for all Racket values, we can ensure that the value is both a number and is positive, combining the two contracts with [and/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._and%252Fc%2529%2529&version=8.18.0.13):\n\n> ([provide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._provide%2529%2529&version=8.18.0.13) ([contract-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._contract-out%2529%2529&version=8.18.0.13) \\[amount ([and/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._and%252Fc%2529%2529&version=8.18.0.13) [number?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._number%7E3f%2529%2529&version=8.18.0.13) [positive?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._positive%7E3f%2529%2529&version=8.18.0.13))\\]))\n\n#### 7.1.2 Experimenting with Contracts and Modules\n\nAll of the contracts and modules in this chapter (excluding those just following) are written using the standard #lang syntax for describing modules. Since modules serve as the boundary between parties in a contract, examples involve multiple modules.\n\nTo experiment with multiple modules within a single module or within DrRacket’s [definitions area](intro.html#%28tech._definitions._area%29), use Racket’s submodules. For example, try the example earlier in this section like this:\n\n> ```racket\n> #lang racket\n> ( module+ server\n> ( provide ( contract-out [ amount ( and/c number? positive? ) ] ) )\n> ( define amount 150 ) )\n> ( module+ main\n> ( require ( submod \"..\" server ) )\n> ( + amount 10 ) )\n> ```\n\nEach of the modules and their contracts are wrapped in parentheses with the [module+](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=module.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._module%252B%2529%2529&version=8.18.0.13) keyword at the front. The first form after [module](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=module.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._module%2529%2529&version=8.18.0.13) is the name of the module to be used in a subsequent [require](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._require%2529%2529&version=8.18.0.13) statement (where each reference through a [require](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._require%2529%2529&version=8.18.0.13) prefixes the name with \"..\").\n\n#### 7.1.3 Experimenting with Nested Contract Boundaries\n\nIn many cases, it makes sense to attach contracts at module boundaries. It is often convenient, however, to be able to use contracts at a finer granularity than modules. The [define/contract](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fregion..rkt%2529._define%252Fcontract%2529%2529&version=8.18.0.13) form enables this kind of use:\n\n> ```racket\n> #lang racket\n> ( define/contract amount\n> ( and/c number? positive? )\n> 150 )\n> ( + amount 10 )\n> ```\n\nIn this example, the [define/contract](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fregion..rkt%2529._define%252Fcontract%2529%2529&version=8.18.0.13) form establishes a contract boundary between the definition of amount and its surrounding context. In other words, the two parties here are the definition and the module that contains it.\n\nForms that create these nested contract boundaries can sometimes be subtle to use because they may have unexpected performance implications or blame a party that may seem unintuitive. These subtleties are explained in [Using define/contract and ->](contract-func.html#%28part._simple-nested%29) and [Contract boundaries and define/contract](contracts-gotchas.html#%28part._contracts-gotcha-nested%29).\n\n------------------------------------------------------------------------\n\n# 7.2 Simple Contracts on Functions\n\n### 7.2 Simple Contracts on Functions\n\nA mathematical function has a domain and a range. The domain indicates the kind of values that the function can accept as arguments, and the range indicates the kind of values that it produces. The conventional notation for describing a function with its domain and range is\n\n> f : A [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) B\n\nwhere A is the domain of the function and B is the range.\n\nFunctions in a programming language have domains and ranges, too, and a contract can ensure that a function receives only values in its domain and produces only values in its range. A [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) creates such a contract for a function. The forms after a [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) specify contracts for the domains and finally a contract for the range.\n\nHere is a module that might represent a bank account:\n\n> ```racket\n> #lang racket\n> ( provide ( contract-out\n> [ deposit ( -> number? any ) ]\n> [ balance ( -> number? ) ] ) )\n> ( define amount 0 )\n> ( define ( deposit a ) ( set! amount ( + amount a ) ) )\n> ( define ( balance ) amount )\n> ```\n\nThe module exports two functions:\n\n- deposit, which accepts a number and returns some value that is not specified in the contract, and\n\n- balance, which returns a number indicating the current balance of the account.\n\nWhen a module exports a function, it establishes two channels of communication between itself as a “server” and the “client” module that imports the function. If the client module calls the function, it sends a value into the server module. Conversely, if such a function call ends and the function returns a value, the server module sends a value back to the client module. This client–server distinction is important, because when something goes wrong, one or the other of the parties is to blame.\n\nIf a client module were to apply deposit to 'millions, it would violate the contract. The contract-monitoring system would catch this violation and blame the client for breaking the contract with the above module. In contrast, if the balance function were to return 'broke, the contract-monitoring system would blame the server module.\n\nA [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) by itself is not a contract; it is a contract combinator, which combines other contracts to form a contract.\n\n#### 7.2.1 Styles of [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13)\n\nIf you are used to mathematical functions, you may prefer a contract arrow to appear between the domain and the range of a function, not at the beginning. If you have read [How to Design Programs](https://htdp.org), you have seen this many times. Indeed, you may have seen contracts such as these in other people’s code:\n\n> ```racket\n> ( provide ( contract-out\n> [ deposit ( number? . -> . any ) ] ) )\n> ```\n\nIf a Racket S-expression contains two dots with a symbol in the middle, the reader re-arranges the S-expression and place the symbol at the front, as described in [Lists and Racket Syntax](Pairs__Lists__and_Racket_Syntax.html#%28part._lists-and-syntax%29). Thus,\n\n> ([number?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._number%7E3f%2529%2529&version=8.18.0.13) . [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) . [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13))\n\nis just another way of writing\n\n> ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [number?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._number%7E3f%2529%2529&version=8.18.0.13) [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13))\n\n#### 7.2.2 Using [define/contract](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fregion..rkt%2529._define%252Fcontract%2529%2529&version=8.18.0.13) and [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13)\n\nThe [define/contract](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fregion..rkt%2529._define%252Fcontract%2529%2529&version=8.18.0.13) form introduced in [Experimenting with Nested Contract Boundaries](contract-boundaries.html#%28part._contracts-intro-nested%29) can also be used to define functions that come with a contract. For example,\n\n> ```racket\n> ( define/contract ( deposit amount )\n> ( -> number? any )\n> ; implementation goes here\n> .... )\n> ```\n\nwhich defines the deposit function with the contract from earlier. Note that this has two potentially important impacts on the use of deposit:\n\n1. The contract will be checked on any call to deposit that is outside of the definition of deposit – even those inside the module in which it is defined. Because there may be many calls inside the module, this checking may cause the contract to be checked too often, which could lead to a performance degradation. This is especially true if the function is called repeatedly from a loop.\n\n2. In some situations, a function may be written to accept a more lax set of inputs when called by other code in the same module. For such use cases, the contract boundary established by [define/contract](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fregion..rkt%2529._define%252Fcontract%2529%2529&version=8.18.0.13) is too strict.\n\n#### 7.2.3 [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13) and [any/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%252Fc%2529%2529&version=8.18.0.13)\n\nThe [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13) contract used for deposit matches any kind of result, and it can only be used in the range position of a function contract. Instead of [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13) above, we could use the more specific contract [void?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=void.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._void%7E3f%2529%2529&version=8.18.0.13), which says that the function will always return the ([void](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=void.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._void%2529%2529&version=8.18.0.13)) value. The [void?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=void.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._void%7E3f%2529%2529&version=8.18.0.13) contract, however, would require the contract monitoring system to check the return value every time the function is called, even though the “client” module can’t do much with the value. In contrast, [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13) tells the monitoring system not to check the return value, it tells a potential client that the “server” module makes no promises at all about the function’s return value, even whether it is a single value or multiple values.\n\nThe [any/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%252Fc%2529%2529&version=8.18.0.13) contract is similar to [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13), in that it makes no demands on a value. Unlike [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13), [any/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%252Fc%2529%2529&version=8.18.0.13) indicates a single value, and it is suitable for use as an argument contract. Using [any/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%252Fc%2529%2529&version=8.18.0.13) as a range contract imposes a check that the function produces a single value. That is,\n\n> ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13) [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13))\n\ndescribes a function that accepts an integer and returns any number of values, while\n\n> ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13) [any/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%252Fc%2529%2529&version=8.18.0.13))\n\ndescribes a function that accepts an integer and produces a single result (but does not say anything more about the result). The function\n\n> ([define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) (f x) ([values](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=values.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._values%2529%2529&version=8.18.0.13) ([+](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._%252B%2529%2529&version=8.18.0.13) x 1) ([-](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._-%2529%2529&version=8.18.0.13) x 1)))\n\nmatches ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13) [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13)), but not ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13) [any/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%252Fc%2529%2529&version=8.18.0.13)).\n\nUse [any/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%252Fc%2529%2529&version=8.18.0.13) as a result contract when it is particularly important to promise a single result from a function. Use [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13) when you want to promise as little as possible (and incur as little checking as possible) for a function’s result.\n\n#### 7.2.4 Rolling Your Own Contracts\n\nThe deposit function adds the given number to the value of amount. While the function’s contract prevents clients from applying it to non-numbers, the contract still allows them to apply the function to complex numbers, negative numbers, or inexact numbers, none of which sensibly represent amounts of money.\n\nThe contract system allows programmers to define their own contracts as functions:\n\n> ```racket\n> #lang racket\n> ( define ( amount? a )\n> ( and ( number? a ) ( integer? a ) ( exact? a ) ( >= a 0 ) ) )\n> ( provide ( contract-out\n> ; an amount is a natural number of cents\n> ; is the given number an amount?\n> [ deposit ( -> amount? any ) ]\n> [ amount? ( -> any/c boolean? ) ]\n> [ balance ( -> amount? ) ] ) )\n> ( define amount 0 )\n> ( define ( deposit a ) ( set! amount ( + amount a ) ) )\n> ( define ( balance ) amount )\n> ```\n\nThis module defines an amount? function and uses it as a contract within [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) contracts. When a client calls the deposit function as exported with the contract ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) amount? [any](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%2529%2529&version=8.18.0.13)), it must supply an exact, nonnegative integer, otherwise the amount? function applied to the argument will return #f, which will cause the contract-monitoring system to blame the client. Similarly, the server module must provide an exact, nonnegative integer as the result of balance to remain blameless.\n\nOf course, it makes no sense to restrict a channel of communication to values that the client doesn’t understand. Therefore the module also exports the amount? predicate itself, with a contract saying that it accepts an arbitrary value and returns a boolean.\n\nIn this case, we could also have used [natural-number/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._natural-number%252Fc%2529%2529&version=8.18.0.13) in place of amount?, since it implies exactly the same check:\n\n> ```racket\n> ( provide ( contract-out\n> [ deposit ( -> natural-number/c any ) ]\n> [ balance ( -> natural-number/c ) ] ) )\n> ```\n\nEvery function that accepts one argument can be treated as a predicate and thus used as a contract. For combining existing checks into a new one, however, contract combinators such as [and/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._and%252Fc%2529%2529&version=8.18.0.13) and [or/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._or%252Fc%2529%2529&version=8.18.0.13) are often useful. For example, here is yet another way to write the contracts above:\n\n> ```racket\n> ( define amount/c\n> ( and/c number? integer? exact? ( or/c positive? zero? ) ) )\n> ( provide ( contract-out\n> [ deposit ( -> amount/c any ) ]\n> [ balance ( -> amount/c ) ] ) )\n> ```\n\nOther values also serve double duty as contracts. For example, if a function accepts a number or #f, ([or/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._or%252Fc%2529%2529&version=8.18.0.13) [number?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._number%7E3f%2529%2529&version=8.18.0.13) #f) suffices. Similarly, the amount/c contract could have been written with a 0 in place of [zero?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._zero%7E3f%2529%2529&version=8.18.0.13). If you use a regular expression as a contract, the contract accepts strings and byte strings that match the regular expression.\n\nNaturally, you can mix your own contract-implementing functions with combinators like [and/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._and%252Fc%2529%2529&version=8.18.0.13). Here is a module for creating strings from banking records:\n\n> ```racket\n> #lang racket\n> ( define ( has-decimal? str )\n> ( define L ( string-length str ) )\n> ( and ( >= L 3 )\n> ( char=? #\\. ( string-ref str ( - L 3 ) ) ) ) )\n> ( provide ( contract-out\n> ; convert a random number to a string\n> [ format-number ( -> number? string? ) ]\n> ; convert an amount into a string with a decimal\n> ; point, as in an amount of US currency\n> [ format-nat ( -> natural-number/c\n> ( and/c string? has-decimal? ) ) ] ) )\n> ```\n\nThe contract of the exported function format-number specifies that the function consumes a number and produces a string. The contract of the exported function format-nat is more interesting than the one of format-number. It consumes only natural numbers. Its range contract promises a string that has a . in the third position from the right.\n\nIf we want to strengthen the promise of the range contract for format-nat so that it admits only strings with digits and a single dot, we could write it like this:\n\n> ```racket\n> #lang racket\n> ( define ( digit-char? x )\n> ( member x ' ( #\\1 #\\2 #\\3 #\\4 #\\5 #\\6 #\\7 #\\8 #\\9 #\\0 ) ) )\n> ( define ( has-decimal? str )\n> ( define L ( string-length str ) )\n> ( and ( >= L 3 )\n> ( char=? #\\. ( string-ref str ( - L 3 ) ) ) ) )\n> ( define ( is-decimal-string? str )\n> ( define L ( string-length str ) )\n> ( and ( has-decimal? str )\n> ( andmap digit-char?\n> ( string->list ( substring str 0 ( - L 3 ) ) ) )\n> ( andmap digit-char?\n> ( string->list ( substring str ( - L 2 ) L ) ) ) ) )\n> ....\n> ( provide ( contract-out\n> ....\n> ; convert an amount (natural number) of cents\n> ; into a dollar-based string\n> [ format-nat ( -> natural-number/c\n> ( and/c string?\n> is-decimal-string? ) ) ] ) )\n> ```\n\nAlternately, in this case, we could use a regular expression as a contract:\n\n> ```racket\n> #lang racket\n> ( provide\n> ( contract-out\n> ....\n> ; convert an amount (natural number) of cents\n> ; into a dollar-based string\n> [ format-nat ( -> natural-number/c\n> ( and/c string? #rx\"[0-9]*\\\\.[0-9][0-9]\" ) ) ] ) )\n> ```\n\n#### 7.2.5 Contracts on Higher-order Functions\n\nFunction contracts are not just restricted to having simple predicates on their domains or ranges. Any of the contract combinators discussed here, including function contracts themselves, can be used as contracts on the arguments and results of a function.\n\nFor example,\n\n> ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13) ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13)))\n\nis a contract that describes a curried function. It matches functions that accept one argument and then return another function accepting a second argument before finally returning an integer. If a server exports a function make-adder with this contract, and if make-adder returns a value other than a function, then the server is to blame. If make-adder does return a function, but the resulting function is applied to a value other than an integer, then the client is to blame.\n\nSimilarly, the contract\n\n> ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13)) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13))\n\ndescribes functions that accept other functions as its input. If a server exports a function twice with this contract and the twice is applied to a value other than a function of one argument, then the client is to blame. If twice is applied to a function of one argument and twice calls the given function on a value other than an integer, then the server is to blame.\n\n#### 7.2.6 Contract Messages with “???”\n\nYou wrote your module. You added contracts. You put them into the interface so that client programmers have all the information from interfaces. It’s a piece of art:\n\n> ```racket\n> > ( module bank-server racket ( provide ( contract-out [ deposit ( -> ( λ ( x ) ( and ( number? x ) ( integer? x ) ( >= x 0 ) ) ) any ) ] ) ) ( define total 0 ) ( define ( deposit a ) ( set! total ( + a total ) ) ) )\n> ```\n\nSeveral clients used your module. Others used their modules in turn. And all of a sudden one of them sees this error message:\n\n> ```racket\n> > ( require ' bank-server )\n> > ( deposit -1 0 )\n> deposit: contract violation\n> expected: ???\n> given: -10\n> in: the 1st argument of\n> (-> ??? any)\n> contract from: bank-server\n> blaming: top-level\n> (assuming the contract is correct)\n> at: eval:2:0\n> ```\n\nWhat is the ??? doing there? Wouldn’t it be nice if we had a name for this class of data much like we have string, number, and so on?\n\nFor this situation, Racket provides flat named contracts. The use of “contract” in this term shows that contracts are first-class values. The “flat” means that the collection of data is a subset of the built-in atomic classes of data; they are described by a predicate that consumes all Racket values and produces a boolean. The “named” part says what we want to do, which is to name the contract so that error messages become intelligible:\n\n> ```racket\n> > ( module improved-bank-server racket ( provide ( contract-out [ deposit ( -> ( flat-named-contract ' amount ( λ ( x ) ( and ( number? x ) ( integer? x ) ( >= x 0 ) ) ) ) any ) ] ) ) ( define total 0 ) ( define ( deposit a ) ( set! total ( + a total ) ) ) )\n> ```\n\nWith this little change, the error message becomes quite readable:\n\n> ```racket\n> > ( require ' improved-bank-server )\n> > ( deposit -1 0 )\n> deposit: contract violation\n> expected: amount\n> given: -10\n> in: the 1st argument of\n> (-> amount any)\n> contract from: improved-bank-server\n> blaming: top-level\n> (assuming the contract is correct)\n> at: eval:5:0\n> ```\n\n#### 7.2.7 Dissecting a contract error message\n\nIn general, each contract error message consists of six sections:\n\n- \n\n a name for the function or method associated with the contract and either the phrase “contract violation” or “broke its contract” depending on whether the contract was violated by the client or the server; e.g. in the previous example:\n\n \n\n \n\n | |\n |-----------------------------|\n | deposit: contract violation |\n\n \n\n- \n\n a description of the precise aspect of the contract that was violated,\n\n \n\n \n\n | |\n |------------------|\n | expected: amount |\n | given: -10 |\n\n \n\n- \n\n the complete contract plus a path into it showing which aspect was violated,\n\n \n\n \n\n | |\n |-------------------------|\n | in: the 1st argument of |\n | (-> amount any) |\n\n \n\n- \n\n the module where the contract was put (or, more generally, the boundary that the contract mediates),\n\n \n\n \n\n | |\n |-------------------------------------|\n | contract from: improved-bank-server |\n\n \n\n- \n\n who was blamed,\n\n \n\n \n\n | |\n |------------------------------------|\n | blaming: top-level |\n | (assuming the contract is correct) |\n\n \n\n- \n\n and the source location where the contract appears.\n\n \n\n \n\n | |\n |--------------|\n | at: eval:5:0 |\n\n \n\n------------------------------------------------------------------------\n\n# 7.3 Contracts on Functions in General\n\n### 7.3 Contracts on Functions in General\n\nThe [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) contract constructor works for functions that take a fixed number of arguments and where the result contract is independent of the input arguments. To support other kinds of functions, Racket supplies additional contract constructors, notably [->*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%252A%2529%2529&version=8.18.0.13) and [->i](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3ei%2529%2529&version=8.18.0.13).\n\n#### 7.3.1 Optional Arguments\n\nTake a look at this excerpt from a string-processing module:\n\n> ```racket\n> #lang racket\n> ( provide\n> ( contract-out\n> ; pad the given str left and right with\n> ; the (optional) char so that it is centered\n> [ string-pad-center ( -> * ( string? natural-number/c )\n> ( char? )\n> string? ) ] ) )\n> ( define ( string-pad-center str width [ pad #\\space ] )\n> ( define field-width ( min width ( string-length str ) ) )\n> ( define rmargin ( ceiling ( / ( - width field-width ) 2 ) ) )\n> ( define lmargin ( floor ( / ( - width field-width ) 2 ) ) )\n> ( string-append ( build-string lmargin ( λ ( x ) pad ) )\n> str\n> ( build-string rmargin ( λ ( x ) pad ) ) ) )\n> ```\n\nThe module exports string-pad-center, a function that creates a string of a given width with the given string in the center. The default fill character is #\\\\space; if the client module wishes to use a different character, it may call string-pad-center with a third argument, a char, overwriting the default.\n\nThe function definition uses optional arguments, which is appropriate for this kind of functionality. The interesting point here is the formulation of the contract for the string-pad-center.\n\nThe contract combinator [->*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%252A%2529%2529&version=8.18.0.13), demands several groups of contracts:\n\n- The first one is a parenthesized group of contracts for all required arguments. In this example, we see two: [string?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=strings.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._string%7E3f%2529%2529&version=8.18.0.13) and [natural-number/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._natural-number%252Fc%2529%2529&version=8.18.0.13).\n\n- The second one is a parenthesized group of contracts for all optional arguments: [char?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=characters.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._char%7E3f%2529%2529&version=8.18.0.13).\n\n- The last one is a single contract: the result of the function.\n\nNote that if a default value does not satisfy a contract, you won’t get a contract error for this interface. If you can’t trust yourself to get the initial value right, you need to communicate the initial value across a boundary.\n\n#### 7.3.2 Rest Arguments\n\nThe [max](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._max%2529%2529&version=8.18.0.13) operator consumes at least one real number, but it accepts any number of additional arguments. You can write other such functions using a [rest argument](lambda.html#%28tech._rest._argument%29), such as in max-abs:\n\n> > > See [Declaring a Rest Argument](lambda.html#%28part._rest-args%29) for an introduction to rest arguments.\n\n> ```racket\n> ( define ( max-abs n . rst )\n> ( foldr ( lambda ( n m ) ( max ( abs n ) m ) ) ( abs n ) rst ) )\n> ```\n\nTo describe this function through a contract, you can use the [...](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=stx-patterns.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fstxcase-scheme..rkt%2529._......%2529%2529&version=8.18.0.13) feature of [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13).\n\n> ```racket\n> ( provide\n> ( contract-out\n> [ max-abs ( -> real? real? ... real? ) ] ) )\n> ```\n\nAlternatively, you can use [->*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%252A%2529%2529&version=8.18.0.13) with a #:rest keyword, which specifies a contract on a list of arguments after the required and optional arguments:\n\n> ```racket\n> ( provide\n> ( contract-out\n> [ max-abs ( -> * ( real? ) ( ) #:rest ( listof real? ) real? ) ] ) )\n> ```\n\nAs always for [->*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%252A%2529%2529&version=8.18.0.13), the contracts for the required arguments are enclosed in the first pair of parentheses, which in this case is a single real number. The empty pair of parenthesis indicates that there are no optional arguments (not counting the rest arguments). The contract for the rest argument follows #:rest; since all additional arguments must be real numbers, the list of rest arguments must satisfy the contract ([listof](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._listof%2529%2529&version=8.18.0.13) [real?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._real%7E3f%2529%2529&version=8.18.0.13)).\n\n#### 7.3.3 Keyword Arguments\n\nIt turns out that the [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) contract constructor also contains support for keyword arguments. For example, consider this function, which creates a simple GUI and asks the user a yes-or-no question:\n\n> > > See [Declaring Keyword Arguments](lambda.html#%28part._lambda-keywords%29) for an introduction to keyword arguments.\n\n> ```racket\n> #lang racket/gui\n> ( define ( ask-yes-or-no-question question\n> #:default answer\n> #:title title\n> #:width w\n> #:height h )\n> ( define d ( new dialog% [ label title ] [ width w ] [ height h ] ) )\n> ( define msg ( new message% [ label question ] [ parent d ] ) )\n> ( define ( yes ) ( set! answer #t ) ( send d show #f ) )\n> ( define ( no ) ( set! answer #f ) ( send d show #f ) )\n> ( define yes-b ( new button%\n> [ label \"Yes\" ] [ parent d ]\n> [ callback ( λ ( x y ) ( yes ) ) ]\n> [ style ( if answer ' ( border ) ' ( ) ) ] ) )\n> ( define no-b ( new button%\n> [ label \"No\" ] [ parent d ]\n> [ callback ( λ ( x y ) ( no ) ) ]\n> [ style ( if answer ' ( ) ' ( border ) ) ] ) )\n> ( send d show #t )\n> answer )\n> ( provide ( contract-out\n> [ ask-yes-or-no-question\n> ( -> string?\n> #:default boolean?\n> #:title string?\n> #:width exact-integer?\n> #:height exact-integer?\n> boolean? ) ] ) )\n> ```\n\n> > > If you really want to ask a yes-or-no question via a GUI, you should use [message-box/custom](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=gui&rel=Windowing_Functions.html%23%2528def._%2528%2528lib._mred%252Fmain..rkt%2529._message-box%252Fcustom%2529%2529&version=8.18.0.13). For that matter, it’s usually better to provide buttons with more specific answers than “yes” and “no.”\n\nThe contract for ask-yes-or-no-question uses [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13), and in the same way that [lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._lambda%2529%2529&version=8.18.0.13) (or [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13)-based functions) allows a keyword to precede a functions formal argument, [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) allows a keyword to precede a function contract’s argument contract. In this case, the contract says that ask-yes-or-no-question must receive four keyword arguments, one for each of the keywords #:default, #:title, #:width, and #:height. As in a function definition, the order of the keywords in [->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) relative to each other does not matter for clients of the function; only the relative order of argument contracts without keywords matters.\n\n#### 7.3.4 Optional Keyword Arguments\n\nOf course, many of the parameters in ask-yes-or-no-question (from the previous question) have reasonable defaults and should be made optional:\n\n> ```racket\n> ( define ( ask-yes-or-no-question question\n> #:default answer\n> #:title [ title \"Yes or No?\" ]\n> #:width [ w 400 ]\n> #:height [ h 200 ] )\n> ... )\n> ```\n\nTo specify this function’s contract, we need to use [->*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%252A%2529%2529&version=8.18.0.13) again. It supports keywords just as you might expect in both the optional and mandatory argument sections. In this case, we have the mandatory keyword #:default and optional keywords #:title, #:width, and #:height. So, we write the contract like this:\n\n> ```racket\n> ( provide ( contract-out\n> [ ask-yes-or-no-question\n> ( -> * ( string?\n> #:default boolean? )\n> ( #:title string?\n> #:width exact-integer?\n> #:height exact-integer? )\n> boolean? ) ] ) )\n> ```\n\nThat is, we put the mandatory keywords in the first section, and we put the optional ones in the second section.\n\n#### 7.3.5 Contracts for [case-lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._case-lambda%2529%2529&version=8.18.0.13)\n\nA function defined with [case-lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._case-lambda%2529%2529&version=8.18.0.13) might impose different constraints on its arguments depending on how many are provided. For example, a report-cost function might convert either a pair of numbers or a string into a new string:\n\n> > > See [Arity-Sensitive Functions: case-lambda](lambda.html#%28part._case-lambda%29) for an introduction to [case-lambda](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=lambda.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._case-lambda%2529%2529&version=8.18.0.13).\n\n> ```\n(define report-cost\n> ( case-lambda\n> [ ( lo hi ) ( format \"between $~a and $~a\" lo hi ) ]\n> [ ( desc ) ( format \"~a of dollars\" desc ) ] ) )\n \n> ( report-cost 5 8 )\n> \"between $5 and $8\"\n> > ( report-cost \"millions\" )\n> \"millions of dollars\"\n```"}
{"text": "### 5.5 Structure Comparisons\n(x)\t→\t\n(-> provide (contract-out\n [ report-cost\n (case →\n (integer? integer? . → . string?)\n (string? . → . string?)) ]))```\n------------------------------------------------------------------------"}
{"text": "# 7.9 Gotchas"}
{"text": "### 7.9 Gotchas"}
{"text": "#### 7.9.1 Contracts and [eq?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=Equality.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._eq%7E3f%2529%2529&version=8.18.0.13)\nAs a general rule, adding a contract to a program should either leave the behavior of the program unchanged, or should signal a contract violation. And this is almost true for Racket contracts, with one exception: [eq?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=Equality.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._eq%7E3f%2529%2529&version=8.18.0.13).\nThe [eq?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=Equality.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._eq%7E3f%2529%2529&version=8.18.0.13) procedure is designed to be fast and does not provide much in the way of guarantees, except that if it returns true, it means that the two values behave identically in all respects. Internally, this is implemented as pointer equality at a low-level so it exposes information about how Racket is implemented (and how contracts are implemented)."}
{"text": "# 7.9 Gotchas\nContracts interact poorly with [eq?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=Equality.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._eq%7E3f%2529%2529&version=8.18.0.13) because function contract checking is implemented internally as wrapper functions. For example, consider this module:\n> ```racket\n> #lang racket\n> ( define ( make-adder x )\n> ( if ( = 1 x )\n> add1\n> ( lambda ( y ) ( + x y ) ) ) )\n> ( provide ( contract-out\n> [ make-adder ( -> number? ( -> number? number? ) ) ] ) )\n> ```\nIt exports the make-adder function that is the usual curried addition function, except that it returns Racket’s [add1](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=generic-numbers.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._add1%2529%2529&version=8.18.0.13) when its input is 1.\nYou might expect that\n> ```racket\n> ( eq? ( make-adder 1 )\n> ( make-adder 1 ) )\n> ```"}
{"text": "# 7.9 Gotchas\nwould return #t, but it does not. If the contract were changed to [any/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%252Fc%2529%2529&version=8.18.0.13) (or even ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [number?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._number%7E3f%2529%2529&version=8.18.0.13) [any/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%252Fc%2529%2529&version=8.18.0.13))), then the [eq?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=Equality.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._eq%7E3f%2529%2529&version=8.18.0.13) call would return #t."}
{"text": "# 7.9 Gotchas\nMoral: Do not use [eq?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=Equality.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._eq%7E3f%2529%2529&version=8.18.0.13) on values that have contracts."}
{"text": "#### 7.9.2 Contract boundaries and [define/contract](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fregion..rkt%2529._define%252Fcontract%2529%2529&version=8.18.0.13)\nThe contract boundaries established by [define/contract](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fregion..rkt%2529._define%252Fcontract%2529%2529&version=8.18.0.13), which creates a nested contract boundary, are sometimes unintuitive. This is especially true when multiple functions or other values with contracts interact. For example, consider these two interacting functions:\n> ```racket\n> > ( define/contract ( f x ) ( -> integer? integer? ) x )\n> > ( define/contract ( g ) ( -> string? ) ( f \"not an integer\" ) )\n> > ( g )\n> f: contract violation\n> expected: integer?\n> given: \"not an integer\"\n> in: the 1st argument of\n> (-> integer? integer?)\n> contract from: (function f)\n> blaming: top-level\n> (assuming the contract is correct)\n> at: eval:2:0\n> ```\nOne might expect that the function g will be blamed for breaking the terms of its contract with f. Blaming g would be right if f and g were directly establishing contracts with each other. They aren’t, however. Instead, the access between f and g is mediated through the top-level of the enclosing module."}
{"text": "# 7.9 Gotchas\nMore precisely, f and the top-level of the module have the ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13) [integer?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=number-types.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._integer%7E3f%2529%2529&version=8.18.0.13)) contract mediating their interaction; g and the top-level have ([->](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=function-contracts.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._-%7E3e%2529%2529&version=8.18.0.13) [string?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=strings.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._string%7E3f%2529%2529&version=8.18.0.13)) mediating their interaction, but there is no contract directly between f and g. This means that the reference to f in the body of g is really the top-level of the module’s responsibility, not g’s. In other words, the function f has been given to g with no contract between g and the top-level and thus the top-level is blamed."}
{"text": "# 7.9 Gotchas\nIf we wanted to add a contract between g and the top-level, we can use [define/contract](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fregion..rkt%2529._define%252Fcontract%2529%2529&version=8.18.0.13)’s #:freevar declaration and see the expected blame:\n> ```racket\n> > ( define/contract ( f x ) ( -> integer? integer? ) x )\n> > ( define/contract ( g ) ( -> string? ) #:freevar f ( -> integer? integer? ) ( f \"not an integer\" ) )\n> > ( g )\n> f: contract violation\n> expected: integer?\n> given: \"not an integer\"\n> in: the 1st argument of\n> (-> integer? integer?)\n> contract from: top-level\n> blaming: (function g)\n> (assuming the contract is correct)\n> at: eval:6:0\n> ```\nMoral: if two values with contracts should interact, put them in separate modules with contracts at the module boundary or use #:freevar."}
{"text": "#### 7.9.3 Exists Contracts and Predicates\nMuch like the [eq?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=Equality.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._eq%7E3f%2529%2529&version=8.18.0.13) example above, #:∃ contracts can change the behavior of a program.\nSpecifically, the [null?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._null%7E3f%2529%2529&version=8.18.0.13) predicate (and many other predicates) return #f for #:∃ contracts, and changing one of those contracts to [any/c](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=data-structure-contracts.html%23%2528def._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fmisc..rkt%2529._any%252Fc%2529%2529&version=8.18.0.13) means that [null?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=pairs.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._null%7E3f%2529%2529&version=8.18.0.13) might now return #t instead, resulting in arbitrarily different behavior depending on how this boolean might flow around in the program.\nMoral: Do not use predicates on #:∃ contracts."}
{"text": "#### 7.9.4 Defining Recursive Contracts\nWhen defining a self-referential contract, it is natural to use [define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13). For example, one might try to write a contract on streams like this:\n> ```racket\n> > ( define stream/c ( promise/c ( or/c null? ( cons/c number? stream/c ) ) ) )\n> stream/c: undefined;\n> cannot reference an identifier before its definition\n> in module: top-level\n> ```\nUnfortunately, this does not work because the value of stream/c is needed before it is defined. Put another way, all of the combinators evaluate their arguments eagerly, even though the values that they accept do not.\nInstead, use\n> ```racket\n> ( define stream/c\n> ( promise/c\n> ( or/c\n> null?\n> ( cons/c number? ( recursive-contract stream/c ) ) ) ) )\n> ```\nThe use of [recursive-contract](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=contract-utilities.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fprivate%252Fbase..rkt%2529._recursive-contract%2529%2529&version=8.18.0.13) delays the evaluation of the identifier stream/c until after the contract is first checked, long enough to ensure that stream/c is defined.\nSee also [Checking Properties of Data Structures](contracts-struct.html#%28part._contracts-lazy-contracts%29)."}
{"text": "#### 7.9.5 Mixing [set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._set%2521%2529%2529&version=8.18.0.13) and [contract-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._contract-out%2529%2529&version=8.18.0.13)\nThe contract library assumes that variables exported via [contract-out](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=attaching-contracts-to-values.html%23%2528form._%2528%2528lib._racket%252Fcontract%252Fbase..rkt%2529._contract-out%2529%2529&version=8.18.0.13) are not assigned to, but does not enforce it. Accordingly, if you try to [set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=set_.html%23%2528form._%2528%2528quote._%7E23%7E25kernel%2529._set%2521%2529%2529&version=8.18.0.13) those variables, you may be surprised. Consider the following example:\n> ```racket\n> > ( module server racket ( define ( inc-x! ) ( set! x ( + x 1 ) ) ) ( define x 0 ) ( provide ( contract-out [ inc-x! ( -> void? ) ] [ x integer? ] ) ) )\n> > ( module client racket ( require ' server ) ( define ( print-latest ) ( printf \"x is ~s\\n\" x ) ) ( print-latest ) ( inc-x! ) ( print-latest ) )\n> > ( require ' client )\n> x is 0 x is 0\n> ```"}
{"text": "# 7.9 Gotchas\nBoth calls to print-latest print 0, even though the value of x has been incremented (and the change is visible inside the module x).\nTo work around this, export accessor functions, rather than exporting the variable directly, like this:\n> ```racket\n> #lang racket\n> ( define ( get-x ) x )\n> ( define ( inc-x! ) ( set! x ( + x 1 ) ) )\n> ( define x 0 )\n> ( provide ( contract-out [ inc-x! ( -> void? ) ]\n> [ get-x ( -> integer? ) ] ) )\n> ```\nMoral: This is a bug that we will address in a future release.\n------------------------------------------------------------------------"}
{"text": "# 8 Input and Output"}
{"text": "## 8 Input and Output\n> > > A Racket port corresponds to the Unix notion of a stream (not to be confused with [racket/stream](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=streams.html&version=8.18.0.13)’s streams).\nA Racket port represents a source or sink of data, such as a file, a terminal, a TCP connection, or an in-memory string. Ports provide sequential access in which data can be read or written a piece at a time, without requiring the data to be consumed or produced all at once. More specifically, an input port represents a source from which a program can read data, and an output port represents a sink to which a program can write data.\n| |\n|---------------------------------------------------------------------------------------|\n| [8.1 Varieties of Ports](ports.html) |\n| [8.2 Default Ports](default-ports.html) |\n| [8.3 Reading and Writing Racket Data](read-write.html) |\n| [8.4 Datatypes and Serialization](serialization.html) |\n| [8.5 Bytes, Characters, and Encodings](encodings.html) |\n| [8.6 I/O Patterns](io-patterns.html) |\n------------------------------------------------------------------------"}
{"text": "# 8.1 Varieties of Ports"}
{"text": "### 8.1 Varieties of Ports\nVarious functions create various kinds of ports. Here are a few examples:\n- Files: The [open-output-file](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=file-ports.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._open-output-file%2529%2529&version=8.18.0.13) function opens a file for writing, and [open-input-file](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=file-ports.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._open-input-file%2529%2529&version=8.18.0.13) opens a file for reading.\n Examples:\n > ```racket\n > > ( define out ( open-output-file \"data\" ) )\n > > ( display \"hello\" out )\n > > ( close-output-port out )\n > > ( define in ( open-input-file \"data\" ) )\n > > ( read-line in )\n > \"hello\"\n > > ( close-input-port in )\n > ```\n If a file exists already, then [open-output-file](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=file-ports.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._open-output-file%2529%2529&version=8.18.0.13) raises an exception by default. Supply an option like #:exists 'truncate or #:exists 'update to re-write or update the file:\n Examples:\n > ```racket\n > > ( define out ( open-output-file \"data\" #:exists ' truncate ) )\n > > ( display \"howdy\" out )\n > > ( close-output-port out )\n > ```"}
{"text": "# 8.1 Varieties of Ports\n Instead of having to match the open calls with close calls, most Racket programmers will use the [call-with-input-file](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=file-ports.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._call-with-input-file%2529%2529&version=8.18.0.13) and [call-with-output-file](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=file-ports.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._call-with-output-file%2529%2529&version=8.18.0.13) functions which take a function to call to carry out the desired operation. This function gets as its only argument the port, which is automatically opened and closed for the operation.\n Examples:\n > ```racket\n > > ( call-with-output-file \"data\" #:exists ' truncate ( lambda ( out ) ( display \"hello\" out ) ) )\n > > ( call-with-input-file \"data\" ( lambda ( in ) ( read-line in ) ) )\n > \"hello\"\n > ```"}
{"text": "# 8.1 Varieties of Ports\n- Strings: The [open-output-string](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=stringport.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._open-output-string%2529%2529&version=8.18.0.13) function creates a port that accumulates data into a string, and [get-output-string](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=stringport.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._get-output-string%2529%2529&version=8.18.0.13) extracts the accumulated string. The [open-input-string](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=stringport.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._open-input-string%2529%2529&version=8.18.0.13) function creates a port to read from a string.\n Examples:\n > ```racket\n > > ( define p ( open-output-string ) )\n > > ( display \"hello\" p )\n > > ( get-output-string p )\n > \"hello\"\n > > ( read-line ( open-input-string \"goodbye\\nfarewell\" ) )\n > \"goodbye\"\n > ```"}
{"text": "# 8.1 Varieties of Ports\n- TCP Connections: The [tcp-connect](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=tcp.html%23%2528def._%2528%2528lib._racket%252Ftcp..rkt%2529._tcp-connect%2529%2529&version=8.18.0.13) function creates both an input port and an output port for the client side of a TCP communication. The [tcp-listen](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=tcp.html%23%2528def._%2528%2528lib._racket%252Ftcp..rkt%2529._tcp-listen%2529%2529&version=8.18.0.13) function creates a server, which accepts connections via [tcp-accept](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=tcp.html%23%2528def._%2528%2528lib._racket%252Ftcp..rkt%2529._tcp-accept%2529%2529&version=8.18.0.13).\n Examples:\n > ```racket\n > > ( define server ( tcp-listen 12345 ) )\n > > ( define-values ( c-in c-out ) ( tcp-connect \"localhost\" 12345 ) )\n > > ( define-values ( s-in s-out ) ( tcp-accept server ) )\n > > ( display \"hello\\n\" c-out )\n > > ( close-output-port c-out )\n > > ( read-line s-in )\n > \"hello\"\n > > ( read-line s-in )\n > #[Regular Expressions](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) provides more on regexps.\n\n------------------------------------------------------------------------\n\n# 9.1 Writing Regexp Patterns\n\n### 9.1 Writing Regexp Patterns\n\nA string or [byte string](bytestrings.html#%28tech._byte._string%29) can be used directly as a [regexp](regexp.html#%28tech._regexp%29) pattern, or it can be prefixed with #rx to form a literal [regexp](regexp.html#%28tech._regexp%29) value. For example, #rx\"abc\" is a string-based [regexp](regexp.html#%28tech._regexp%29) value, and #rx#\"abc\" is a [byte string](bytestrings.html#%28tech._byte._string%29)-based [regexp](regexp.html#%28tech._regexp%29) value. Alternately, a string or byte string can be prefixed with #px, as in #px\"abc\", for a slightly extended syntax of patterns within the string.\n\nMost of the characters in a [regexp](regexp.html#%28tech._regexp%29) pattern are meant to match occurrences of themselves in the [text string](regexp.html#%28tech._text._string%29). Thus, the pattern #rx\"abc\" matches a string that contains the characters a, b, and c in succession. Other characters act as metacharacters, and some character sequences act as metasequences. That is, they specify something other than their literal selves. For example, in the pattern #rx\"a.c\", the characters a and c stand for themselves, but the [metacharacter](#%28tech._metacharacter%29) . can match any character. Therefore, the pattern #rx\"a.c\" matches an a, any character, and c in succession.\n\n> > > When we want a literal \\\\ inside a Racket string or regexp literal, we must escape it so that it shows up in the string at all. Racket strings use \\\\ as the escape character, so we end up with two \\\\s: one Racket-string \\\\ to escape the regexp \\\\, which then escapes the .. Another character that would need escaping inside a Racket string is \".\n\nIf we needed to match the character . itself, we can escape it by preceding it with a \\\\. The character sequence \\\\. is thus a [metasequence](#%28tech._metasequence%29), since it doesn’t match itself but rather just .. So, to match a, ., and c in succession, we use the regexp pattern #rx\"a\\\\\\\\.c\"; the double \\\\ is an artifact of Racket strings, not the [regexp](regexp.html#%28tech._regexp%29) pattern itself.\n\nThe [regexp](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp%2529%2529&version=8.18.0.13) function takes a string or byte string and produces a [regexp](regexp.html#%28tech._regexp%29) value. Use [regexp](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp%2529%2529&version=8.18.0.13) when you construct a pattern to be matched against multiple strings, since a pattern is compiled to a [regexp](regexp.html#%28tech._regexp%29) value before it can be used in a match. The [pregexp](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._pregexp%2529%2529&version=8.18.0.13) function is like [regexp](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp%2529%2529&version=8.18.0.13), but using the extended syntax. Regexp values as literals with #rx or #px are compiled once and for all when they are read.\n\nThe [regexp-quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._regexp-quote%2529%2529&version=8.18.0.13) function takes an arbitrary string and returns a string for a pattern that matches exactly the original string. In particular, characters in the input string that could serve as regexp metacharacters are escaped with a backslash, so that they safely match only themselves.\n\n> ```racket\n> > ( regexp-quote \"cons\" )\n> \"cons\"\n> > ( regexp-quote \"list?\" )\n> \"list\\\\?\"\n> ```\n\nThe [regexp-quote](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._regexp-quote%2529%2529&version=8.18.0.13) function is useful when building a composite [regexp](regexp.html#%28tech._regexp%29) from a mix of [regexp](regexp.html#%28tech._regexp%29) strings and verbatim strings.\n\n------------------------------------------------------------------------\n\n# 9.2 Matching Regexp Patterns\n\n### 9.2 Matching Regexp Patterns\n\nThe [regexp-match-positions](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-match-positions%2529%2529&version=8.18.0.13) function takes a [regexp](regexp.html#%28tech._regexp%29) pattern and a [text string](regexp.html#%28tech._text._string%29), and it returns a match if the regexp matches (some part of) the [text string](regexp.html#%28tech._text._string%29), or #f if the regexp did not match the string. A successful match produces a list of index pairs.\n\nExamples:\n\n> ```racket\n> > ( regexp-match-positions #rx\"brain\" \"bird\" )\n> #f\n> > ( regexp-match-positions #rx\"needle\" \"hay needle stack\" )\n> '((4 . 10))\n> ```\n\nIn the second example, the integers 4 and 10 identify the substring that was matched. The 4 is the starting (inclusive) index, and 10 the ending (exclusive) index of the matching substring:\n\n> ```racket\n> > ( substring \"hay needle stack\" 4 10 )\n> \"needle\"\n> ```\n\nIn this first example, [regexp-match-positions](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-match-positions%2529%2529&version=8.18.0.13)’s return list contains only one index pair, and that pair represents the entire substring matched by the regexp. When we discuss [subpatterns](regexp-clusters.html#%28tech._subpattern%29) later, we will see how a single match operation can yield a list of [submatch](regexp-clusters.html#%28tech._submatch%29)es.\n\nThe [regexp-match-positions](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-match-positions%2529%2529&version=8.18.0.13) function takes optional third and fourth arguments that specify the indices of the [text string](regexp.html#%28tech._text._string%29) within which the matching should take place.\n\n> ```racket\n> > ( regexp-match-positions #rx\"needle\" \"his needle stack -- my needle stack -- her needle stack\" 20 39 )\n> '((23 . 29))\n> ```\n\nNote that the returned indices are still reckoned relative to the full [text string](regexp.html#%28tech._text._string%29).\n\nThe [regexp-match](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-match%2529%2529&version=8.18.0.13) function is like [regexp-match-positions](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-match-positions%2529%2529&version=8.18.0.13), but instead of returning index pairs, it returns the matching substrings:\n\n> ```racket\n> > ( regexp-match #rx\"brain\" \"bird\" )\n> #f\n> > ( regexp-match #rx\"needle\" \"hay needle stack\" )\n> '(\"needle\")\n> ```\n\nWhen [regexp-match](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-match%2529%2529&version=8.18.0.13) is used with byte-string regexp, the result is a matching byte substring:\n\n> ```racket\n> > ( regexp-match #rx#\"needle\" #\"hay needle stack\" )\n> '(#\"needle\")\n> ```\n\n> > > A byte-string regexp can be applied to a string, and a string regexp can be applied to a byte string. In both cases, the result is a byte string. Internally, all regexp matching is in terms of bytes, and a string regexp is expanded to a regexp that matches UTF-8 encodings of characters. For maximum efficiency, use byte-string matching instead of string, since matching bytes directly avoids UTF-8 encodings.\n\nIf you have data that is in a port, there’s no need to first read it into a string. Functions like [regexp-match](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-match%2529%2529&version=8.18.0.13) can match on the port directly:\n\n> ```racket\n> > ( define-values ( i o ) ( make-pipe ) )\n> > ( write \"hay needle stack\" o )\n> > ( close-output-port o )\n> > ( regexp-match #rx#\"needle\" i )\n> '(#\"needle\")\n> ```\n\nThe [regexp-match?](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-match%7E3f%2529%2529&version=8.18.0.13) function is like [regexp-match-positions](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-match-positions%2529%2529&version=8.18.0.13), but simply returns a boolean indicating whether the match succeeded:\n\n> ```racket\n> > ( regexp-match? #rx\"brain\" \"bird\" )\n> #f\n> > ( regexp-match? #rx\"needle\" \"hay needle stack\" )\n> #t\n> ```\n\nThe [regexp-split](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._regexp-split%2529%2529&version=8.18.0.13) function takes two arguments, a [regexp](regexp.html#%28tech._regexp%29) pattern and a text string, and it returns a list of substrings of the text string; the pattern identifies the delimiter separating the substrings.\n\n> ```racket\n> > ( regexp-split #rx\":\" \"/bin:/usr/bin:/usr/bin/X11:/usr/local/bin\" )\n> '(\"/bin\" \"/usr/bin\" \"/usr/bin/X11\" \"/usr/local/bin\")\n> > ( regexp-split #rx\" \" \"pea soup\" )\n> '(\"pea\" \"soup\")\n> ```\n\nIf the first argument matches empty strings, then the list of all the single-character substrings is returned.\n\n> ```racket\n> > ( regexp-split #rx\"\" \"smithereens\" )\n> '(\"\" \"s\" \"m\" \"i\" \"t\" \"h\" \"e\" \"r\" \"e\" \"e\" \"n\" \"s\" \"\")\n> ```\n\nThus, to identify one-or-more spaces as the delimiter, take care to use the regexp #rx\" +\", not #rx\" \\*\".\n\n> ```racket\n> > ( regexp-split #rx\" +\" \"split pea soup\" )\n> '(\"split\" \"pea\" \"soup\")\n> > ( regexp-split #rx\" *\" \"split pea soup\" )\n> '(\"\" \"s\" \"p\" \"l\" \"i\" \"t\" \"\" \"p\" \"e\" \"a\" \"\" \"s\" \"o\" \"u\" \"p\" \"\")\n> ```\n\nThe [regexp-replace](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-replace%2529%2529&version=8.18.0.13) function replaces the matched portion of the text string by another string. The first argument is the pattern, the second the text string, and the third is either the string to be inserted or a procedure to convert matches to the insert string.\n\n> ```racket\n> > ( regexp-replace #rx\"te\" \"liberte\" \"ty\" )\n> \"liberty\"\n> > ( regexp-replace #rx\".\" \"racket\" string-upcase )\n> \"Racket\"\n> ```\n\nIf the pattern doesn’t occur in the text string, the returned string is identical to the text string.\n\nThe [regexp-replace*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._regexp-replace%252A%2529%2529&version=8.18.0.13) function replaces all matches in the text string by the insert string:\n\n> ```racket\n> > ( regexp-replace* #rx\"te\" \"liberte egalite fraternite\" \"ty\" )\n> \"liberty egality fratyrnity\"\n> > ( regexp-replace* #rx\"[ds]\" \"drracket\" string-upcase )\n> \"Drracket\"\n> ```\n\n------------------------------------------------------------------------\n\n# 9.3 Basic Assertions\n\n### 9.3 Basic Assertions\n\nThe assertions ^ and $ identify the beginning and the end of the text string, respectively. They ensure that their adjoining regexps match at one or other end of the text string:\n\n> ```racket\n> > ( regexp-match-positions #rx\"^contact\" \"first contact\" )\n> #f\n> ```\n\nThe [regexp](regexp.html#%28tech._regexp%29) above fails to match because contact does not occur at the beginning of the text string. In\n\n> ```racket\n> > ( regexp-match-positions #rx\"laugh$\" \"laugh laugh laugh laugh\" )\n> '((18 . 23))\n> ```\n\nthe regexp matches the last laugh.\n\nThe metasequence \\\\b asserts that a word boundary exists, but this metasequence works only with #px syntax. In\n\n> ```racket\n> > ( regexp-match-positions #px\"yack\\\\b\" \"yackety yack\" )\n> '((8 . 12))\n> ```\n\nthe yack in yackety doesn’t end at a word boundary so it isn’t matched. The second yack does and is.\n\nThe metasequence \\\\B (also #px only) has the opposite effect to \\\\b; it asserts that a word boundary does not exist. In\n\n> ```racket\n> > ( regexp-match-positions #px\"an\\\\B\" \"an analysis\" )\n> '((3 . 5))\n> ```\n\nthe an that doesn’t end in a word boundary is matched.\n\n------------------------------------------------------------------------\n\n# 9.4 Characters and Character Classes\n\n### 9.4 Characters and Character Classes\n\nTypically, a character in the regexp matches the same character in the text string. Sometimes it is necessary or convenient to use a regexp [metasequence](regexp-intro.html#%28tech._metasequence%29) to refer to a single character. For example, the metasequence \\\\. matches the period character.\n\nThe [metacharacter](regexp-intro.html#%28tech._metacharacter%29) . matches any character (other than newline in [multi-line mode](regexp-clusters.html#%28tech._multi._line._mode%29); see [Cloisters](regexp-clusters.html#%28part._regexp-cloister%29)):\n\n> ```racket\n> > ( regexp-match #rx\"p.t\" \"pet\" )\n> '(\"pet\")\n> ```\n\nThe above pattern also matches pat, pit, pot, put, and p8t, but not peat or pfffft.\n\nA character class matches any one character from a set of characters. A typical format for this is the bracketed character class \\[...\\], which matches any one character from the non-empty sequence of characters enclosed within the brackets. Thus, #rx\"p\\[aeiou\\]t\" matches pat, pet, pit, pot, put, and nothing else.\n\nInside the brackets, a - between two characters specifies the Unicode range between the characters. For example, #rx\"ta\\[b-dgn-p\\]\" matches tab, tac, tad, tag, tan, tao, and tap.\n\nAn initial ^ after the left bracket inverts the set specified by the rest of the contents; i.e., it specifies the set of characters other than those identified in the brackets. For example, #rx\"do\\[^g\\]\" matches all three-character sequences starting with do except dog.\n\nNote that the [metacharacter](regexp-intro.html#%28tech._metacharacter%29) ^ inside brackets means something quite different from what it means outside. Most other [metacharacters](regexp-intro.html#%28tech._metacharacter%29) (., \\*, +, ?, etc.) cease to be [metacharacters](regexp-intro.html#%28tech._metacharacter%29) when inside brackets, although you may still escape them for peace of mind. A - is a [metacharacter](regexp-intro.html#%28tech._metacharacter%29) only when it’s inside brackets, and when it is neither the first nor the last character between the brackets.\n\nBracketed character classes cannot contain other bracketed character classes (although they contain certain other types of character classes; see below). Thus, a \\[ inside a bracketed character class doesn’t have to be a metacharacter; it can stand for itself. For example, #rx\"\\[a\\[b\\]\" matches a, \\[, and b.\n\nFurthermore, since empty bracketed character classes are disallowed, a \\] immediately occurring after the opening left bracket also doesn’t need to be a metacharacter. For example, #rx\"\\[\\]ab\\]\" matches \\], a, and b.\n\n#### 9.4.1 Some Frequently Used Character Classes\n\nIn #px syntax, some standard character classes can be conveniently represented as metasequences instead of as explicit bracketed expressions: \\\\d matches a digit (the same as \\[0-9\\]); \\\\s matches an ASCII whitespace character; and \\\\w matches a character that could be part of a “word”.\n\n> > > Following regexp custom, we identify “word” characters as \\[A-Za-z0-9\\_\\], although these are too restrictive for what a Racketeer might consider a “word.”\n\nThe upper-case versions of these metasequences stand for the inversions of the corresponding character classes: \\\\D matches a non-digit, \\\\S a non-whitespace character, and \\\\W a non-“word” character.\n\nRemember to include a double backslash when putting these metasequences in a Racket string:\n\n> ```racket\n> > ( regexp-match #px\"\\\\d\\\\d\" \"0 dear, 1 have 2 read catch 22 before 9\" )\n> '(\"22\")\n> ```\n\nThese character classes can be used inside a bracketed expression. For example, #px\"\\[a-z\\\\\\\\d\\]\" matches a lower-case letter or a digit.\n\n#### 9.4.2 POSIX character classes\n\nA POSIX character class is a special [metasequence](regexp-intro.html#%28tech._metasequence%29) of the form \\[:...:\\] that can be used only inside a bracketed expression in #px syntax. The POSIX classes supported are\n\n- \\[:alnum:\\] — ASCII letters and digits\n\n- \\[:alpha:\\] — ASCII letters\n\n- \\[:ascii:\\] — ASCII characters\n\n- \\[:blank:\\] — ASCII widthful whitespace: space and tab\n\n- \\[:cntrl:\\] — “control” characters: ASCII 0 to 31\n\n- \\[:digit:\\] — ASCII digits, same as \\\\d\n\n- \\[:graph:\\] — ASCII characters that use ink\n\n- \\[:lower:\\] — ASCII lower-case letters\n\n- \\[:print:\\] — ASCII ink-users plus widthful whitespace\n\n- \\[:space:\\] — ASCII whitespace, same as \\\\s\n\n- \\[:upper:\\] — ASCII upper-case letters\n\n- \\[:word:\\] — ASCII letters and \\_, same as \\\\w\n\n- \\[:xdigit:\\] — ASCII hex digits\n\nFor example, the #px\"\\[\\[:alpha:\\]\\_\\]\" matches a letter or underscore.\n\n> ```racket\n> > ( regexp-match #px\"[[:alpha:]_]\" \"--x--\" )\n> '(\"x\")\n> > ( regexp-match #px\"[[:alpha:]_]\" \"--_--\" )\n> '(\"_\")\n> > ( regexp-match #px\"[[:alpha:]_]\" \"--:--\" )\n> #f\n> ```\n\nThe POSIX class notation is valid only inside a bracketed expression. For instance, \\[:alpha:\\], when not inside a bracketed expression, will not be read as the letter class. Rather, it is (from previous principles) the character class containing the characters :, a, l, p, h.\n\n> ```racket\n> > ( regexp-match #px\"[:alpha:]\" \"--a--\" )\n> '(\"a\")\n> > ( regexp-match #px\"[:alpha:]\" \"--x--\" )\n> #f\n> ```\n\n------------------------------------------------------------------------\n\n# 9.5 Quantifiers\n\n### 9.5 Quantifiers\n\nThe quantifiers \\*, +, and ? match respectively: zero or more, one or more, and zero or one instances of the preceding subpattern.\n\n> ```racket\n> > ( regexp-match-positions #rx\"c[ad]*r\" \"cadaddadddr\" )\n> '((0 . 11))\n> > ( regexp-match-positions #rx\"c[ad]*r\" \"cr\" )\n> '((0 . 2))\n> > ( regexp-match-positions #rx\"c[ad]+r\" \"cadaddadddr\" )\n> '((0 . 11))\n> > ( regexp-match-positions #rx\"c[ad]+r\" \"cr\" )\n> #f\n> > ( regexp-match-positions #rx\"c[ad]?r\" \"cadaddadddr\" )\n> #f\n> > ( regexp-match-positions #rx\"c[ad]?r\" \"cr\" )\n> '((0 . 2))\n> > ( regexp-match-positions #rx\"c[ad]?r\" \"car\" )\n> '((0 . 3))\n> ```\n\nIn #px syntax, you can use braces to specify much finer-tuned quantification than is possible with \\*, +, ?:\n\n- The quantifier {m} matches exactly m instances of the preceding [subpattern](regexp-clusters.html#%28tech._subpattern%29); m must be a nonnegative integer.\n\n- The quantifier {m,n} matches at least m and at most n instances. m and n are nonnegative integers with m less or equal to n. You may omit either or both numbers, in which case m defaults to 0 and n to infinity.\n\nIt is evident that + and ? are abbreviations for {1,} and {0,1} respectively, and \\* abbreviates {,}, which is the same as {0,}.\n\n> ```racket\n> > ( regexp-match #px\"[aeiou]{3}\" \"vacuous\" )\n> '(\"uou\")\n> > ( regexp-match #px\"[aeiou]{3}\" \"evolve\" )\n> #f\n> > ( regexp-match #px\"[aeiou]{2,3}\" \"evolve\" )\n> #f\n> > ( regexp-match #px\"[aeiou]{2,3}\" \"zeugma\" )\n> '(\"eu\")\n> ```\n\nThe quantifiers described so far are all greedy: they match the maximal number of instances that would still lead to an overall match for the full pattern.\n\n> ```racket\n> > ( regexp-match #rx\"<.*>\" \"[Sequences](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=sequences.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) provides more on sequences."}
{"text": "### 11.2 [for](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%2529%2529&version=8.18.0.13) and [for*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%252A%2529%2529&version=8.18.0.13)\nA more complete syntax of [for](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%2529%2529&version=8.18.0.13) is\n> > ```\n(for (clause ...)\n> > body ...+ )\nclause = [id sequence-expr]\n | #:when boolean-expr\n | #:unless boolean-expr"}
{"text": "### 11.2 [for](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%2529%2529&version=8.18.0.13) and [for*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%252A%2529%2529&version=8.18.0.13)\n```\nWhen multiple \\[id sequence-expr\\] clauses are provided in a for form, the corresponding sequences are traversed in parallel:\n\n> ```racket\n> > ( for ( [ i ( in-range 1 4 ) ] [ chapter ' ( \"Intro\" \"Details\" \"Conclusion\" ) ] ) ( printf \"Chapter ~a. ~a\\n\" i chapter ) )\n> Chapter 1. Intro Chapter 2. Details Chapter 3. Conclusion\n> ```\n\nWith parallel sequences, the for expression stops iterating when any sequence ends. This behavior allows in-naturals, which creates an infinite sequence of numbers, to be used for indexing:\n\n> ```racket\n> > ( for ( [ i ( in-naturals 1 ) ] [ chapter ' ( \"Intro\" \"Details\" \"Conclusion\" ) ] ) ( printf \"Chapter ~a. ~a\\n\" i chapter ) )\n> Chapter 1. Intro Chapter 2. Details Chapter 3. Conclusion\n> ```\n\nThe for* form, which has the same syntax as for, nests multiple sequences instead of running them in parallel:\n\n> ```racket\n> > ( for* ( [ book ' ( \"Guide\" \"Reference\" ) ] [ chapter ' ( \"Intro\" \"Details\" \"Conclusion\" ) ] ) ( printf \"~a ~a\\n\" book chapter ) )\n> Guide Intro Guide Details Guide Conclusion Reference Intro Reference Details Reference Conclusion\n> ```\n\nThus, for* is a shorthand for nested fors in the same way that let* is a shorthand for nested lets.\n\nThe #:when boolean-expr form of a clause is another shorthand. It allows the bodys to evaluate only when the boolean-expr produces a true value:\n\n> ```racket\n> > ( for* ( [ book ' ( \"Guide\" \"Reference\" ) ] [ chapter ' ( \"Intro\" \"Details\" \"Conclusion\" ) ] #:when ( not ( equal? chapter \"Details\" ) ) ) ( printf \"~a ~a\\n\" book chapter ) )\n> Guide Intro Guide Conclusion Reference Intro Reference Conclusion\n> ```\n\nA boolean-expr with #:when can refer to any of the preceding iteration bindings. In a for form, this scoping makes sense only if the test is nested in the iteration of the preceding bindings; thus, bindings separated by #:when are mutually nested, instead of in parallel, even with for.\n\n> ```racket\n> > ( for ( [ book ' ( \"Guide\" \"Reference\" \"Notes\" ) ] #:when ( not ( equal? book \"Notes\" ) ) [ i ( in-naturals 1 ) ] [ chapter ' ( \"Intro\" \"Details\" \"Conclusion\" \"Index\" ) ] #:when ( not ( equal? chapter \"Index\" ) ) ) ( printf \"~a Chapter ~a. ~a\\n\" book i chapter ) )\n> Guide Chapter 1. Intro Guide Chapter 2. Details Guide Chapter 3. Conclusion Reference Chapter 1. Intro Reference Chapter 2. Details Reference Chapter 3. Conclusion\n> ```\n\nAn #:unless clause is analogous to a #:when clause, but the bodys evaluate only when the boolean-expr produces a false value.\n\n### 11.3 for/list and for*/list\n\nThe for/list form, which has the same syntax as for, evaluates the bodys to obtain values that go into a newly constructed list:\n\n> ```racket\n> > ( for/list ( [ i ( in-naturals 1 ) ] [ chapter ' ( \"Intro\" \"Details\" \"Conclusion\" ) ] ) ( string-append ( number → string i ) \". \" chapter ) )\n> '(\"1. Intro\" \"2. Details\" \"3. Conclusion\")\n> ```\n\nA #:when clause in a for-list form prunes the result list along with evaluations of the bodys:\n\n> ```racket\n> > ( for/list ( [ i ( in-naturals 1 ) ] [ chapter ' ( \"Intro\" \"Details\" \"Conclusion\" ) ] #:when ( odd? i ) ) chapter )\n> '(\"Intro\" \"Conclusion\")\n> ```\n\nThis pruning behavior of #:when is more useful with for/list than for. Whereas a plain when form normally suffices with for, a when expression form in a for/list would cause the result list to contain #[Iterations and Comprehensions: for, for/list, ...](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html&version=8.18.0.13) in [The Racket Reference](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13) provides more on iterations and comprehensions.\n\n------------------------------------------------------------------------\n\n# 12 Pattern Matching\n\n## 12 Pattern Matching\n\n> > > ([require](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=require.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._require%2529%2529&version=8.18.0.13) racket/match) is needed for [#lang](Module_Syntax.html#%28part._hash-lang%29) [racket/base](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=index.html&version=8.18.0.13).\n\nThe [match](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=match.html%23%2528form._%2528%2528lib._racket%252Fmatch..rkt%2529._match%2529%2529&version=8.18.0.13) form supports pattern matching on arbitrary Racket values, as opposed to functions like [regexp-match](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=regexp.html%23%2528def._%2528%2528quote._%7E23%7E25kernel%2529._regexp-match%2529%2529&version=8.18.0.13) that compare regular expressions to byte and character sequences (see [Regular Expressions](regexp.html)).\n\n> > ```\n(match target-expr\n> > [ pattern expr ...+ ] ... )\n```"}
{"text": "### 11.2 [for](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%2529%2529&version=8.18.0.13) and [for*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%252A%2529%2529&version=8.18.0.13)\n(1)\t→```\nThe grow method in picky-fish% is declared with [define/override](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=createclass.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._define%252Foverride%2529%2529&version=8.18.0.13) instead of [define/public](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=createclass.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._define%252Fpublic%2529%2529&version=8.18.0.13), because grow is meant as an overriding declaration. If grow had been declared with [define/public](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=createclass.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._define%252Fpublic%2529%2529&version=8.18.0.13), an error would have been signaled when evaluating the [class](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=createclass.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._class%2529%2529&version=8.18.0.13) expression, because fish% already supplies grow."}
{"text": "### 11.2 [for](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%2529%2529&version=8.18.0.13) and [for*](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=for.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._for%252A%2529%2529&version=8.18.0.13)\nUsing [define/override](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=createclass.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._define%252Foverride%2529%2529&version=8.18.0.13) also allows the invocation of the overridden method via a [super](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=createclass.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._super%2529%2529&version=8.18.0.13) call. For example, the grow implementation in picky-fish% uses [super](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=createclass.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._super%2529%2529&version=8.18.0.13) to delegate to the superclass implementation."}
{"text": "### 13.2 Initialization Arguments\nSince picky-fish% declares no initialization arguments, any initialization values supplied in ([new](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=objcreation.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._new%2529%2529&version=8.18.0.13) picky-fish% ....) are propagated to the superclass initialization, i.e., to fish%. A subclass can supply additional initialization arguments for its superclass in a [super-new](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=objcreation.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._super-new%2529%2529&version=8.18.0.13) call, and such initialization arguments take precedence over arguments supplied to [new](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=objcreation.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._new%2529%2529&version=8.18.0.13). For example, the following size-10-fish% class always generates fish of size 10:"}
{"text": "### 13.2 Initialization Arguments\n> | ([define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=define.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fbase..rkt%2529._define%2529%2529&version=8.18.0.13) size-10-fish% ([class](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=createclass.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._class%2529%2529&version=8.18.0.13) fish% ([super-new](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=reference&rel=objcreation.html%23%2528form._%2528%2528lib._racket%252Fprivate%252Fclass-internal..rkt%2529._super-new%2529%2529&version=8.18.0.13) [size 10]))) |
|
|
See [Memory Management](memory.html) for functions related to garbage collection.\n\nIn the program state\n\n```\nobjects: ( define \n |
| red : ([and/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._and%2Fc%29%29) [natural-number/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._natural-number%2Fc%29%29) ([<=/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._~3c~3d%2Fc%29%29) 255)) |
| green : ([and/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._and%2Fc%29%29) [natural-number/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._natural-number%2Fc%29%29) ([<=/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._~3c~3d%2Fc%29%29) 255)) |
| blue : ([and/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._and%2Fc%29%29) [natural-number/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._natural-number%2Fc%29%29) ([<=/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._~3c~3d%2Fc%29%29) 255)) |
| alpha : ([and/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._and%2Fc%29%29) [natural-number/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._natural-number%2Fc%29%29) ([<=/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._~3c~3d%2Fc%29%29) 255)) |
\n | |||
| #:mutable) | |||
| connector : ([or/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29) 'postgresql 'mysql 'sqlite3 'odbc) | |||
| args : [list?](pairs.html#%28def._%28%28quote._~23~25kernel%29._list~3f%29%29) | |||
| extensions : ([listof](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._listof%29%29) ([list/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._list%2Fc%29%29) [symbol?](symbols.html#%28def._%28%28quote._~23~25kernel%29._symbol~3f%29%29) [any/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29))) |
\n\n |
| ([submod](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._submod%29%29) \".\" submod-path-element ...) |
| ([submod](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._submod%29%29) \"..\" submod-path-element ...) |
\n\n |
[Exports: provide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=module-provide.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [provide](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._provide%29%29).\n\n> \n\n | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
\n\n | ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
\n\n |
\n\n |
\n\n |
\n\n |
\n\n | |||||||||||||||||||||||||
|
| ||
| ||
| ||
| ||
| ||
| ||
| ||
| ||
| ||
| ||
| ||
| ||
| ||
|
\n\n |
\n\n |
[Quoting: quote and ’](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=quote.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [quote](#%28form._%28%28quote._~23~25kernel%29._quote%29%29).\n\n> \n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
| ([#%variable-reference](#%28form._%28%28quote._~23~25kernel%29._~23~25variable-reference%29%29) ([#%top](__top.html#%28form._%28%28quote._~23~25kernel%29._~23~25top%29%29) . id)) |
| ([#%variable-reference](#%28form._%28%28quote._~23~25kernel%29._~23~25variable-reference%29%29)) |
[Function Calls](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=application.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces procedure applications.\n\n> ```\nsyntax\n\n(proc-expr arg ...)\n```"}
{"text": "### 2.5 Notation for Parameter Documentation\n(parameter)\t→```\nCombines [letrec-syntaxes](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._letrec-syntaxes%29%29) with a variant of [letrec-values](#%28form._%28%28quote._~23~25kernel%29._letrec-values%29%29): each trans-id and val-id is bound in all trans-exprs and val-exprs.\nThe [letrec-syntaxes+values](#%28form._%28%28quote._~23~25kernel%29._letrec-syntaxes%2Bvalues%29%29) form is the core form for local compile-time bindings, since forms like [letrec-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._letrec-syntax%29%29) and [internal-definition contexts](syntax-model.html#%28tech._internal._definition._context%29) expand to it. In a fully expanded expression (see [Fully Expanded Programs](syntax-model.html#%28part._fully-expanded%29)), the trans-id bindings are discarded and the form reduces to a combination of [letrec-values](#%28form._%28%28quote._~23~25kernel%29._letrec-values%29%29) or [let-values](#%28form._%28%28quote._~23~25kernel%29._let-values%29%29)."}
{"text": "### 2.5 Notation for Parameter Documentation\nFor variables bound by [letrec-syntaxes+values](#%28form._%28%28quote._~23~25kernel%29._letrec-syntaxes%2Bvalues%29%29), the [location](eval-model.html#%28tech._location%29)-creation rules differ slightly from [letrec-values](#%28form._%28%28quote._~23~25kernel%29._letrec-values%29%29). The \\[(val-id [...](stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29)) val-expr\\] binding clauses are partitioned into minimal sets of clauses that satisfy the following rule: if a clause has a val-id binding that is referenced (in a full expansion) by the val-expr of an earlier clause, the two clauses and all in between are in the same set. If a set consists of a single clause whose val-expr does not refer to any of the clause’s val-ids, then [locations](eval-model.html#%28tech._location%29) for the val-ids are created after the val-expr is evaluated. Otherwise, [locations](eval-model.html#%28tech._location%29) for all val-ids in a set are created just before the first val-expr in the set is evaluated. For the purposes of forming sets, a ([quote-syntax](Syntax_Quoting__quote-syntax.html#%28form._%28%28quote._~23~25kernel%29._quote-syntax%29%29) datum #:local) form counts as a reference to all bindings in the [letrec-syntaxes+values](#%28form._%28%28quote._~23~25kernel%29._letrec-syntaxes%2Bvalues%29%29) form"}
{"text": "### 2.5 Notation for Parameter Documentation\nThe end result of the [location](eval-model.html#%28tech._location%29)-creation rules is that scoping and evaluation order are the same as for [letrec-values](#%28form._%28%28quote._~23~25kernel%29._letrec-values%29%29), but the compiler has more freedom to optimize away [location](eval-model.html#%28tech._location%29) creation. The rules also correspond to a nesting of [let-values](#%28form._%28%28quote._~23~25kernel%29._let-values%29%29) and [letrec-values](#%28form._%28%28quote._~23~25kernel%29._letrec-values%29%29), which is how [letrec-syntaxes+values](#%28form._%28%28quote._~23~25kernel%29._letrec-syntaxes%2Bvalues%29%29) for a fully-expanded expression.\nSee also [local](local.html#%28form._%28%28lib._racket%2Flocal..rkt%29._local%29%29), which supports local bindings with [define](define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29), [define-syntax](define.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29), and more.\n------------------------------------------------------------------------"}
{"text": "# 3.10 Local Definitions: local"}
{"text": "### 3.10 Local Definitions: [local](#%28form._%28%28lib._racket%2Flocal..rkt%29._local%29%29)\n| | |\n|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------:|\n| ([require](require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._require%29%29) [racket/local]()) | package: [base](https://pkgs.racket-lang.org/package/base \"Install this package using `raco pkg install base`\") |\nThe bindings documented in this section are provided by the [racket/local]() and [racket](index.html) libraries, but not [racket/base](index.html).\n> \n |
\n |
[Conditionals](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=conditionals.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces conditionals.\n> \n |
\n | ||||||||||||||||||||
|
[Chaining Tests: cond](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=conditionals.html%23%2528part._cond%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [cond](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._cond%29%29).\nA cond-clause that starts with [else](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._else%29%29) must be the last cond-clause.\nIf no cond-clauses are present, the result is [#\n |
\n |
\n |
[Combining Tests: and and or](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=conditionals.html%23%2528part._and%252Bor%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [and](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29).\nIf no exprs are provided, then result is #t."}
{"text": "### 3.12 Conditionals: [if](#%28form._%28%28quote._~23~25kernel%29._if%29%29), [cond](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._cond%29%29), [and](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29), and [or](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._or%29%29)\nIf a single expr is provided, then it is in tail position, so the results of the [and](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29) expression are the results of the expr.\nOtherwise, the first expr is evaluated. If it produces #f, the result of the [and](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29) expression is #f. Otherwise, the result is the same as an [and](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29) expression with the remaining exprs in tail position with respect to the original [and](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29) form.\nExamples:\n> ```racket\n> > ( and )\n> #t\n> > ( and 1 )\n> 1\n> > ( and ( values 1 2 ) )\n> 1 2\n> > ( and #f ( error \"doesn't get here\" ) )\n> #f\n> > ( and #t 5 )\n> 5\n> ```\n> \n |
[Combining Tests: and and or](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=conditionals.html%23%2528part._and%252Bor%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [or](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._or%29%29).\nIf no exprs are provided, then result is #f.\nIf a single expr is provided, then it is in tail position, so the results of the [or](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._or%29%29) expression are the results of the expr.\nOtherwise, the first expr is evaluated. If it produces a value other than #f, that result is the result of the [or](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._or%29%29) expression. Otherwise, the result is the same as an [or](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._or%29%29) expression with the remaining exprs in tail position with respect to the original [or](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._or%29%29) form.\nExamples:"}
{"text": "### 3.12 Conditionals: [if](#%28form._%28%28quote._~23~25kernel%29._if%29%29), [cond](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._cond%29%29), [and](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29), and [or](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._or%29%29)\n> ```racket\n> > ( or )\n> #f\n> > ( or 1 )\n> 1\n> > ( or ( values 1 2 ) )\n> 1 2\n> > ( or 5 ( error \"doesn't get here\" ) )\n> 5\n> > ( or #f 5 )\n> 5\n> ```\n------------------------------------------------------------------------"}
{"text": "# 3.13 Dispatch: case"}
{"text": "### 3.13 Dispatch: [case](#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._case%29%29)\n> \n | ||||||||||
|
| |
| |
| |
|
[Definitions: define](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=define.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces definitions.\n> \n | ||||||||||||||||||||||||||||||||||||||||||||||||||
| ([define](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29) (head args) body ...+) | ||||||||||||||||||||||||||||||||||||||||||||||||||
|
\n |
\n |
| ([define-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29) (head args) body ...+) |
\n |
\n |
| ([define-for-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-for-syntax%29%29) (head args) body ...+) |
\n |
\n |
| ([define-require-syntax](#%28form._%28%28lib._racket%2Frequire-syntax..rkt%29._define-require-syntax%29%29) (id args ...) body ...+) |
\n\n |
| (define-provide-syntax (id args ...) body ...+) |
[Sequencing](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=begin.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [begin](#%28form._%28%28quote._~23~25kernel%29._begin%29%29) and [begin0](#%28form._%28%28quote._~23~25kernel%29._begin0%29%29).\n\n> \n\n |
| ([begin](#%28form._%28%28quote._~23~25kernel%29._begin%29%29) expr ...+) |
\n\n |
\n\n |
[Effects If...: when and unless](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=begin.html%23%2528part._when%252Bunless%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [when](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._when%29%29) and [unless](#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._unless%29%29).\n\n> \n\n |
\n\n |
[Assignment: set!](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=set_.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [set!](#%28form._%28%28quote._~23~25kernel%29._set%21%29%29).\n\n> \n\n |
\n\n |
[Iterations and Comprehensions](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=for.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces iterations and comprehensions.\n\nThe [for](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29) iteration forms are based on SRFI-42 \\[[SRFI-42](doc-bibliography.html#%28cite._.S.R.F.I-42%29)\\].\n\n#### 3.18.1 Iteration and Comprehension Forms\n\n> \n\n | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
\n\n |
\n\n | |||||||||||||||
| |||||||||||||||
|
| |
| |
| |
|
\n\n |
\n\n |
|
|
\n |
\n |
See also for/stream for a more convenient (albeit less flexible) way to lazily transform infinite sequences. (Internally, for/stream is defined in terms of for/foldr.)\n\nExamples:\n\n> ```racket\n> > ( define squares ( for/foldr ( [ s empty-stream ] #:delay ) ( [ n ( in-naturals ) ] ) ( stream-cons ( * n n ) ( force s ) ) ) )\n> > ( stream → list ( stream-take squares 10 ) )\n> '(0 1 4 9 16 25 36 49 64 81)\n> ```\n\nThe suspension introduced by the #:delay option does not ordinarily affect the loop’s eventual return value, but if #:delay and #:result are combined, the accum-ids will be delayed in the scope of the result-expr in the same way they are delayed within the loop body. This can be used to introduce an additional layer of suspension around the evaluation of the entire loop, if desired.\n\nExamples:\n\n> ```racket\n> > ( define evaluated-yet? #f )\n> > ( for/foldr ( [ acc ( set! evaluated-yet? #t ) ] #:delay ) ( ) ( force acc ) )\n> > evaluated-yet?\n> #t\n> ```\n\n> ```racket\n> > ( define evaluated-yet? #f )\n> > ( define start ( for/foldr ( [ acc ( set! evaluated-yet? #t ) ] #:delay #:result acc ) ( ) ( force acc ) ) )\n> > evaluated-yet?\n> #f\n> > ( force start )\n> > evaluated-yet?\n> #t\n> ```\n\nIf the #:delay-as option is provided, then delayed-id is bound to an additional promise that returns the values of all accum-ids at once. When multiple accum-ids are provided, forcing this promise can be slightly more efficient than forcing the promises bound to the accum-ids individually.\n\nIf the #:delay-with option is provided, the given delayer-id is used to suspend nested iterations (instead of the default, delay). A form of the shape (delayer-id recur-expr) is constructed and placed in expression position, where recur-expr is an expression that, when evaluated, will perform the next iteration and return its result (or results). Sensible choices for delayer-id include lazy, delay/sync, delay/thread, or any of the other promise constructors from racket/promise, as well as thunk from racket/function. However, beware that choices such as thunk or delay/name may evaluate their subexpression multiple times, which can lead to nonsensical results for sequences that have state, as the state will be shared between all evaluations of the recur-expr.\n\nIf multiple accum-ids are given, the #:delay-with option is provided, and delayer-id is not bound to one of delay, lazy, delay/strict, delay/sync, delay/thread, or delay/idle, the accum-ids will not be bound at all, even within the loop body. Instead, the #:delay-as option must be specified to access the accumulator values via delayed-id.\n\nAdded in version 7.3.0.3 of package base.\n\n> \n\n |
\n\n | ||||||||||
|
\n |
\n\n |
Continuation Marks provides more information on continuation marks.\n\n------------------------------------------------------------------------\n\n# 3.20 Quasiquoting: quasiquote, unquote, and unquote-splicing\n\n### 3.20 Quasiquoting: quasiquote, unquote, and unquote-splicing\n\n> > > Quasiquoting: quasiquote and ‘ in The Racket Guide introduces quasiquote.\n\n> \n\n |
\n\n |
\n\n |
\n\n |
| (quote-syntax datum #:local) |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n | ||||||||||||||||||||||||||||||||||||||||||||||||||
| (define-inline (head args) body ...+) | ||||||||||||||||||||||||||||||||||||||||||||||||||
|
\n\n | ||||||||||
|
\n\n | ||||||||||
|
Built-In Datatypes in The Racket Guide introduces Datatypes.\n\nEach pre-defined datatype comes with a set of procedures for manipulating instances of the datatype.\n\n| |\n|-------------------------------------------------------------------------------------|\n| 4.1 Equality |\n| 4.2 Booleans |\n| 4.3 Numbers |\n| 4.4 Strings |\n| 4.5 Byte Strings |\n| 4.6 Characters |\n| 4.7 Symbols |\n| 4.8 Regular Expressions |\n| 4.9 Keywords |\n| 4.10 Pairs and Lists |\n| 4.11 Mutable Pairs and Lists |\n| 4.12 Vectors |\n| 4.13 Stencil Vectors |\n| 4.14 Boxes |\n| 4.15 Hash Tables |\n| 4.16 Treelists |\n| 4.17 Sequences and Streams |\n| 4.18 Dictionaries |\n| 4.19 Sets |\n| 4.20 Procedures |\n| 4.21 Void |\n| 4.22 Undefined |\n\n------------------------------------------------------------------------\n\n# 4.1 Equality\n\n8.18.0.13\n\n### 4.1 Equality\n\nEquality is the concept of whether two values are “the same.” Racket supports a few different kinds of equality by default, although equal? is preferred for most uses.\n\n> ```\n(equal? v1 v2) → boolean?\n v1 : any/c\n v2 : any/c```\n\n\nTwo values are [equal?](#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) if and only if they are [eqv?](#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29), unless otherwise specified for a particular datatype.\n\nDatatypes with further specification of [equal?](#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) include strings, byte strings, pairs, mutable pairs, vectors, boxes, hash tables, and inspectable structures. In the last six cases, equality is recursively defined; if both v1 and v2 contain reference cycles, they are equal when the infinite unfoldings of the values would be equal. See also [gen:equal+hash](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._gen~3aequal%2Bhash%29%29) and [prop:impersonator-of](chaperones.html#%28def._%28%28quote._~23~25kernel%29._prop~3aimpersonator-of%29%29).\n\nExamples:\n\n> ```racket\n> > ( equal? ' yes ' yes )\n> #t\n> > ( equal? ' yes ' no )\n> #f\n> > ( equal? ( * 6 7 ) 42 )\n> #t\n> > ( equal? ( expt 2 100 ) ( expt 2 100 ) )\n> #t\n> > ( equal? 2 2.0 )\n> #f\n> > ( let ( [ v ( mcons 1 2 ) ] ) ( equal? v v ) )\n> #t\n> > ( equal? ( mcons 1 2 ) ( mcons 1 2 ) )\n> #t\n> > ( equal? ( integer->char 955 ) ( integer->char 955 ) )\n> #t\n> > ( equal? ( make-string 3 #\\z ) ( make-string 3 #\\z ) )\n> #t\n> > ( equal? #t #t )\n> #t\n> ```\n\n> ```\n(equal-always? v1 v2) → boolean?\n v1 : any/c\n v2 : any/c\n```"}
{"text": "### 3.14 Definitions: [define](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29), [define-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29), ...\nIndicates whether v1 and v2 are equal and will always stay equal independent of mutations. Generally, for two values to be equal-always, corresponding immutable values within v1 and v2 must be equal?, while corresponding mutable values within them must be eq?. Precedents for this operator in other languages include egal \\[Baker93\\].\nTwo values v1 and v2 are equal-always? if and only if there exists a third value v3 such that v1 and v2 are both chaperones of v3, meaning (chaperone-of? v1 v3) and (chaperone-of? v2 v3) are both true.\nFor values that include no chaperones or other impersonators, v1 and v2 can be considered equal-always if they are equal?, except that corresponding mutable vectors, boxes, hash tables, strings, byte strings, mutable pairs, and mutable structures within v1 and v2 must be eq?, and equality on structures can be specialized for equal-always? through gen:equal-mode+hash.\nExamples:"}
{"text": "### 3.14 Definitions: [define](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29), [define-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29), ...\n> ```racket\n> > ( equal-always? ' yes ' yes )\n> #t\n> > ( equal-always? ' yes ' no )\n> #f\n> > ( equal-always? ( * 6 7 ) 42 )\n> #t\n> > ( equal-always? ( expt 2 100 ) ( expt 2 100 ) )\n> #t\n> > ( equal-always? 2 2.0 )\n> #f\n> > ( equal-always? ( list 1 2 ) ( list 1 2 ) )\n> #t\n> > ( let ( [ v ( mcons 1 2 ) ] ) ( equal-always? v v ) )\n> #t\n> > ( equal-always? ( mcons 1 2 ) ( mcons 1 2 ) )\n> #f\n> > ( equal-always? ( integer → char 955 ) ( integer → char 955 ) )\n> #t\n> > ( equal-always? ( make-string 3 #\\z ) ( make-string 3 #\\z ) )\n> #f\n> > ( equal-always? ( string → immutable-string ( make-string 3 #\\z ) ) ( string → immutable-string ( make-string 3 #\\z ) ) )\n> #t\n> > ( equal-always? #t #t )\n> #t\n> ```\nAdded in version 8.5.0.3 of package base.\n> ```\n(eqv? v1 v2) → boolean?\n v1 : any/c\n v2 : any/c```\nTwo values are [eqv?](#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29) if and only if they are [eq?](#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29), unless otherwise specified for a particular datatype."}
{"text": "### 3.14 Definitions: [define](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29), [define-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29), ...\nThe [number](numbers.html#%28tech._number%29) and [character](characters.html#%28tech._character%29) datatypes are the only ones for which [eqv?](#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29) differs from [eq?](#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29). Two numbers are [eqv?](#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29) when they have the same exactness, precision, and are both equal and non-zero, both +0.0, both +0.0f0, both -0.0, both -0.0f0, both +nan.0, or both +nan.f—considering real and imaginary components separately in the case of [complex numbers](numbers.html#%28tech._complex._number%29). Two characters are [eqv?](#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29) when their [char->integer](characters.html#%28def._%28%28quote._~23~25kernel%29._char-~3einteger%29%29) results are equal.\nGenerally, [eqv?](#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29) is identical to [equal?](#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) except that the former cannot recursively compare the contents of compound data types (such as lists and structs) and cannot be customized by user-defined data types. The use of [eqv?](#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29) is lightly discouraged in favor of [equal?](#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29).\nExamples:"}
{"text": "### 3.14 Definitions: [define](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29), [define-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29), ...\n> ```racket\n> > ( eqv? ' yes ' yes )\n> #t\n> > ( eqv? ' yes ' no )\n> #f\n> > ( eqv? ( * 6 7 ) 42 )\n> #t\n> > ( eqv? ( expt 2 100 ) ( expt 2 100 ) )\n> #t\n> > ( eqv? 2 2.0 )\n> #f\n> > ( let ( [ v ( mcons 1 2 ) ] ) ( eqv? v v ) )\n> #t\n> > ( eqv? ( mcons 1 2 ) ( mcons 1 2 ) )\n> #f\n> > ( eqv? ( integer->char 955 ) ( integer->char 955 ) )\n> #t\n> > ( eqv? ( make-string 3 #\\z ) ( make-string 3 #\\z ) )\n> #f\n> > ( eqv? #t #t )\n> #t\n> ```\n> ```\n(eq? v1 v2) → boolean?\n v1 : any/c\n v2 : any/c"}
{"text": "### 3.14 Definitions: [define](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29), [define-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29), ...\n```\nReturn #t if v1 and v2 refer to the same object, #f otherwise. As a special case among numbers, two fixnums that are = are also the same according to eq?. See also Object Identity and Comparisons.\n\nExamples:\n\n> ```racket\n> > ( eq? ' yes ' yes )\n> #t\n> > ( eq? ' yes ' no )\n> #f\n> > ( eq? ( * 6 7 ) 42 )\n> #t\n> > ( eq? ( expt 2 100 ) ( expt 2 100 ) )\n> #f\n> > ( eq? 2 2.0 )\n> #f\n> > ( let ( [ v ( mcons 1 2 ) ] ) ( eq? v v ) )\n> #t\n> > ( eq? ( mcons 1 2 ) ( mcons 1 2 ) )\n> #f\n> > ( eq? ( integer → char 955 ) ( integer → char 955 ) )\n> #t\n> > ( eq? ( make-string 3 #\\z ) ( make-string 3 #\\z ) )\n> #f\n> > ( eq? #t #t )\n> #t\n> ```\n\n> ```\n(equal?/recur v1 v2 recur-proc) → boolean?\n v1 : any/c\n v2 : any/c\n recur-proc : (any/c any/c . → . any/c)```\n\n\nLike [equal?](#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29), but using recur-proc for recursive comparisons (which means that reference cycles are not handled automatically). Non-#f results from recur-proc are converted to #t before being returned by [equal?/recur](#%28def._%28%28quote._~23~25kernel%29._equal~3f%2Frecur%29%29).\n\nExamples:\n\n> ```racket\n> > ( equal?/recur 1 1 ( lambda ( a b ) #f ) )\n> #t\n> > ( equal?/recur ' ( 1 ) ' ( 1 ) ( lambda ( a b ) #f ) )\n> #f\n> > ( equal?/recur ' # ( 1 1 1 ) ' # ( 1 1.2 3/4 ) ( lambda ( a b ) ( <= ( abs ( - a b ) ) 0.25 ) ) )> #t\n> ```\n\n> ```\n(equal-always?/recur v1 v2 recur-proc) → boolean?\n v1 : any/c\n v2 : any/c\n recur-proc : (any/c any/c . → . any/c)\n```"}
{"text": "### 3.14 Definitions: [define](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29), [define-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29), ...\nLike equal-always?, but using recur-proc for recursive comparisons (which means that reference cycles are not handled automatically). Non-#f results from recur-proc are converted to #t before being returned by equal-always?/recur.\nExamples:\n> ```racket\n> > ( equal-always?/recur 1 1 ( lambda ( a b ) #f ) )\n> #t\n> > ( equal-always?/recur ' ( 1 ) ' ( 1 ) ( lambda ( a b ) #f ) )\n> #f\n> > ( equal-always?/recur ( vector-immutable 1 1 1 ) ( vector-immutable 1 1.2 3/4 ) ( lambda ( a b ) ( <= ( abs ( - a b ) ) 0.25 ) ) )> #t\n> ```"}
{"text": "#### 4.1.1 Object Identity and Comparisons\nThe eq? operator compares two values, returning #t when the values refer to the same object. This form of equality is suitable for comparing objects that support imperative update (e.g., to determine that the effect of modifying an object through one reference is visible through another reference). Also, an eq? test evaluates quickly, and eq?-based hashing is more lightweight than equal?-based hashing in hash tables.\nIn some cases, however, eq? is unsuitable as a comparison operator, because the generation of objects is not clearly defined. In particular, two applications of + to the same two exact integers may or may not produce results that are eq?, although the results are always equal?. Similarly, evaluation of a lambda form typically generates a new procedure object, but it may re-use a procedure object previously generated by the same source lambda form.\nThe behavior of a datatype with respect to eq? is generally specified with the datatype and its associated procedures."}
{"text": "#### 4.1.2 Equality and Hashing\nAll comparable values have at least one hash code — an arbitrary integer (more specifically a fixnum) computed by applying a hash function to the value. The defining property of these hash codes is that equal values have equal hash codes. Note that the reverse is not true: two unequal values can still have equal hash codes. Hash codes are useful for various indexing and comparison operations, especially in the implementation of hash tables. See Hash Tables for more information.\n> ```\n(equal-hash-code v) → fixnum?\n v : any/c```\nReturns a [hash code](#%28tech._hash._code%29) consistent with [equal?](#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29). For any two calls with [equal?](#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) values, the returned number is the same. A hash code is computed even when v contains a cycle through pairs, vectors, boxes, and/or inspectable structure fields. Additionally, user-defined data types can customize how this hash code is computed by implementing [gen:equal+hash](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._gen~3aequal%2Bhash%29%29) or [gen:equal-mode+hash](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._gen~3aequal-mode%2Bhash%29%29)."}
{"text": "### 3.14 Definitions: [define](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29), [define-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29), ...\nFor any v that could be produced by [read](Reading.html#%28def._%28%28quote._~23~25kernel%29._read%29%29), if v2 is produced by [read](Reading.html#%28def._%28%28quote._~23~25kernel%29._read%29%29) for the same input characters, the ([equal-hash-code](#%28def._%28%28quote._~23~25kernel%29._equal-hash-code%29%29) v) is the same as ([equal-hash-code](#%28def._%28%28quote._~23~25kernel%29._equal-hash-code%29%29) v2) — even if v and v2 do not exist at the same time (and therefore could not be compared by calling [equal?](#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29)).\nChanged in version 6.4.0.12 of package base: Strengthened guarantee for [read](Reading.html#%28def._%28%28quote._~23~25kernel%29._read%29%29)able values.\n> ```\n(equal-hash-code/recur v recur-proc) → fixnum?\n v : any/c\n recur-proc : ( → any/c exact-integer?)"}
{"text": "### 3.14 Definitions: [define](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29), [define-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29), ...\n```\nLike equal-hash-code, but using recur-proc for recursive hashing within v.\n\nExamples:\n\n> ```racket\n> > ( define ( rational-hash x ) ( cond [ ( rational? x ) ( equal-hash-code ( inexact → exact x ) ) ] [ else ( equal-hash-code/recur x rational-hash ) ] ) )\n> > ( = ( rational-hash 0.0 ) ( rational-hash -0 .0 ) )\n> #t\n> > ( = ( rational-hash 1.0 ) ( rational-hash -1 .0 ) )\n> #f\n> > ( = ( rational-hash ( list ( list ( list 4.0 0.0 ) 9.0 ) 6.0 ) ) ( rational-hash ( list ( list ( list 4 0 ) 9 ) 6 ) ) )\n> #t\n> ```\n\nAdded in version 8.8.0.9 of package base.\n\n> ```\n(equal-secondary-hash-code v) → fixnum?\n v : any/c```\n\n\nLike [equal-hash-code](#%28def._%28%28quote._~23~25kernel%29._equal-hash-code%29%29), but computes a secondary [hash code](#%28tech._hash._code%29) suitable for use in double hashing.\n\n> ```\n(equal-always-hash-code v) → fixnum?\n v : any/c\n```\nReturns a hash code consistent with equal-always?. For any two calls with equal-always? values, the returned number is the same.\nAs equal-always-hash-code traverses v, immutable values within v are hashed with equal-hash-code, while mutable values within v are hashed with eq-hash-code.\n> ```\n(equal-always-hash-code/recur v recur-proc) → fixnum?\n v : any/c\n recur-proc : ( → any/c exact-integer?)```"}
{"text": "### 3.14 Definitions: [define](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define%29%29), [define-syntax](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._define-syntax%29%29), ...\nLike [equal-always-hash-code](#%28def._%28%28quote._~23~25kernel%29._equal-always-hash-code%29%29), but using recur-proc for recursive hashing within v.\nAdded in version 8.8.0.9 of package base.\n> ```\n(equal-always-secondary-hash-code v) → fixnum?\n v : any/c\n```\nLike equal-always-hash-code, but computes a secondary hash code suitable for use in double hashing.\n\n> ```\n(eq-hash-code v) → fixnum?\n v : any/c```\n\n\nReturns a [hash code](#%28tech._hash._code%29) consistent with [eq?](#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29). For any two calls with [eq?](#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29) values, the returned number is the same.\n\n> > > Equal [fixnums](numbers.html#%28tech._fixnum%29) are always [eq?](#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29).\n\n> ```\n(eqv-hash-code v) → fixnum?\n v : any/c\n```\nReturns a hash code consistent with eqv?. For any two calls with eqv? values, the returned number is the same."}
{"text": "#### 4.1.3 Implementing Equality for Custom Types\n> \n |
\n |
\n |
|
|
|
|
\n |
\n |
\n |
\n |
\n |
Numbers in The Racket Guide introduces numbers.\n\nAll numbers are complex numbers. Some of them are real numbers, and all of the real numbers that can be represented are also rational numbers, except for +inf.0 (positive infinity), +inf.f (single-precision variant, when enabled via read-single-flonum), -inf.0 (negative infinity), -inf.f (single-precision variant, when enabled), +nan.0 (not-a-number), and +nan.f (single-precision variant, when enabled). Among the rational numbers, some are integers, because round applied to the number produces the same number.\n\n> > > See Reading Numbers for information on the syntax of number literals.\n\nOrthogonal to those categories, each number is also either an exact number or an inexact number. Unless otherwise specified, computations that involve an inexact number produce inexact results. Certain operations on inexact numbers, however, produce an exact number, such as multiplying an inexact number with an exact 0. Operations that mathematically produce irrational numbers for some rational arguments (e.g., sqrt) may produce inexact results even for exact arguments.\n\nIn the case of complex numbers, either the real and imaginary parts are both exact or inexact with the same precision, or the number has an exact zero real part and an inexact imaginary part; a complex number with an exact zero imaginary part is a real number.\n\nInexact real numbers are implemented as double-precision IEEE floating-point numbers, also known as flonums, or as single-precision IEEE floating-point numbers, also known as single-flonums. Single-flonums are supported only when (single-flonum-available?) reports #t. Although we write +inf.f, -inf.f, and +nan.f to mean single-flonums, those forms read as double-precision flonums by default, since read-single-flonum is #f by default. When single-flonums are supported, inexact numbers are still represented as flonums by default, and single precision is used only when a computation starts with single-flonums.\n\nInexact numbers can be coerced to exact form, except for the inexact numbers +inf.0, +inf.f, -inf.0, -inf.f, +nan.0, and +nan.f, which have no exact form. Dividing a number by exact zero raises an exception; dividing a non-zero number other than +nan.0 or +nan.f by an inexact zero returns +inf.0, +inf.f, -inf.0 or -inf.f, depending on the sign and precision of the dividend. The +nan.0 value is not = to itself, but +nan.0 is eqv? to itself, and +nan.f is similarly eqv? but not = to itself. Conversely, (= 0.0 -0.0) is #t, but (eqv? 0.0 -0.0) is #f, and the same for 0.0f0 and -0.0f0 (which are single-precision variants). The datum -nan.0 refers to the same constant as +nan.0, and -nan.f is the same as +nan.f.\n\nCalculations with infinities produce results consistent with IEEE double- or single-precision floating point where IEEE specifies the result; in cases where IEEE provides no specification, the result corresponds to the limit approaching infinity, or +nan.0 or +nan.f if no such limit exists.\n\nThe precision and size of exact numbers is limited only by available memory (and the precision of operations that can produce irrational numbers). In particular, adding, multiplying, subtracting, and dividing exact numbers always produces an exact result.\n\nA fixnum is an exact integer whose two’s complement representation fits into 30 or 31 bits (depending on the Racket variant) on a 32-bit platform or 61 or 63 bits (depending on the Racket variant) on a 64-bit platform. No allocation is required when computing with fixnums. See also the racket/fixnum module, below.\n\nTwo fixnums that are = are also the same according to eq?. Otherwise, the result of eq? applied to two numbers is undefined, except that numbers produced by the default reader in read-syntax mode are interned and therefore eq? when they are eqv?.\n\nTwo real numbers are eqv? when they are both inexact with the same precision or both exact, and when they are = (except for +nan.0, +nan.f, 0.0, +0.0f0, -0.0, and -0.0f0, as noted above). Two complex numbers are eqv? when their real and imaginary parts are eqv?. Two numbers are equal? when they are eqv?.\n\nSee Reading Numbers for information on reading numbers and Printing Numbers for information on printing numbers.\n\n| |\n|----------------------------------------------------------------------------------------------------------------------------------------------|\n| 4.3.1 Number Types |\n| 4.3.2 Generic Numerics |\n| 4.3.2.1 Arithmetic |\n| 4.3.2.2 Number Comparison |\n| 4.3.2.3 Powers and Roots |\n| 4.3.2.4 Trigonometric Functions |\n| 4.3.2.5 Complex Numbers |\n| 4.3.2.6 Bitwise Operations |\n| 4.3.2.7 Random Numbers |\n| 4.3.2.8 Other Randomness Utilities |\n| 4.3.2.9 Number–String Conversions |\n| 4.3.2.10 Extra Constants and Functions |\n| 4.3.3 Flonums |\n| 4.3.3.1 Flonum Arithmetic |\n| 4.3.3.2 Flonum Vectors |\n| 4.3.4 Fixnums |\n| 4.3.4.1 Fixnum Arithmetic |\n| 4.3.4.2 Fixnum Vectors |\n| 4.3.4.3 Fixnum Range |\n| 4.3.5 Extflonums |\n| 4.3.5.1 Extflonum Arithmetic |\n| 4.3.5.2 Extflonum Constants |\n| 4.3.5.3 Extflonum Vectors |\n| 4.3.5.4 Extflonum Byte Strings |\n\n------------------------------------------------------------------------\n\n# 4.3.1 Number Types\n\n#### 4.3.1 Number Types\n\n> ```\n(number? v) → boolean?\n v : any/c```\n\n\nReturns #t if v is a number, #f otherwise.\n\nExamples:\n\n> ```racket\n> > ( number? 1 )\n> #t\n> > ( number? 2+3i )\n> #t\n> > ( number? \"hello\" )\n> #f\n> > ( number? +nan.0 )\n> #t\n> ```\n\n> ```\n(complex? v) → boolean?\n v : any/c\n```"}
{"text": "# 4.2 Booleans\nReturns (number? v), because all numbers are complex numbers.\n> ```\n(real? v) → boolean?\n v : any/c```\nReturns #t if v is a [real number](numbers.html#%28tech._real._number%29), #f otherwise.\nExamples:\n> ```racket\n> > ( real? 1 )\n> #t\n> > ( real? +inf.0 )\n> #t\n> > ( real? 2+3i )\n> #f\n> > ( real? 2.0+0.0i )\n> #f\n> > ( real? \"hello\" )\n> #f\n> ```\n> ```\n(rational? v) → boolean?\n v : any/c\n```\nReturns #t if v is a rational number, #f otherwise.\n\nExamples:\n\n> ```racket\n> > ( rational? 1 )\n> #t\n> > ( rational? +inf.0 )\n> #f\n> > ( rational? \"hello\" )\n> #f\n> ```\n\n> ```\n(integer? v) → boolean?\n v : any/c```\n\n\nReturns #t if v is a number that is an [integer](numbers.html#%28tech._integer%29), #f otherwise.\n\nExamples:\n\n> ```racket\n> > ( integer? 1 )\n> #t\n> > ( integer? 2.3 )\n> #f\n> > ( integer? 4.0 )\n> #t\n> > ( integer? +inf.0 )\n> #f\n> > ( integer? 2+3i )\n> #f\n> > ( integer? \"hello\" )\n> #f\n> ```\n\n> ```\n(exact-integer? v) → boolean?\n v : any/c\n```\nReturns (and (integer? v) (exact? v)).\nExamples:\n> ```racket\n> > ( exact-integer? 1 )\n> #t\n> > ( exact-integer? 4.0 )\n> #f\n> ```\n> ```\n(exact-nonnegative-integer? v) → boolean?\n v : any/c```\nReturns ([and](if.html#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29) ([exact-integer?](#%28def._%28%28quote._~23~25kernel%29._exact-integer~3f%29%29) v) ([not](booleans.html#%28def._%28%28quote._~23~25kernel%29._not%29%29) ([negative?](#%28def._%28%28quote._~23~25kernel%29._negative~3f%29%29) v))).\nExamples:"}
{"text": "# 4.2 Booleans\n> ```racket\n> > ( exact-nonnegative-integer? 0 )\n> #t\n> > ( exact-nonnegative-integer? -1 )\n> #f\n> ```\n> ```\n(exact-positive-integer? v) → boolean?\n v : any/c\n```\nReturns (and (exact-integer? v) (positive? v)).\n\nExamples:\n\n> ```racket\n> > ( exact-positive-integer? 1 )\n> #t\n> > ( exact-positive-integer? 0 )\n> #f\n> ```\n\n> ```\n(inexact-real? v) → boolean?\n v : any/c```\n\n\nReturns ([and](if.html#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29) ([real?](#%28def._%28%28quote._~23~25kernel%29._real~3f%29%29) v) ([inexact?](#%28def._%28%28quote._~23~25kernel%29._inexact~3f%29%29) v)).\n\n> ```\n(fixnum? v) → boolean?\n v : any/c\n```\nReturn #t if v is a fixnum, #f otherwise.\nNote: the result of this function is platform-dependent, so using it in syntax transformers can lead to platform-dependent bytecode files. See also fixnum-for-every-system?.\n> ```\n(flonum? v) → boolean?\n v : any/c```\nReturn #t if v is a [flonum](numbers.html#%28tech._flonum%29), #f otherwise.\n> ```\n(double-flonum? v) → boolean?\n v : any/c\n```\nIdentical to flonum?.\n\n> ```\n(single-flonum? v) → boolean?\n v : any/c```\n\n\nReturn #t if v is a [single-flonum](numbers.html#%28tech._single._flonum%29) (i.e., a single-precision floating-point number), #f otherwise.\n\n> ```\n(single-flonum-available?) → boolean?\n```\nReturns #t if single-flonums are supported on the current platform, #f otherwise.\nCurrently, single-flonum-available? produces #t when (system-type 'vm) produces 'racket, and single-flonum-available? produces #f otherwise."}
{"text": "# 4.2 Booleans\nIf the result is #f, then single-flonum? also produces #f for all arguments.\nAdded in version 7.3.0.5 of package base.\n> ```\n(zero? z) → boolean?\n z : number?```\nReturns ([=](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._~3d%29%29) 0 z).\nExamples:\n> ```racket\n> > ( zero? 0 )\n> #t\n> > ( zero? -0 .0 )\n> #t\n> ```\n> ```\n(positive? x) → boolean?\n x : real?\n```\nReturns (> x 0).\n\nExamples:\n\n> ```racket\n> > ( positive? 10 )\n> #t\n> > ( positive? -1 0 )\n> #f\n> > ( positive? 0.0 )\n> #f\n> ```\n\n> ```\n(negative? x) → boolean?\n x : real?```\n\n\nReturns ([<](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._~3c%29%29) x 0).\n\nExamples:\n\n> ```racket\n> > ( negative? 10 )\n> #f\n> > ( negative? -1 0 )\n> #t\n> > ( negative? -0 .0 )\n> #f\n> ```\n\n> ```\n(even? n) → boolean?\n n : integer?\n```\nReturns (zero? (modulo n 2)).\nExamples:\n> ```racket\n> > ( even? 10.0 )\n> #t\n> > ( even? 11 )\n> #f\n> > ( even? +inf.0 )\n> even?: contract violation\n> expected: integer?\n> given: +inf.0\n> ```\n> ```\n(odd? n) → boolean?\n n : integer?```\nReturns ([not](booleans.html#%28def._%28%28quote._~23~25kernel%29._not%29%29) ([even?](#%28def._%28%28quote._~23~25kernel%29._even~3f%29%29) n)).\nExamples:\n> ```racket\n> > ( odd? 10.0 )\n> #f\n> > ( odd? 11 )\n> #t\n> > ( odd? +inf.0 )\n> odd?: contract violation\n> expected: integer?\n> given: +inf.0\n> ```\n> ```\n(exact? z) → boolean?\n z : number?\n```\n\n\nReturns #t if z is an exact number, #f otherwise.\n\nExamples:\n\n> ```racket\n> > ( exact? 1 )\n> #t\n> > ( exact? 1.0 )\n> #f\n> ```\n\n> ```\n(inexact? z) → boolean?\n z : number?\n```"}
{"text": "# 4.2 Booleans\nReturns #t if z is an inexact number, #f otherwise.\nExamples:\n> ```racket\n> > ( inexact? 1 )\n> #f\n> > ( inexact? 1.0 )\n> #t\n> ```\n> ```\n(inexact → exact z) → exact?\n z : number?\n```\nCoerces z to an exact number. If z is already exact, it is returned. If z is +inf.0, -inf.0, +nan.0, +inf.f, -inf.f, or +nan.f, then the exn:fail:contract exception is raised.\n\nExamples:\n\n> ```racket\n> > ( inexact → exact 1 )\n> 1\n> > ( inexact → exact 1.0 )\n> 1\n> ```\n\n> ```\n(exact → inexact z) → inexact?\n z : number?```\n\n\nCoerces z to an inexact number. If z is already inexact, it is returned.\n\nExamples:\n\n> ```racket\n> > ( exact->inexact 1 )\n> 1.0\n> > ( exact->inexact 1.0 )\n> 1.0\n> ```\n\n> ```\n(real → single-flonum x) → single-flonum?\n x : real?\n```\nCoerces x to a single-precision floating-point number. If x is already a single-precision floating-point number, it is returned.\n> ```\n(real → double-flonum x) → flonum?\n x : real?\n```\n\n\nCoerces x to a double-precision floating-point number. If x is already a double-precision floating-point number, it is returned.\n\n------------------------------------------------------------------------\n\n# 4.3.2 Generic Numerics\n\n#### 4.3.2 Generic Numerics\n\nMost Racket numeric operations work on any kind of number.\n\n##### 4.3.2.1 Arithmetic\n\n> ```\n(+ z ...) → number?\n z : number?\n```\nReturns the sum of the zs, adding pairwise from left to right. If no arguments are provided, the result is 0.\nExamples:\n> ```racket\n> > ( + 1 2 )\n> 3\n> > ( + 1.0 2+3i 5 )\n> 8.0+3.0i\n> > ( + )\n> 0\n> ```\n> ```"}
{"text": "# 4.2 Booleans\n(- z) → number?\n z : number?\n(- z w ...+) → number?\n z : number?\n w : number?\n```\n\n\nWhen no ws are supplied, returns ([-](#%28def._%28%28quote._~23~25kernel%29._-%29%29) 0 z). Otherwise, returns the subtraction of the ws from z working pairwise from left to right.\n\nExamples:\n\n> ```racket\n> > ( - 5 3.0 )\n> 2.0\n> > ( - 1 )\n> -1\n> > ( - 2+7i 1 3 )\n> -2+7i\n> ```\n\n> ```\n(* z ...) → number?\n z : number?\n```\nReturns the product of the zs, multiplying pairwise from left to right. If no arguments are provided, the result is 1. Multiplying any number by exact 0 produces exact 0.\nExamples:\n> ```racket\n> > ( * 2 3 )\n> 6\n> > ( * 8.0 9 )\n> 72.0\n> > ( * 1+2i 3+4i )\n> -5+10i\n> ```\n> ```\n(/ z) → number?\n z : number?\n(/ z w ...+) → number?\n z : number?\n w : number?\n```\n\n\nWhen no ws are supplied, returns ([/](#%28def._%28%28quote._~23~25kernel%29._%2F%29%29) 1 z). Otherwise, returns the division of z by the ws working pairwise from left to right.\n\nIf z is exact 0 and no w is exact 0, then the result is exact 0. If any w is exact 0, the [exn:fail:contract:divide-by-zero](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract~3adivide-by-zero%29%29) exception is raised.\n\nExamples:\n\n> ```racket\n> > ( / 3 4 )\n> 3/4\n> > ( / 81 3 3 )\n> 9\n> > ( / 10.0 )\n> 0.1\n> > ( / 1+2i 3+4i )\n> 11/25+2/25i\n> ```\n\n> ```\n(quotient n m) → integer?\n n : integer?\n m : integer?\n```\nReturns (truncate (/ n m)).\nExamples:"}
{"text": "# 4.2 Booleans\n> ```racket\n> > ( quotient 10 3 )\n> 3\n> > ( quotient -1 0.0 3 )\n> -3.0\n> > ( quotient +inf.0 3 )\n> quotient: contract violation\n> expected: integer?\n> given: +inf.0\n> ```\n> ```\n(remainder n m) → integer?\n n : integer?\n m : integer?```\nReturns q with the same sign as n such that\n- ([abs](#%28def._%28%28quote._~23~25kernel%29._abs%29%29) q) is between 0 (inclusive) and ([abs](#%28def._%28%28quote._~23~25kernel%29._abs%29%29) m) (exclusive), and\n- ([+](#%28def._%28%28quote._~23~25kernel%29._%2B%29%29) q ([*](#%28def._%28%28quote._~23~25kernel%29._%2A%29%29) m ([quotient](#%28def._%28%28quote._~23~25kernel%29._quotient%29%29) n m))) equals n.\nIf m is exact 0, the [exn:fail:contract:divide-by-zero](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract~3adivide-by-zero%29%29) exception is raised.\nExamples:\n> ```racket\n> > ( remainder 10 3 )\n> 1\n> > ( remainder -1 0.0 3 )\n> -1.0\n> > ( remainder 10.0 -3 )\n> 1.0\n> > ( remainder -1 0 -3 )\n> -1\n> > ( remainder +inf.0 3 )\n> remainder: contract violation\n> expected: integer?\n> given: +inf.0\n> ```\n> ```\n(quotient/remainder n m) → integer? integer?\n n : integer?\n m : integer?"}
{"text": "# 4.2 Booleans\n```\nReturns (values (quotient n m) (remainder n m)), but the combination may be computed more efficiently than separate calls to quotient and remainder.\n\nExample:\n\n> ```racket\n> > ( quotient/remainder 10 3 )\n> 3 1\n> ```\n\n> ```\n(modulo n m) → integer?\n n : integer?\n m : integer?```\n\n\nReturns q with the same sign as m where\n\n- ([abs](#%28def._%28%28quote._~23~25kernel%29._abs%29%29) q) is between 0 (inclusive) and ([abs](#%28def._%28%28quote._~23~25kernel%29._abs%29%29) m) (exclusive), and\n\n- the difference between q and ([-](#%28def._%28%28quote._~23~25kernel%29._-%29%29) n ([*](#%28def._%28%28quote._~23~25kernel%29._%2A%29%29) m ([quotient](#%28def._%28%28quote._~23~25kernel%29._quotient%29%29) n m))) is a multiple of m.\n\nIf m is exact 0, the [exn:fail:contract:divide-by-zero](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract~3adivide-by-zero%29%29) exception is raised.\n\nExamples:\n\n> ```racket\n> > ( modulo 10 3 )\n> 1\n> > ( modulo -1 0.0 3 )\n> 2.0\n> > ( modulo 10.0 -3 )\n> -2.0\n> > ( modulo -1 0 -3 )\n> -1\n> > ( modulo +inf.0 3 )\n> modulo: contract violation\n> expected: integer?\n> given: +inf.0\n> ```\n\n> ```\n(add1 z) → number?\n z : number?\n```\nReturns (+ z 1).\n> ```\n(sub1 z) → number?\n z : number?```\nReturns ([-](#%28def._%28%28quote._~23~25kernel%29._-%29%29) z 1).\n> ```\n(abs x) → number?\n x : real?"}
{"text": "# 4.2 Booleans\n```\nReturns the absolute value of x.\n\nExamples:\n\n> ```racket\n> > ( abs 1.0 )\n> 1.0\n> > ( abs -1 )\n> 1\n> ```\n\n> ```\n(max x ...+) → real?\n x : real?```\n\n\nReturns the largest of the xs, or +nan.0 if any x is +nan.0. If any x is inexact, the result is coerced to inexact. See also [argmax](pairs.html#%28def._%28%28lib._racket%2Flist..rkt%29._argmax%29%29).\n\nExamples:\n\n> ```racket\n> > ( max 1 3 2 )\n> 3\n> > ( max 1 3 2.0 )\n> 3.0\n> ```\n\n> ```\n(min x ...+) → real?\n x : real?\n```\nReturns the smallest of the xs, or +nan.0 if any x is +nan.0. If any x is inexact, the result is coerced to inexact. See also argmin.\nExamples:\n> ```racket\n> > ( min 1 3 2 )\n> 1\n> > ( min 1 3 2.0 )\n> 1.0\n> ```\n> ```\n(gcd n ...) → rational?\n n : rational?```\nReturns the greatest common divisor (a non-negative number) of the ns; for non-integer ns, the result is the [gcd](#%28def._%28%28quote._~23~25kernel%29._gcd%29%29) of the numerators divided by the [lcm](#%28def._%28%28quote._~23~25kernel%29._lcm%29%29) of the denominators. If no arguments are provided, the result is 0. If all arguments are zero, the result is zero.\nExamples:\n> ```racket\n> > ( gcd 10 )\n> 10\n> > ( gcd 12 81.0 )\n> 3.0\n> > ( gcd 1/2 1/3 )\n> 1/6\n> ```\n> ```\n(lcm n ...) → (or/c rational? +inf.0)\n n : rational?"}
{"text": "# 4.2 Booleans\n```\nReturns the least common multiple (a non-negative number) of the ns. For two non-integer ns, the result is the absolute value of the product divided by the gcd. If no arguments are provided, the result is 1. If any argument is zero, the result is zero; furthermore, if any argument is exact 0, the result is exact 0.\n\nExamples:\n\n> ```racket\n> > ( lcm 10 )\n> 10\n> > ( lcm 3 4.0 )\n> 12.0\n> > ( lcm 1/2 2/3 )\n> 2\n> ```\n\n> ```\n(round x) → (or/c integer? +inf.0 -inf.0 +nan.0)\n x : real?```\n\n\nReturns the integer closest to x, resolving ties in favor of an even number, but +inf.0, -inf.0, and +nan.0 round to themselves.\n\nExamples:\n\n> ```racket\n> > ( round 17/4 )\n> 4\n> > ( round -1 7/4 )\n> -4\n> > ( round 2.5 )\n> 2.0\n> > ( round -2 .5 )\n> -2.0\n> > ( round +inf.0 )\n> +inf.0\n> ```\n\n> ```\n(floor x) → (or/c integer? +inf.0 -inf.0 +nan.0)\n x : real?\n```\nReturns the largest integer that is no more than x, but +inf.0, -inf.0, and +nan.0 floor to themselves.\nExamples:\n> ```racket\n> > ( floor 17/4 )\n> 4\n> > ( floor -1 7/4 )\n> -5\n> > ( floor 2.5 )\n> 2.0\n> > ( floor -2 .5 )\n> -3.0\n> > ( floor +inf.0 )\n> +inf.0\n> ```\n> ```\n(ceiling x) → (or/c integer? +inf.0 -inf.0 +nan.0)\n x : real?\n```\n\n\nReturns the smallest integer that is at least as large as x, but +inf.0, -inf.0, and +nan.0 ceiling to themselves.\n\nExamples:\n\n> ```racket\n> > ( ceiling 17/4 )\n> 5\n> > ( ceiling -1 7/4 )\n> -4\n> > ( ceiling 2.5 )\n> 3.0\n> > ( ceiling -2 .5 )\n> -2.0\n> > ( ceiling +inf.0 )\n> +inf.0\n> ```\n\n> ```\n(truncate x) → (or/c integer? +inf.0 -inf.0 +nan.0)\n x : real?\n```"}
{"text": "# 4.2 Booleans\nReturns the integer farthest from 0 that is not farther from 0 than x, but +inf.0, -inf.0, and +nan.0 truncate to themselves.\nExamples:\n> ```racket\n> > ( truncate 17/4 )\n> 4\n> > ( truncate -1 7/4 )\n> -4\n> > ( truncate 2.5 )\n> 2.0\n> > ( truncate -2 .5 )\n> -2.0\n> > ( truncate +inf.0 )\n> +inf.0\n> ```\n> ```\n(numerator q) → integer?\n q : rational?\n```\n\n\nCoerces q to an exact number, finds the numerator of the number expressed in its simplest fractional form, and returns this number coerced to the exactness of q.\n\nExamples:\n\n> ```racket\n> > ( numerator 5 )\n> 5\n> > ( numerator 17/4 )\n> 17\n> > ( numerator 2.3 )\n> 2589569785738035.0\n> ```\n\n> ```\n(denominator q) → (and/c integer? positive?)\n q : rational?\n```\nCoerces q to an exact number, finds the denominator of the number expressed in its simplest fractional form, and returns this number coerced to the exactness of q.\nExamples:\n> ```racket\n> > ( denominator 5 )\n> 1\n> > ( denominator 17/4 )\n> 4\n> > ( denominator 2.3 )\n> 1125899906842624.0\n> ```\n> ```\n(rationalize x tolerance) → real?\n x : real?\n tolerance : real?"}
{"text": "# 4.2 Booleans\n```\n\n\nAmong the real numbers within ([abs](#%28def._%28%28quote._~23~25kernel%29._abs%29%29) tolerance) of x, returns the one corresponding to an exact number whose [denominator](#%28def._%28%28quote._~23~25kernel%29._denominator%29%29) is the smallest. If multiple integers are within tolerance of x, the one closest to 0 is used.\n\nExamples:\n\n> ```racket\n> > ( rationalize 1/4 1/10 )\n> 1/3\n> > ( rationalize -1 /4 1/10 )\n> -1/3\n> > ( rationalize 1/4 1/4 )\n> 0\n> > ( rationalize 11/40 1/4 )\n> 1/2\n> ```\n\n##### 4.3.2.2 Number Comparison\n\n> ```\n(= z w ...) → boolean?\n z : number?\n w : number?\n```\nReturns #t if all of the arguments are numerically equal, #f otherwise. An inexact number is numerically equal to an exact number when the exact coercion of the inexact number is the exact number. Also, 0.0 and -0.0 are numerically equal, but +nan.0 is not numerically equal to itself.\nExamples:\n> ```racket\n> > ( = 1 1.0 )\n> #t\n> > ( = 1 2 )\n> #f\n> > ( = 2+3i 2+3i 2+3i )\n> #t\n> > ( = 1 )\n> #t\n> ```\nChanged in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.\n> \n |
| x : real? |
| y : real? |
\n |
| x : real? |
| y : real? |
\n |
\n |
See also [Fixnum and Flonum Optimizations](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=performance.html%23%2528part._fixnums%252Bflonums%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13)."}
{"text": "##### 4.3.3.1 Flonum Arithmetic\n> ```\n(fl+ a ...) → flonum?\n a : flonum?\n(fl- a b ...) → flonum?\n a : flonum?\n b : flonum?\n(fl* a ...) → flonum?\n a : flonum?\n(fl/ a b ...) → flonum?\n a : flonum?\n b : flonum?\n(flabs a) → flonum?\n a : flonum?\n```\nLike +, -, *, /, and abs, but constrained to consume flonums. The result is always a flonum.\n\nChanged in version 7.0.0.13 of package base: Allow zero or more arguments for fl+ and fl* and one or more arguments for fl- and fl/.\n\n> ```\n(fl= a b ...) → boolean?\n a : flonum?\n b : flonum?\n\n([fl\n\n(fl> a b ...) → boolean?\n a : flonum?\n b : flonum?\n\n([fl\n\n(fl>= a b ...) → boolean?\n a : flonum?\n b : flonum?\n\n(flmin a b ...) → flonum?\n a : flonum?\n b : flonum?\n\n(flmax a b ...) → flonum?\n a : flonum?\n b : flonum?```\n\n\nLike [=](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._~3d%29%29), [<](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._~3c%29%29), [>](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._~3e%29%29), [<=](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._~3c~3d%29%29), [>=](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._~3e~3d%29%29), [min](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._min%29%29), and [max](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._max%29%29), but constrained to consume [flonums](numbers.html#%28tech._flonum%29).\n\nChanged in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.\n\n> ```\n(flround a) → flonum?\n a : flonum?\n\n(flfloor a) → flonum?\n a : flonum?\n\n(flceiling a) → flonum?\n a : flonum?\n\n(fltruncate a) → flonum?\n a : flonum?\n```"}
{"text": "# 4.3.3 Flonums\nLike round, floor, ceiling, and truncate, but constrained to consume flonums.\n> ```\n(flsingle a) → flonum?\n a : flonum?```\nReturns a value like a, but potentially discards precision and range so that the result can be represented as a single-precision IEEE floating-point number (even if [single-flonums](numbers.html#%28tech._single._flonum%29) are not supported).\nUsing [flsingle](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flsingle%29%29) on the arguments and results of [fl+](#%28def._%28%28lib._racket%2Fflonum..rkt%29._fl%2B%29%29), [fl-](#%28def._%28%28lib._racket%2Fflonum..rkt%29._fl-%29%29), [fl*](#%28def._%28%28lib._racket%2Fflonum..rkt%29._fl%2A%29%29), [fl/](#%28def._%28%28lib._racket%2Fflonum..rkt%29._fl%2F%29%29), and [flsqrt](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flsqrt%29%29)—that is, performing double-precision operations on values representable in single precision and then rounding the result to single precision—is always the same as performing the corresponding single-precision operation \\[[Roux14](doc-bibliography.html#%28cite._.Roux14%29)\\]. (For other operations, the IEEE floating-point specification does not make enough guarantees to say more about the interaction with [flsingle](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flsingle%29%29).)\nAdded in version 7.8.0.7 of package base.\n> ```\n(flbit-field a start end) → exact-nonnegative-integer?\n a : flonum?\n start : (integer-in 0 64)\n end : (integer-in 0 64)"}
{"text": "# 4.3.3 Flonums\n```\n\n\nExtracts a range of bits from the 64-bit IEEE representation of a, returning the non-negative integer that has the same bits set in its (semi-infinite) two’s complement representation.\n\nExamples:\n\n> ```racket\n> > ( flbit-field -0 .0 63 64 )\n> 1\n> > ( format \"~x\" ( flbit-field 3.141579e+132 16 48 ) )\n> \"b43544f2\"\n> ```\n\nAdded in version 8.15.0.3 of package base.\n\n> ```\n(flsin a) → flonum?\n a : flonum?\n\n(flcos a) → flonum?\n a : flonum?\n\n(fltan a) → flonum?\n a : flonum?\n\n(flasin a) → flonum?\n a : flonum?\n\n(flacos a) → flonum?\n a : flonum?\n\n(flatan a) → flonum?\n a : flonum?\n\n(fllog a) → flonum?\n a : flonum?\n\n(flexp a) → flonum?\n a : flonum?\n\n(flsqrt a) → flonum?\n a : flonum?\n```"}
{"text": "# 4.3.3 Flonums\nLike [sin](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._sin%29%29), [cos](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._cos%29%29), [tan](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._tan%29%29), [asin](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._asin%29%29), [acos](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._acos%29%29), [atan](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._atan%29%29), [log](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._log%29%29), [exp](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._exp%29%29), and [sqrt](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._sqrt%29%29), but constrained to consume and produce [flonums](numbers.html#%28tech._flonum%29). The result is +nan.0 when a number outside the range -1.0 to 1.0 is given to [flasin](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flasin%29%29) or [flacos](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flacos%29%29), or when a negative number is given to [fllog](#%28def._%28%28lib._racket%2Fflonum..rkt%29._fllog%29%29) or [flsqrt](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flsqrt%29%29).\n> ```\n(flexpt a b) → flonum?\n a : flonum?\n b : flonum?"}
{"text": "# 4.3.3 Flonums\n```\n\n\nLike [expt](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._expt%29%29), but constrained to consume and produce [flonums](numbers.html#%28tech._flonum%29).\n\nDue to the result constraint, the results compared to [expt](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._expt%29%29) differ in the following cases: These special cases correspond to pow in C99 \\[[C99](doc-bibliography.html#%28cite._.C99%29)\\].\n\n- ([flexpt](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flexpt%29%29) -1.0 +inf.0) — 1.0\n\n- ([flexpt](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flexpt%29%29) a +inf.0) where a is negative — ([expt](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._expt%29%29) ([abs](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._abs%29%29) a) +inf.0)\n\n- ([flexpt](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flexpt%29%29) a -inf.0) where a is negative — ([expt](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._expt%29%29) ([abs](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._abs%29%29) a) -inf.0)\n\n- \n\n ([expt](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._expt%29%29) -inf.0 b) where b is a non-integer:\n\n \n\n \n\n - b is negative — 0.0\n\n - b is positive — +inf.0\n\n \n\n- ([flexpt](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flexpt%29%29) a b) where a is negative and b is not an integer — +nan.0\n\n> ```\n( → fl a) → flonum?\n a : exact-integer?\n```"}
{"text": "# 4.3.3 Flonums\nLike [exact->inexact](number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-~3einexact%29%29), but constrained to consume exact integers, so the result is always a [flonum](numbers.html#%28tech._flonum%29).\n> ```\n(fl → exact-integer a) → exact-integer?\n a : flonum?\n```\nLike inexact → exact, but constrained to consume an integer flonum, so the result is always an exact integer.\n\n> ```\n(make-flrectangular a b)\n → ( and/c complex?\n> ( lambda ( c ) ( flonum? ( real-part c ) ) )\n> ( lambda ( c ) ( flonum? ( imag-part c ) ) ) )\n\n a : flonum?\n b : flonum?\n\n(flreal-part a) → flonum?\n a : ( and/c complex?\n> ( lambda ( c ) ( flonum? ( real-part c ) ) )\n> ( lambda ( c ) ( flonum? ( imag-part c ) ) ) )\n\n(flimag-part a) → flonum?\n a : ( and/c complex?\n> ( lambda ( c ) ( flonum? ( real-part c ) ) )\n> ( lambda ( c ) ( flonum? ( imag-part c ) ) ) )```\n\n\nLike [make-rectangular](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._make-rectangular%29%29), [real-part](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._real-part%29%29), and [imag-part](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._imag-part%29%29), but both parts of the complex number must be inexact.\n\n> ```\n(flrandom rand-gen) → (and flonum? (>/c 0) ([\n```\nEquivalent to (random rand-gen)."}
{"text": "##### 4.3.3.2 Flonum Vectors\nA flvector is like a vector, but it holds only inexact real numbers. This representation can be more compact, and unsafe operations on flvectors (see racket/unsafe/ops) can execute more efficiently than unsafe operations on vectors of inexact reals.\nAn f64vector as provided by ffi/vector stores the same kinds of values as a flvector, but with extra indirections that make f64vectors more convenient for working with foreign libraries. The lack of indirections makes unsafe flvector access more efficient.\nTwo flvectors are equal? if they have the same length, and if the values in corresponding slots of the flvectors are equal?.\nA printed flvector starts with #fl(, optionally with a number between the #fl and (. See Reading Vectors for information on reading flvectors and Printing Vectors for information on printing flvectors.\n> ```\n(flvector? v) → boolean?\n v : any/c```\nReturns #t if v is a [flvector](#%28tech._flvector%29), #f otherwise.\n> ```\n(flvector x ...) → flvector?\n x : flonum?\n```\nCreates a flvector containing the given inexact real numbers.\n\nExample:\n\n> ```racket\n> > ( flvector 2.0 3.0 4.0 5.0 )\n> (flvector 2.0 3.0 4.0 5.0)\n> ```\n\n> ```\n(make-flvector size [x) → flvector?\n size : exact-nonnegative-integer?\n x : flonum? = 0.0```\n\n\nCreates a [flvector](#%28tech._flvector%29) with size elements, where every slot in the [flvector](#%28tech._flvector%29) is filled with x.\n\nExample:\n\n> ```racket\n> > ( make-flvector 4 3.0 )\n> (flvector 3.0 3.0 3.0 3.0)\n> ```\n\n> ```\n(flvector-length vec) → exact-nonnegative-integer?\n vec : flvector?\n```"}
{"text": "# 4.3.3 Flonums\nReturns the length of vec (i.e., the number of slots in the flvector).\n> ```\n(flvector-ref vec pos) → flonum?\n vec : flvector?\n pos : exact-nonnegative-integer?```\nReturns the inexact real number in slot pos of vec. The first slot is position 0, and the last slot is one less than ([flvector-length](#%28def._%28%28lib._racket%2Fflonum..rkt%29._flvector-length%29%29) vec).\n> ```\n(flvector-set! vec pos x) → flonum?\n vec : flvector?\n pos : exact-nonnegative-integer?\n x : flonum?\n```\nSets the inexact real number in slot pos of vec. The first slot is position 0, and the last slot is one less than (flvector-length vec).\n\n> ```\n(flvector-copy vec [start end) → flvector?\n vec : flvector?\n start : exact-nonnegative-integer? = 0\n end : exact-nonnegative-integer? = (vector-length v)```\n\n\nCreates a fresh [flvector](#%28tech._flvector%29) of size ([-](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._-%29%29) end start), with all of the elements of vec from start (inclusive) to end (exclusive).\n\n> ```\n(in-flvector vec [start stop step) → sequence?\n vec : flvector?\n start : exact-nonnegative-integer? = 0\n stop : (or/c exact-integer? #f) = #f\n step : (and/c exact-integer? (not/c zero?)) = 1\n```\nReturns a sequence equivalent to vec when no optional arguments are supplied.\nThe optional arguments start, stop, and step are as in in-vector.\nA in-flvector application can provide better performance for flvector iteration when it appears directly in a for clause."}
{"text": "# 4.3.3 Flonums\n>
| ||||||||||||||||||||||||||||||||
|
| ||||||||||||||||||||||||||||||||
|
\n\n |
[Strings (Unicode)](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=strings.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces strings.\n\nA string is a fixed-length array of [characters](characters.html).\n\nA string can be mutable or immutable. When an immutable string is provided to a procedure like [string-set!](#%28def._%28%28quote._~23~25kernel%29._string-set%21%29%29), the [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised. String constants generated by the default reader (see [Reading Strings](reader.html#%28part._parse-string%29)) are immutable, and they are [interned](reader.html#%28tech._interned%29) in [read-syntax](Reading.html#%28def._%28%28quote._~23~25kernel%29._read-syntax%29%29) mode. Use [immutable?](booleans.html#%28def._%28%28quote._~23~25kernel%29._immutable~3f%29%29) to check whether a string is immutable.\n\nTwo strings are [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) when they have the same length and contain the same sequence of characters.\n\nA string can be used as a single-valued sequence (see [Sequences](sequences.html)). The characters of the string serve as elements of the sequence. See also [in-string](sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-string%29%29).\n\nSee [Reading Strings](reader.html#%28part._parse-string%29) for information on [read](Reading.html#%28def._%28%28quote._~23~25kernel%29._read%29%29)ing strings and [Printing Strings](printing.html#%28part._print-string%29) for information on [print](Writing.html#%28def._%28%28quote._~23~25kernel%29._print%29%29)ing strings.\n\nSee also: [immutable?](booleans.html#%28def._%28%28quote._~23~25kernel%29._immutable~3f%29%29), [symbol->string](symbols.html#%28def._%28%28quote._~23~25kernel%29._symbol-~3estring%29%29), [bytes->string/utf-8](bytestrings.html#%28def._%28%28quote._~23~25kernel%29._bytes-~3estring%2Futf-8%29%29).\n\n#### 4.4.1 String Constructors, Selectors, and Mutators\n\n> ```\n(string? v) → boolean?\n v : any/c\n```"}
{"text": "# 4.3.5 Extflonums\nReturns #t if v is a string, #f otherwise.\nSee also immutable-string? and mutable-string?.\nExamples:\n> ```racket\n> > ( string? \"Apple\" )\n> #t\n> > ( string? ' apple )\n> #f\n> ```\n> ```\n(make-string k [char) → string?\n k : exact-nonnegative-integer?\n char : char? = #\\nul```\nReturns a new mutable string of length k where each position in the string is initialized with the character char.\nExample:\n> ```racket\n> > ( make-string 5 #\\z )\n> \"zzzzz\"\n> ```\n> ```\n(string char ...) → string?\n char : char?\n```\n\n\nReturns a new mutable string whose length is the number of provided chars, and whose positions are initialized with the given chars.\n\nExample:\n\n> ```racket\n> > ( string #\\A #\\p #\\p #\\l #\\e )\n> \"Apple\"\n> ```\n\n> ```\n(string → immutable-string str) → (and/c string? immutable?)\n str : string?\n```\nReturns an immutable string with the same content as str, returning str itself if str is immutable.\nExamples:\n> ```racket\n> > ( immutable? ( string #\\H #\\e #\\l #\\l #\\o ) )\n> #f\n> > ( immutable? ( string->immutable-string ( string #\\H #\\e #\\l #\\l #\\o ) ) )\n> #t\n> ```\n> ```\n(string-length str) → exact-nonnegative-integer?\n str : string?\n```\n\n\nReturns the length of str.\n\nExample:\n\n> ```racket\n> > ( string-length \"Apple\" )\n> 5\n> ```\n\n> ```\n(string-ref str k) → char?\n str : string?\n k : exact-nonnegative-integer?\n```"}
{"text": "# 4.3.5 Extflonums\nReturns the character at position k in str. The first position in the string corresponds to 0, so the position k must be less than the length of the string, otherwise the [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised.\nExample:\n> ```racket\n> > ( string-ref \"Apple\" 0 )\n> #\\A\n> ```\n> ```\n(parameter)\t→\t\n(-> and/c string? (not/c immutable?))\n```\nChanges the character position k in str to char. The first position in the string corresponds to 0, so the position k must be less than the length of the string, otherwise the exn:fail:contract exception is raised.\n\nExamples:\n\n> ```racket\n> > ( define s ( string #\\A #\\p #\\p #\\l #\\e ) )\n> > ( string-set! s 4 #\\y )\n> > s\n> \"Apply\"\n> ```\n\n> ```\n(substring str start [end) → string?\n str : string?\n start : exact-nonnegative-integer?\n end : exact-nonnegative-integer? = (string-length str)```\n\n\nReturns a new mutable string that is ([-](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._-%29%29) end start) characters long, and that contains the same characters as str from start inclusive to end exclusive. The first position in a string corresponds to 0, so the start and end arguments must be less than or equal to the length of str, and end must be greater than or equal to start, otherwise the [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised.\n\nExamples:\n\n> ```racket\n> > ( substring \"Apple\" 1 3 )\n> \"pp\"\n> > ( substring \"Apple\" 1 )\n> \"pple\"\n> ```\n\n> ```\n(string-copy str) → string?\n str : string?\n```"}
{"text": "# 4.3.5 Extflonums\n(parameter)\t→\t\n(-> and/c string? (not/c immutable?))```\nChanges the characters of dest starting at position dest-start to match the characters in src from src-start (inclusive) to src-end (exclusive), where the first position in a string corresponds to 0. The strings dest and src 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 dest-start, src-start, or src-end are out of range (taking into account the sizes of the strings and the source and destination regions), the [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised.\nExamples:\n> ```racket\n> > ( define s ( string #\\A #\\p #\\p #\\l #\\e ) )\n> > ( string-copy! s 4 \"y\" )\n> > ( string-copy! s 0 s 3 4 )\n> > s\n> \"lpply\"\n> ```\n> ```\n(parameter)\t→\t\n(-> and/c string? (not/c immutable?))"}
{"text": "# 4.3.5 Extflonums\n```\nChanges dest so that every position in the string is filled with char.\n\nExamples:\n\n> ```racket\n> > ( define s ( string #\\A #\\p #\\p #\\l #\\e ) )\n> > ( string-fill! s #\\q )\n> > s\n> \"qqqqq\"\n> ```\n\n> ```\n(string-append str ...) → string?\n str : string?```\n\n\nReturns a new mutable string that is as long as the sum of the given strs’ lengths, and that contains the concatenated characters of the given strs. If no strs are provided, the result is a zero-length string.\n\nExample:\n\n> ```racket\n> > ( string-append \"Apple\" \"Banana\" )\n> \"AppleBanana\"\n> ```\n\n> ```\n(string-append-immutable str ...) → (and/c string? immutable?)\n str : string?\n```\nThe same as string-append, but the result is an immutable string.\nExamples:\n> ```racket\n> > ( string-append-immutable \"Apple\" \"Banana\" )\n> \"AppleBanana\"\n> > ( immutable? ( string-append-immutable \"A\" \"B\" ) )\n> #t\n> ```\nAdded in version 7.5.0.14 of package base.\n> ```\n(string → list str) → (listof char?)\n str : string?```\nReturns a new list of characters corresponding to the content of str. That is, the length of the list is ([string-length](#%28def._%28%28quote._~23~25kernel%29._string-length%29%29) str), and the sequence of characters in str is the same sequence in the result list.\nExample:\n> ```racket\n> > ( string->list \"Apple\" )\n> '(#\\A #\\p #\\p #\\l #\\e)\n> ```\n> ```\n(list → string lst) → string?\n lst : (listof char?)"}
{"text": "# 4.3.5 Extflonums\n```\nReturns a new mutable string whose content is the list of characters in lst. That is, the length of the string is (length lst), and the sequence of characters in lst is the same sequence in the result string.\n\nExample:\n\n> ```racket\n> > ( list → string ( list #\\A #\\p #\\p #\\l #\\e ) )\n> \"Apple\"\n> ```\n\n> ```\n(build-string n proc) → string?\n n : exact-nonnegative-integer?\n proc : (exact-nonnegative-integer? . → . char?)```\n\n\nCreates a string of n characters by applying proc to the integers from 0 to ([sub1](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._sub1%29%29) n) in order. If str is the resulting string, then ([string-ref](#%28def._%28%28quote._~23~25kernel%29._string-ref%29%29) str i) is the character produced by (proc i).\n\nExample:\n\n> ```racket\n> > ( build-string 5 ( lambda ( i ) ( integer->char ( + i 97 ) ) ) )\n> \"abcde\"\n> ```\n\n#### 4.4.2 String Comparisons\n\n> ```\n(string=? str1 str2 ...) → boolean?\n str1 : string?\n str2 : string?\n```\nReturns #t if all of the arguments are equal?.\nExamples:\n> ```racket\n> > ( string=? \"Apple\" \"apple\" )\n> #f\n> > ( string=? \"a\" \"as\" \"a\" )\n> #f\n> ```\nChanged in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.\n> \n |
| str1 : string? |
| str2 : string? |
\n |
| str1 : string? |
| str2 : string? |
\n\n |
| str1 : [string?](#%28def._%28%28quote._~23~25kernel%29._string~3f%29%29) |
| str2 : [string?](#%28def._%28%28quote._~23~25kernel%29._string~3f%29%29) |
\n\n |
| str1 : [string?](#%28def._%28%28quote._~23~25kernel%29._string~3f%29%29) |
| str2 : [string?](#%28def._%28%28quote._~23~25kernel%29._string~3f%29%29) |
\n |
| str1 : string? |
| str2 : string? |
[Bytes and Byte Strings](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=bytestrings.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces byte strings.\nA byte string is a fixed-length array of bytes. A byte is an exact integer between 0 and 255 inclusive.\nA byte string can be mutable or immutable. When an immutable byte string is provided to a procedure like [bytes-set!](#%28def._%28%28quote._~23~25kernel%29._bytes-set%21%29%29), the [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised. Byte-string constants generated by the default reader (see [Reading Strings](reader.html#%28part._parse-string%29)) are immutable, and they are [interned](reader.html#%28tech._interned%29) in [read-syntax](Reading.html#%28def._%28%28quote._~23~25kernel%29._read-syntax%29%29) mode. Use [immutable?](booleans.html#%28def._%28%28quote._~23~25kernel%29._immutable~3f%29%29) to check whether a byte string is immutable.\nTwo byte strings are [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) when they have the same length and contain the same sequence of bytes."}
{"text": "# 4.5 Byte Strings\nA byte string can be used as a single-valued sequence (see [Sequences](sequences.html)). The bytes of the string serve as elements of the sequence. See also [in-bytes](sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-bytes%29%29).\nSee [Reading Strings](reader.html#%28part._parse-string%29) for information on [read](Reading.html#%28def._%28%28quote._~23~25kernel%29._read%29%29)ing byte strings and [Printing Strings](printing.html#%28part._print-string%29) for information on [print](Writing.html#%28def._%28%28quote._~23~25kernel%29._print%29%29)ing byte strings.\nSee also: [immutable?](booleans.html#%28def._%28%28quote._~23~25kernel%29._immutable~3f%29%29)."}
{"text": "#### 4.5.1 Byte String Constructors, Selectors, and Mutators\n> ```\n(bytes? v) → boolean?\n v : any/c\n```\nReturns #t if v is a byte string, #f otherwise.\n\nSee also immutable-bytes? and mutable-bytes?.\n\nExamples:\n\n> ```racket\n> > ( bytes? #\"Apple\" )\n> #t\n> > ( bytes? \"Apple\" )\n> #f\n> ```\n\n> ```\n(make-bytes k [b) → bytes?\n k : exact-nonnegative-integer?\n b : byte? = 0```\n\n\nReturns a new mutable byte string of length k where each position in the byte string is initialized with the byte b.\n\nExample:\n\n> ```racket\n> > ( make-bytes 5 65 )\n> #\"AAAAA\"\n> ```\n\n> ```\n(bytes b ...) → bytes?\n b : byte?\n```\nReturns a new mutable byte string whose length is the number of provided bs, and whose positions are initialized with the given bs.\nExample:\n> ```racket\n> > ( bytes 65 112 112 108 101 )\n> #\"Apple\"\n> ```\n> ```\n(bytes → immutable-bytes bstr) → (and/c bytes? immutable?)\n bstr : bytes?\n```\n\n\nReturns an immutable byte string with the same content as bstr, returning bstr itself if bstr is immutable.\n\nExamples:\n\n> ```racket\n> > ( bytes->immutable-bytes ( bytes 65 65 65 ) )\n> #\"AAA\"\n> > ( define b ( bytes->immutable-bytes ( make-bytes 5 65 ) ) )\n> > ( bytes->immutable-bytes b )\n> #\"AAAAA\"\n> > ( eq? ( bytes->immutable-bytes b ) b )\n> #t\n> ```\n\n> ```\n(byte? v) → boolean?\n v : any/c\n```\nReturns #t if v is a byte (i.e., an exact integer between 0 and 255 inclusive), #f otherwise.\nExamples:\n> ```racket\n> > ( byte? 65 )\n> #t\n> > ( byte? 0 )\n> #t\n> > ( byte? 256 )\n> #f\n> > ( byte? -1 )\n> #f\n> ```\n> ```\n(bytes-length bstr) → exact-nonnegative-integer?\n bstr : bytes?"}
{"text": "# 4.5 Byte Strings\n```\n\n\nReturns the length of bstr.\n\nExample:\n\n> ```racket\n> > ( bytes-length #\"Apple\" )\n> 5\n> ```\n\n> ```\n(bytes-ref bstr k) → byte?\n bstr : bytes?\n k : exact-nonnegative-integer?\n```\n(parameter)\t→\t\n(-> and/c bytes? (not/c immutable?))```\nChanges the byte at position k in bstr to b. The first position in the byte string corresponds to 0, so the position k must be less than the length of the bytes, otherwise the [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised.\nExamples:\n> ```racket\n> > ( define s ( bytes 65 112 112 108 101 ) )\n> > ( bytes-set! s 4 121 )\n> > s\n> #\"Apply\"\n> ```\n> ```\n(subbytes bstr start [end) → bytes?\n bstr : bytes?\n start : exact-nonnegative-integer?\n end : exact-nonnegative-integer? = (bytes-length str)\n```\nReturns a new mutable byte string that is (- end start) bytes long, and that contains the same bytes as bstr from start inclusive to end exclusive. The start and end arguments must be less than or equal to the length of bstr, and end must be greater than or equal to start, otherwise the exn:fail:contract exception is raised.\n\nExamples:\n\n> ```racket\n> > ( subbytes #\"Apple\" 1 3 )\n> #\"pp\"\n> > ( subbytes #\"Apple\" 1 )\n> #\"pple\"\n> ```\n\n> ```\n(bytes-copy bstr) → bytes?\n bstr : bytes?```\n\n\nReturns ([subbytes](#%28def._%28%28quote._~23~25kernel%29._subbytes%29%29) str 0).\n\n> ```\n(parameter)\t→\t\n(-> and/c bytes? (not/c immutable?))\n```\n(inclusive)\t→\t\n(-> and/c bytes? (not/c immutable?))```"}
{"text": "# 4.5 Byte Strings\nChanges dest so that every position in the bytes is filled with b.\nExamples:\n> ```racket\n> > ( define s ( bytes 65 112 112 108 101 ) )\n> > ( bytes-fill! s 113 )\n> > s\n> #\"qqqqq\"\n> ```\n> ```\n(bytes-append bstr ...) → bytes?\n bstr : bytes?\n```\n\n\nReturns a new mutable byte string that is as long as the sum of the given bstrs’ lengths, and that contains the concatenated bytes of the given bstrs. If no bstrs are provided, the result is a zero-length byte string.\n\nExample:\n\n> ```racket\n> > ( bytes-append #\"Apple\" #\"Banana\" )\n> #\"AppleBanana\"\n> ```\n\n> ```\n(bytes → list bstr) → (listof byte?)\n bstr : bytes?\n```\nReturns a new list of bytes corresponding to the content of bstr. That is, the length of the list is ([bytes-length](#%28def._%28%28quote._~23~25kernel%29._bytes-length%29%29) bstr), and the sequence of bytes in bstr is the same sequence in the result list.\nExample:\n> ```racket\n> > ( bytes->list #\"Apple\" )\n> '(65 112 112 108 101)\n> ```\n> ```\n(list → bytes lst) → bytes?\n lst : (listof byte?)"}
{"text": "# 4.5 Byte Strings\n```\nReturns a new mutable byte string whose content is the list of bytes in lst. That is, the length of the byte string is (length lst), and the sequence of bytes in lst is the same sequence in the result byte string.\n\nExample:\n\n> ```racket\n> > ( list → bytes ( list 65 112 112 108 101 ) )\n> #\"Apple\"\n> ```\n\n> ```\n(make-shared-bytes k [b) → bytes?\n k : exact-nonnegative-integer?\n b : byte? = 0```\n\n\nReturns a new mutable byte string of length k where each position in the byte string is initialized with the byte b. For communication among [places](places.html#%28tech._place%29), the new byte string is allocated in the [shared memory space](places.html#%28tech._shared._memory._space%29).\n\nExample:\n\n> ```racket\n> > ( make-shared-bytes 5 65 )\n> #\"AAAAA\"\n> ```\n\n> ```\n(shared-bytes b ...) → bytes?\n b : byte?\n```\nReturns a new mutable byte string whose length is the number of provided bs, and whose positions are initialized with the given bs. For communication among places, the new byte string is allocated in the shared memory space.\nExample:\n> ```racket\n> > ( shared-bytes 65 112 112 108 101 )\n> #\"Apple\"\n> ```"}
{"text": "#### 4.5.2 Byte String Comparisons\n> ```\n(bytes=? bstr1 bstr2 ...) → boolean?\n bstr1 : bytes?\n bstr2 : bytes?```\nReturns #t if all of the arguments are [eqv?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29).\nExamples:\n> ```racket\n> > ( bytes=? #\"Apple\" #\"apple\" )\n> #f\n> > ( bytes=? #\"a\" #\"as\" #\"a\" )\n> #f\n> ```\nChanged in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.\n> \n |
| bstr1 : [bytes?](#%28def._%28%28quote._~23~25kernel%29._bytes~3f%29%29) |
| bstr2 : [bytes?](#%28def._%28%28quote._~23~25kernel%29._bytes~3f%29%29) |
Characters in The Racket Guide introduces characters.\nCharacters range over Unicode scalar values, which includes characters whose values range from #x0 to #x10FFFF, but not including #xD800 to #xDFFF. The scalar values are a subset of the Unicode code points.\nTwo characters are eqv? if they correspond to the same scalar value. For each scalar value less than 256, character values that are eqv? are also eq?. Characters produced by the default reader are interned in read-syntax mode.\nSee Reading Characters for information on reading characters and Printing Characters for information on printing characters.\nChanged in version 6.1.1.8 of package base: Updated from Unicode 5.0.1 to Unicode 7.0.0."}
{"text": "#### 4.6.1 Characters and Scalar Values\n> ```\n(char? v) → boolean?\n v : any/c```\nReturn #t if v is a character, #f otherwise.\n> ```\n(char → integer char) → exact-integer?\n char : char?\n```\n\n\nReturns a character’s code-point number.\n\nExample:\n\n> ```racket\n> > ( char->integer #\\A )\n> 65\n> ```\n\n> ```\n(integer → char k) → char?\n k : ( and/c exact-integer?\n> ( or/c ( integer-in 0 #xD7FF )\n> ( integer-in #xE000 #x10FFFF ) ) )\n```\nReturn the character whose code-point number is k. For k less than 256, the result is the same object for the same k.\nExample:\n> ```racket\n> > ( integer->char 65 )\n> #\\A\n> ```\n> ```\n(char-utf-8-length char) → (integer-in 1 6)\n char : char?"}
{"text": "# 4.6 Characters\n```\nProduces the same result as (bytes-length (string → bytes/utf-8 (string char))).\n\n#### 4.6.2 Character Comparisons\n\n> ```\n(char=? char1 char2 ...) → boolean?\n char1 : char?\n char2 : char?```\n\n\nReturns #t if all of the arguments are [eqv?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29).\n\nExamples:\n\n> ```racket\n> > ( char=? #\\a #\\a )\n> #t\n> > ( char=? #\\a #\\A #\\a )\n> #f\n> ```\n\nChanged in version 7.0.0.13 of package base: Allow one argument, in addition to allowing two or more.\n\n> \n\n |
| char1 : [char?](#%28def._%28%28quote._~23~25kernel%29._char~3f%29%29) |
| char2 : [char?](#%28def._%28%28quote._~23~25kernel%29._char~3f%29%29) |
\n\n |
| char1 : [char?](#%28def._%28%28quote._~23~25kernel%29._char~3f%29%29) |
| char2 : [char?](#%28def._%28%28quote._~23~25kernel%29._char~3f%29%29) |
\n\n |
| char1 : char? |
| char2 : char? |
\n\n |
| char1 : char? |
| char2 : char? |
[Regular Expressions](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=regexp.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces regular expressions.\n\nRegular expressions are specified as strings or byte strings, using the same pattern language as either the Unix utility egrep or Perl. A string-specified pattern produces a character regexp matcher, and a byte-string pattern produces a byte regexp matcher. If a character regexp is used with a byte string or input port, it matches UTF-8 encodings (see [Encodings and Locales](encodings.html)) of matching character streams; if a byte regexp is used with a character string, it matches bytes in the UTF-8 encoding of the string.\n\nA regular expression that is represented as a string or byte string can be compiled to a regexp value, which can be used more efficiently by functions such as [regexp-match](#%28def._%28%28quote._~23~25kernel%29._regexp-match%29%29) compared to the string or byte string form. The [regexp](#%28def._%28%28quote._~23~25kernel%29._regexp%29%29) and [byte-regexp](#%28def._%28%28quote._~23~25kernel%29._byte-regexp%29%29) procedures convert a string or byte string (respectively) into a regexp value using a syntax of regular expressions that is most compatible to egrep. The [pregexp](#%28def._%28%28quote._~23~25kernel%29._pregexp%29%29) and [byte-pregexp](#%28def._%28%28quote._~23~25kernel%29._byte-pregexp%29%29) procedures produce a regexp value using a slightly different syntax of regular expressions that is more compatible with Perl.\n\nTwo [regexp values](#%28tech._regexp._value%29) are [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) if they have the same source, use the same pattern language, and are both character regexps or both byte regexps.\n\nA literal or printed [regexp value](#%28tech._regexp._value%29) starts with #rx or #px. See [Reading Regular Expressions](reader.html#%28part._parse-regexp%29) for information on [read](Reading.html#%28def._%28%28quote._~23~25kernel%29._read%29%29)ing regular expressions and [Printing Regular Expressions](printing.html#%28part._print-regexp%29) for information on [print](Writing.html#%28def._%28%28quote._~23~25kernel%29._print%29%29)ing regular expressions. Regexp values produced by the default reader are [interned](reader.html#%28tech._interned%29) in [read-syntax](Reading.html#%28def._%28%28quote._~23~25kernel%29._read-syntax%29%29) mode.\n\nOn the [BC](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=performance.html%23%2528tech._bc%2529&version=8.18.0.13) variant of Racket, the internal size of a [regexp value](#%28tech._regexp._value%29) is limited to 32 kilobytes; this limit roughly corresponds to a source string with 32,000 literal characters or 5,000 operators.\n\n#### 4.8.1 Regexp Syntax\n\nThe following syntax specifications describe the content of a string that represents a regular expression. The syntax of the corresponding string may involve extra escape characters. For example, the regular expression (.\\*)\\\\1 can be represented with the string \"(.\\*)\\\\\\\\1\" or the regexp constant #rx\"(.\\*)\\\\\\\\1\"; the \\\\ in the regular expression must be escaped to include it in a string or regexp constant.\n\nThe [regexp](#%28def._%28%28quote._~23~25kernel%29._regexp%29%29) and [pregexp](#%28def._%28%28quote._~23~25kernel%29._pregexp%29%29) syntaxes share a common core:\n\n| | | | | | | |\n|:----|:---------|:-----:|:-----------------------|:----|:---------------------------------------------|:-------------------------------------|\n| | ‹regexp› | ::= | ‹pces› | | Match ‹pces› | |\n| | | \\| | ‹regexp›\\|‹regexp› | | Match either ‹regexp›, try left first | [ex1](#%28elem._%28rxex._1%29%29) |\n| | ‹pces› | ::= | | | Match empty | |\n| | | \\| | ‹pce›‹pces› | | Match ‹pce› followed by ‹pces› | |\n| | ‹pce› | ::= | ‹repeat› | | Match ‹repeat›, longest possible | [ex3](#%28elem._%28rxex._3%29%29) |\n| | | \\| | ‹repeat›? | | Match ‹repeat›, shortest possible | [ex6](#%28elem._%28rxex._6%29%29) |\n| | | \\| | ‹atom› | | Match ‹atom› exactly once | |\n| | ‹repeat› | ::= | ‹atom›\\* | | Match ‹atom› 0 or more times | [ex3](#%28elem._%28rxex._3%29%29) |\n| | | \\| | ‹atom›+ | | Match ‹atom› 1 or more times | [ex4](#%28elem._%28rxex._4%29%29) |\n| | | \\| | ‹atom›? | | Match ‹atom› 0 or 1 times | [ex5](#%28elem._%28rxex._5%29%29) |\n| | ‹atom› | ::= | (‹regexp›) | | Match sub-expression ‹regexp› and report | [ex11](#%28elem._%28rxex._11%29%29) |\n| | | \\| | \\[‹rng›\\] | | Match any character in ‹rng› | [ex2](#%28elem._%28rxex._2%29%29) |\n| | | \\| | \\[^‹crng›\\] | | Match any character not in ‹crng› | [ex12](#%28elem._%28rxex._12%29%29) |\n| | | \\| | . | | Match any (except newline in multi mode) | [ex13](#%28elem._%28rxex._13%29%29) |\n| | | \\| | ^ | | Match start (or after newline in multi mode) | [ex14](#%28elem._%28rxex._14%29%29) |\n| | | \\| | $ | | Match end (or before newline in multi mode) | [ex15](#%28elem._%28rxex._15%29%29) |\n| | | \\| | ‹literal› | | Match a single literal character | [ex1](#%28elem._%28rxex._1%29%29) |\n| | | \\| | (?‹mode›:‹regexp›) | | Match ‹regexp› using ‹mode› | [ex35](#%28elem._%28rxex._35%29%29) |\n| | | \\| | (?>‹regexp›) | | Match ‹regexp›, only first possible | |\n| | | \\| | ‹look› | | Match empty if ‹look› matches | |\n| | | \\| | (?‹tst›‹pces›\\|‹pces›) | | Match 1st ‹pces› if ‹tst›, else 2nd ‹pces› | [ex36](#%28elem._%28rxex._36%29%29) |\n| | | \\| | (?‹tst›‹pces›) | | Match ‹pces› if ‹tst›, empty if not ‹tst› | |\n| | | \\| | \\\\ at end of pattern | | Match the nul character (ASCII 0) | |\n| | ‹crng› | ::= | ‹rng› | | ‹crng› contains everything in ‹rng› | |\n| | | \\| | ^‹crng› | | ‹crng› contains ^ and everything in ‹crng› | [ex37](#%28elem._%28rxex._37%29%29) |\n| | ‹rng› | ::= | \\] | | ‹rng› contains \\] only | [ex27](#%28elem._%28rxex._27%29%29) |\n| | | \\| | \\- | | ‹rng› contains - only | [ex28](#%28elem._%28rxex._28%29%29) |\n| | | \\| | ‹mrng› | | ‹rng› contains everything in ‹mrng› | |\n| | | \\| | ‹mrng›- | | ‹rng› contains - and everything in ‹mrng› | |\n| | ‹mrng› | ::= | \\]‹lrng› | | ‹mrng› contains \\] and everything in ‹lrng› | [ex29](#%28elem._%28rxex._29%29%29) |\n| | | \\| | -‹lrng› | | ‹mrng› contains - and everything in ‹lrng› | [ex29](#%28elem._%28rxex._29%29%29) |\n| | | \\| | ‹lirng› | | ‹mrng› contains everything in ‹lirng› | |\n| | ‹lirng› | ::= | ‹riliteral› | | ‹lirng› contains a literal character | |\n| | | \\| | ‹riliteral›-‹rliteral› | | ‹lirng› contains Unicode range inclusive | [ex22](#%28elem._%28rxex._22%29%29) |\n| | | \\| | ‹lirng›‹lrng› | | ‹lirng› contains everything in both | |\n| | ‹lrng› | ::= | ^ | | ‹lrng› contains ^ | [ex30](#%28elem._%28rxex._30%29%29) |\n| | | \\| | ‹rliteral›-‹rliteral› | | ‹lrng› contains Unicode range inclusive | |\n| | | \\| | ^‹lrng› | | ‹lrng› contains ^ and more | |\n| | | \\| | ‹lirng› | | ‹lrng› contains everything in ‹lirng› | |\n| | ‹look› | ::= | (?=‹regexp›) | | Match if ‹regexp› matches | [ex31](#%28elem._%28rxex._31%29%29) |\n| | | \\| | (?!‹regexp›) | | Match if ‹regexp› doesn’t match | [ex32](#%28elem._%28rxex._32%29%29) |\n| | | \\| | (?\\<=‹regexp›) | | Match if ‹regexp› matches preceding | [ex33](#%28elem._%28rxex._33%29%29) |\n| | | \\| | (?\\ ```racket\n> > ( regexp-match #rx\"a|b\" \"cat\" ) ; ex 1\n> '(\"a\")\n> > ( regexp-match #rx\"[at]\" \"cat\" ) ; ex 2\n> '(\"a\")\n> > ( regexp-match #rx\"ca*[at]\" \"caaat\" ) ; ex 3\n> '(\"caaat\")\n> > ( regexp-match #rx\"ca+[at]\" \"caaat\" ) ; ex 4\n> '(\"caaat\")\n> > ( regexp-match #rx\"ca?t?\" \"ct\" ) ; ex 5\n> '(\"ct\")\n> > ( regexp-match #rx\"ca*?[at]\" \"caaat\" ) ; ex 6\n> '(\"ca\")\n> > ( regexp-match #px\"ca{2}\" \"caaat\" ) ; ex 7 , uses #px\n> '(\"caa\")\n> > ( regexp-match #px\"ca{2,}t\" \"catcaat\" ) ; ex 8 , uses #px\n> '(\"caat\")\n> > ( regexp-match #px\"ca{,2}t\" \"caaatcat\" ) ; ex 9 , uses #px\n> '(\"cat\")\n> > ( regexp-match #px\"ca{1,2}t\" \"caaatcat\" ) ; ex 10 , uses #px\n> '(\"cat\")\n> > ( regexp-match #rx\"(c<*)(a*)\" \"caat\" ) ; ex 11> '(\"caa\" \"c\" \"aa\")\n> > ( regexp-match #rx\"[^ca]\" \"caat\" ) ; ex 12\n> '(\"t\")\n> > ( regexp-match #rx\".(.).\" \"cat\" ) ; ex 13\n> '(\"cat\" \"a\")\n> > ( regexp-match #rx\"^a|^c\" \"cat\" ) ; ex 14\n> '(\"c\")\n> > ( regexp-match #rx\"a$|t$\" \"cat\" ) ; ex 15\n> '(\"t\")\n> > ( regexp-match #px\"c(.)\\\\1t\" \"caat\" ) ; ex 16 , uses #px\n> '(\"caat\" \"a\")\n> > ( regexp-match #px\".\\\\b.\" \"cat in hat\" ) ; ex 17 , uses #px\n> '(\"t \")\n> > ( regexp-match #px\".\\\\B.\" \"cat in hat\" ) ; ex 18 , uses #px\n> '(\"ca\")\n> > ( regexp-match #px\"\\\\p{Ll}\" \"Cat\" ) ; ex 19 , uses #px\n> '(\"a\")\n> > ( regexp-match #px\"\\\\P{Ll}\" \"cat!\" ) ; ex 20 , uses #px\n> '(\"!\")\n> > ( regexp-match #rx\"\\\\|\" \"c|t\" ) ; ex 21\n> '(\"|\")\n> > ( regexp-match #rx\"[a-f]*\" \"cat\" ) ; ex 22\n> '(\"ca\")\n> > ( regexp-match #px\"[a-f\\\\d]*\" \"1cat\" ) ; ex 23 , uses #px\n> '(\"1ca\")\n> > ( regexp-match #px\" [\\\\w]\" \"cat hat\" ) ; ex 24 , uses #px\n> '(\" h\")\n> > ( regexp-match #px\"t[\\\\s]\" \"cat\\nhat\" ) ; ex 25 , uses #px\n> '(\"t\\n\")\n> > ( regexp-match #px\"[[:lower:]]+\" \"Cat\" ) ; ex 26 , uses #px\n> '(\"at\")\n> > ( regexp-match #rx\"[]]\" \"c]t\" ) ; ex 27\n> '(\"]\")\n> > ( regexp-match #rx\"[-]\" \"c-t\" ) ; ex 28\n> '(\"-\")\n> > ( regexp-match #rx\"[]a[]+\" \"c[a]t\" ) ; ex 29\n> '(\"[a]\")\n> > ( regexp-match #rx\"[a^]+\" \"ca^t\" ) ; ex 30\n> '(\"a^\")\n> > ( regexp-match #rx\".a(?=p)\" \"cat nap\" ) ; ex 31\n> '(\"na\")\n> > ( regexp-match #rx\".a(?!t)\" \"cat nap\" ) ; ex 32\n> '(\"na\")\n> > ( regexp-match #rx\"(?<=n)a.\" \"cat nap\" ) ; ex 33> '(\"ap\")\n> > ( regexp-match #rx\"(? '(\"ap\")\n> > ( regexp-match #rx\"(?i:a)[tp]\" \"cAT nAp\" ) ; ex 35\n> '(\"Ap\")\n> > ( regexp-match #rx\"(?(?<=c)a|b)+\" \"cabal\" ) ; ex 36> '(\"ab\")\n> > ( regexp-match #rx\"[^^]+\" \"^cat^\" ) ; ex 37\n> '(\"cat\")\n> ```\n\nChanged in version 8.15.0.8 of package base: Added \\\\X grapheme cluster pattern.\n\n#### 4.8.2 Additional Syntactic Constraints\n\nIn addition to matching a grammar, regular expressions must meet two syntactic restrictions:\n\n- In a ‹repeat› other than ‹atom›?, the ‹atom› must not match an empty sequence.\n\n- In a (?\\<=‹regexp›) or (?\\
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
(‹n›) : [α‹n›, ∞] |
| [‹rng›] : [1, 1] |
| [^‹rng›] : [1, 1] |
. : [1, 1] |
| ^ : [0, 0] |
| $ : [0, 0] |
‹literal› : [1, 1] |
| \\‹n› : [α‹n›, ∞] |
| ‹class› : [1, 1] |
\\b : [0, 0] |
| \\B : [0, 0] |
\\p{‹property›} : [1, 6] |
| \\P{‹property›} : [1, 6] |
\\X : [1, ∞] |
\n |
| a-keyword : [keyword?](#%28def._%28%28quote._~23~25kernel%29._keyword~3f%29%29) |
| b-keyword : [keyword?](#%28def._%28%28quote._~23~25kernel%29._keyword~3f%29%29) |
Pairs and Lists in The Racket Guide introduces pairs and lists.\n\nA pair combines exactly two values. The first value is accessed with the car procedure, and the second value is accessed with the cdr procedure. Pairs are not mutable (but see Mutable Pairs and Lists).\n\nA list is recursively defined: it is either the constant null, or it is a pair whose second value is a list.\n\nA list can be used as a single-valued sequence (see Sequences). The elements of the list serve as elements of the sequence. See also in-list.\n\nCyclic data structures can be created using only immutable pairs via read or make-reader-graph. If starting with a pair and using some number of cdrs returns to the starting pair, then the pair is not a list.\n\nSee Reading Pairs and Lists for information on reading pairs and lists and Printing Pairs and Lists for information on printing pairs and lists.\n\n#### 4.10.1 Pair Constructors and Selectors\n\n> ```\n(pair? v) → boolean?\n v : any/c```\n\n\nReturns #t if v is a pair, #f otherwise.\n\nExamples:\n\n> ```racket\n> > ( pair? 1 )\n> #f\n> > ( pair? ( cons 1 2 ) )\n> #t\n> > ( pair? ( list 1 2 ) )\n> #t\n> > ( pair? ' ( 1 2 ) )\n> #t\n> > ( pair? ' ( ) )\n> #f\n> ```\n\n> ```\n(null? v) → boolean?\n v : any/c\n```"}
{"text": "# 4.6 Characters\nReturns #t if v is the empty list, #f otherwise.\nExamples:\n> ```racket\n> > ( null? 1 )\n> #f\n> > ( null? ' ( 1 2 ) )\n> #f\n> > ( null? ' ( ) )\n> #t\n> > ( null? ( cdr ( list 1 ) ) )\n> #t\n> ```\n> ```\n(cons a d) → list?\n a : any/c\n d : list?\n(cons a d) → pair?\n a : any/c\n d : any/c\n```\n\n\nReturns a newly allocated pair whose first element is a and second element is d. When d is a list, the allocated pair is also a list.\n\nExamples:\n\n> ```racket\n> > ( cons 1 2 )\n> '(1 . 2)\n> > ( cons 1 ' ( ) )\n> '(1)\n> ```\n\n> ```\n(car p) → any/c\n p : pair?\n```\nReturns the first element of the pair p.\nExamples:\n> ```racket\n> > ( car ' ( 1 2 ) )\n> 1\n> > ( car ' ( 2 . 3 ) )\n> 2\n> ```\n> ```\n(cdr p) → any/c\n p : pair?\n```\n\n\nReturns the second element of the pair p.\n\nExamples:\n\n> ```racket\n> > ( cdr ' ( 1 2 ) )\n> '(2)\n> > ( cdr ' ( 2 . 3 ) )\n> 3\n> ```\n\n> \n\n |
\n\n |
[Vectors](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=vectors.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces vectors.\n\nA vector is a fixed-length array with constant-time access and update of the vector slots, which are numbered from 0 to one less than the number of slots in the vector.\n\nTwo vectors are [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) if they have the same length, and if the values in corresponding slots of the vectors are [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29).\n\nA vector can be mutable or immutable. When an immutable vector is provided to a procedure like [vector-set!](#%28def._%28%28quote._~23~25kernel%29._vector-set%21%29%29), the [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised. Vectors generated by the default reader (see [Reading Strings](reader.html#%28part._parse-string%29)) are immutable. Use [immutable?](booleans.html#%28def._%28%28quote._~23~25kernel%29._immutable~3f%29%29) to check whether a vector is immutable.\n\nA vector can be used as a single-valued sequence (see [Sequences](sequences.html)). The elements of the vector serve as elements of the sequence. See also [in-vector](sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-vector%29%29).\n\nA literal or printed vector starts with #(, optionally with a number between the # and (. See [Reading Vectors](reader.html#%28part._parse-vector%29) for information on [read](Reading.html#%28def._%28%28quote._~23~25kernel%29._read%29%29)ing vectors and [Printing Vectors](printing.html#%28part._print-vectors%29) for information on [print](Writing.html#%28def._%28%28quote._~23~25kernel%29._print%29%29)ing vectors.\n\n> ```\n(vector? v) → boolean?\n v : any/c\n```"}
{"text": "# 4.11 Mutable Pairs and Lists\nReturns #t if v is a vector, #f otherwise.\nSee also immutable-vector? and mutable-vector?.\n> ```\n(make-vector size [v) → vector?\n size : exact-nonnegative-integer?\n v : any/c = 0```\nReturns a mutable vector with size slots, where all slots are initialized to contain v. Note that v is shared for all elements, so for mutable data, mutating an element will affect other elements.\nExamples:\n> ```racket\n> > ( make-vector 3 2 )\n> '#(2 2 2)\n> > ( define v ( make-vector 5 ( box 3 ) ) )\n> > v\n> '#(#&3 #&3 #&3 #&3 #&3)\n> > ( set-box! ( vector-ref v 0 ) 7 )\n> > v\n> '#(#&7 #&7 #&7 #&7 #&7)\n> ```\nThis function takes time proportional to size.\nA common mistake is using [make-vector](#%28def._%28%28quote._~23~25kernel%29._make-vector%29%29) to create nested vectors. The fact that v is shared for all elements means that ([make-vector](#%28def._%28%28quote._~23~25kernel%29._make-vector%29%29) 3 ([make-vector](#%28def._%28%28quote._~23~25kernel%29._make-vector%29%29) 4)) would not be a good way of representing a mutable 3x4 matrix, for example, since just one mutable vector would be shared three times. Using [for/vector](for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%2Fvector%29%29) as follows more likely produces the intended result, since it evaluates ([make-vector](#%28def._%28%28quote._~23~25kernel%29._make-vector%29%29) 4) separately for each iteration:\nExample:\n> ```racket\n> > ( for/vector ( [ i ( in-range 3 ) ] ) ( make-vector 4 ) )\n> '#(#(0 0 0 0) #(0 0 0 0) #(0 0 0 0))\n> ```\n> ```\n(vector v ...) → vector?\n v : any/c"}
{"text": "# 4.11 Mutable Pairs and Lists\n```\nReturns a newly allocated mutable vector with as many slots as provided vs, where the slots are initialized to contain the given vs in order.\n\n> ```\n(vector-immutable v ...) → (and/c vector?\n> immutable? )\n\n v : any/c```\n\n\nReturns a newly allocated immutable vector with as many slots as provided vs, where the slots contain the given vs in order.\n\n> ```\n(vector-length vec) → exact-nonnegative-integer?\n vec : vector?\n```\nReturns the length of vec (i.e., the number of slots in the vector).\nThis function takes constant time.\n> ```\n(vector-ref vec pos) → any/c\n vec : vector?\n pos : exact-nonnegative-integer?\n```\n\n\nReturns the element in slot pos of vec. The first slot is position 0, and the last slot is one less than ([vector-length](#%28def._%28%28quote._~23~25kernel%29._vector-length%29%29) vec).\n\nThis function takes constant time.\n\n> ```\n(parameter)\t→\t\n(-> and/c vector? (not/c immutable?))\n```\n(parameter)\t→\t\n(-> and/c vector? (not/c impersonator?))```\nLike [vector-length](#%28def._%28%28quote._~23~25kernel%29._vector-length%29%29), [vector-ref](#%28def._%28%28quote._~23~25kernel%29._vector-ref%29%29), and [vector-set!](#%28def._%28%28quote._~23~25kernel%29._vector-set%21%29%29), but constrained to work on vectors that are not [impersonators](chaperones.html#%28tech._impersonator%29).\nAdded in version 6.90.0.15 of package base.\n> ```\n(vector-cas! vec pos old-v new-v) → boolean?\n vec : (and/c vector? (not/c immutable?) (not/c impersonator?))\n pos : exact-nonnegative-integer?\n old-v : any/c\n new-v : any/c"}
{"text": "# 4.11 Mutable Pairs and Lists\n```\nCompare and set operation for vectors. See box-cas!.\n\nAdded in version 6.11.0.2 of package base.\n\n> ```\n(vector → list vec) → list?\n vec : vector?```\n\n\nReturns a list with the same length and elements as vec.\n\nThis function takes time proportional to the size of vec.\n\n> ```\n(list → vector lst) → vector?\n lst : list?\n```\nReturns a mutable vector with the same length and elements as lst.\nThis function takes time proportional to the length of lst.\n> ```\n(vector → immutable-vector vec) → (and/c vector? immutable?)\n vec : vector?\n```\n\n\nReturns an immutable vector with the same length and elements as vec. If vec is itself immutable, then it is returned as the result.\n\nThis function takes time proportional to the size of vec when vec is mutable.\n\n> ```\n(parameter)\t→\t\n(-> and/c vector? (not/c immutable?))\n```\n(parameter)\t→\t\n(-> and/c vector? (not/c immutable?))```\nChanges the elements of dest starting at position dest-start to match the elements in src from src-start (inclusive) to src-end (exclusive). The vectors dest and src can be the same vector, and in that case the destination region can overlap with the source region; the destination elements after the copy match the source elements from before the copy. If any of dest-start, src-start, or src-end are out of range (taking into account the sizes of the vectors and the source and destination regions), the [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised."}
{"text": "# 4.11 Mutable Pairs and Lists\nThis function takes time proportional to ([-](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._-%29%29) src-end src-start).\nExamples:\n> ```racket\n> > ( define v ( vector ' A ' p ' p ' l ' e ) )\n> > ( vector-copy! v 4 # ( y ) )\n> > ( vector-copy! v 0 v 3 4 )\n> > v\n> '#(l p p l y)\n> ```\n> ```\n(vector → values vec [start-pos end-pos) → any\n vec : vector?\n start-pos : exact-nonnegative-integer? = 0\n end-pos : exact-nonnegative-integer? = (vector-length vec)\n```\nReturns end-pos - start-pos values, which are the elements of vec from start-pos (inclusive) to end-pos (exclusive). If start-pos or end-pos are greater than (vector-length vec), or if end-pos is less than start-pos, the exn:fail:contract exception is raised.\n\nThis function takes time proportional to the size of vec.\n\n> ```\n(build-vector n proc) → vector?\n n : exact-nonnegative-integer?\n proc : (exact-nonnegative-integer? . → . any/c)```\n\n\nCreates a vector of n elements by applying proc to the integers from 0 to ([sub1](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._sub1%29%29) n) in order. If vec is the resulting vector, then ([vector-ref](#%28def._%28%28quote._~23~25kernel%29._vector-ref%29%29) vec i) is the value produced by (proc i).\n\nExample:\n\n> ```racket\n> > ( build-vector 5 add1 )\n> '#(1 2 3 4 5)\n> ```\n\n#### 4.12.1 Additional Vector Functions\n\n| | |\n|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------:|\n| ([require](require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._require%29%29) [racket/vector](#%28mod-path._racket%2Fvector%29)) | package: [base](https://pkgs.racket-lang.org/package/base \"Install this package using `raco pkg install base`\") |\n\nThe bindings documented in this section are provided by the [racket/vector](#%28mod-path._racket%2Fvector%29) and [racket](index.html) libraries, but not [racket/base](index.html).\n\n> ```\n(vector-empty? v) → boolean?\n v : vector?\n```"}
{"text": "# 4.11 Mutable Pairs and Lists\n(parameter)\t→\t\n(-> and/c vector? (not/c immutable?))```\nUpdates each slot pos of vec to contain each v. The update takes place from the left so later updates overwrite earlier updates.\n> ```\n(vector-map proc vec ...+) → vector?\n proc : procedure?\n vec : vector?\n```\nApplies proc to the elements of the vecs from the first elements to the last. The proc argument must accept the same number of arguments as the number of supplied vecs, and all vecs must have the same number of elements. The result is a fresh vector containing each result of proc in order.\n\nExample:\n\n> ```racket\n> > ( vector-map + # ( 1 2 ) # ( 3 4 ) )\n> '#(4 6)\n> ```\n\n> ```\n(vector-map! proc vec ...+) → vector?\n proc : procedure?\n vec : (and/c vector? (not/c immutable?))```\n\n\nLike [vector-map](#%28def._%28%28lib._racket%2Fvector..rkt%29._vector-map%29%29), but result of proc is inserted into the first vec at the index that the arguments to proc were taken from. The result is the first vec.\n\nExamples:\n\n> ```racket\n> > ( define v ( vector 1 2 3 4 ) )\n> > ( vector-map! add1 v )\n> '#(2 3 4 5)\n> > v\n> '#(2 3 4 5)\n> ```\n\n> ```\n(vector-append vec ...) → vector?\n vec : vector?\n```\nCreates a fresh vector that contains all of the elements of the given vectors in order.\nExample:\n> ```racket\n> > ( vector-append # ( 1 2 ) # ( 3 4 ) )\n> '#(1 2 3 4)\n> ```\n> ```\n(vector-take vec pos) → vector?\n vec : vector?\n pos : exact-nonnegative-integer?"}
{"text": "# 4.11 Mutable Pairs and Lists\n```\n\n\nReturns a fresh vector whose elements are the first pos elements of vec. If vec has fewer than pos elements, then the [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised.\n\nExample:\n\n> ```racket\n> > ( vector-take # ( 1 2 3 4 ) 2 )\n> '#(1 2)\n> ```\n\n> ```\n(vector-take-right vec pos) → vector?\n vec : vector?\n pos : exact-nonnegative-integer?\n```\nReturns a fresh vector whose elements are the last pos elements of vec. If vec has fewer than pos elements, then the exn:fail:contract exception is raised.\nExample:\n> ```racket\n> > ( vector-take-right # ( 1 2 3 4 ) 2 )\n> '#(3 4)\n> ```\n> ```\n(vector-drop vec pos) → vector?\n vec : vector?\n pos : exact-nonnegative-integer?```\nReturns a fresh vector whose elements are the elements of vec after the first pos elements. If vec has fewer than pos elements, then the [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised.\nExample:\n> ```racket\n> > ( vector-drop # ( 1 2 3 4 ) 2 )\n> '#(3 4)\n> ```\n> ```\n(vector-drop-right vec pos) → vector?\n vec : vector?\n pos : exact-nonnegative-integer?"}
{"text": "# 4.11 Mutable Pairs and Lists\n```\nReturns a fresh vector whose elements are the prefix of vec, dropping its pos-length tail. If vec has fewer than pos elements, then the exn:fail:contract exception is raised.\n\nExamples:\n\n> ```racket\n> > ( vector-drop-right # ( 1 2 3 4 ) 1 )\n> '#(1 2 3)\n> > ( vector-drop-right # ( 1 2 3 4 ) 3 )\n> '#(1)\n> ```\n\n> ```\n(vector-split-at vec pos) → vector? vector?\n\n vec : vector?\n pos : exact-nonnegative-integer?```\n\n\nReturns the same result as\n\n> ([values](values.html#%28def._%28%28quote._~23~25kernel%29._values%29%29) ([vector-take](#%28def._%28%28lib._racket%2Fvector..rkt%29._vector-take%29%29) vec pos) ([vector-drop](#%28def._%28%28lib._racket%2Fvector..rkt%29._vector-drop%29%29) vec pos))\n\nexcept that it can be faster.\n\nExample:\n\n> ```racket\n> > ( vector-split-at # ( 1 2 3 4 5 ) 2 )\n> '#(1 2) '#(3 4 5)\n> ```\n\n> ```\n(vector-split-at-right vec pos) → vector? vector?\n\n vec : vector?\n pos : exact-nonnegative-integer?\n```\nReturns the same result as\n> (values (vector-take-right vec pos) (vector-drop-right vec pos))\nexcept that it can be faster.\nExample:\n> ```racket\n> > ( vector-split-at-right # ( 1 2 3 4 5 ) 2 )\n> '#(1 2 3) '#(4 5)\n> ```\n> ```\n(vector-copy vec [start end) → vector?\n vec : vector?\n start : exact-nonnegative-integer? = 0\n end : exact-nonnegative-integer? = (vector-length v)```\nCreates a fresh vector of size ([-](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._-%29%29) end start), with all of the elements of vec from start (inclusive) to end (exclusive).\nExamples:"}
{"text": "# 4.11 Mutable Pairs and Lists\n> ```racket\n> > ( vector-copy # ( 1 2 3 4 ) )\n> '#(1 2 3 4)\n> > ( vector-copy # ( 1 2 3 4 ) 3 )\n> '#(4)\n> > ( vector-copy # ( 1 2 3 4 ) 2 3 )\n> '#(3)\n> ```\n> ```\n(vector-set/copy vec pos val) → vector?\n vec : vector?\n pos : exact-nonnegative-integer?\n val : any/c\n```\nCreates a fresh vector with the same content as vec, except that val is the element at index pos.\n\nExamples:\n\n> ```racket\n> > ( vector-set/copy # ( 1 2 3 ) 0 ' x )\n> '#(x 2 3)\n> > ( vector-set/copy # ( 1 2 3 ) 2 ' x )\n> '#(1 2 x)\n> ```\n\nAdded in version 8.11.1.10 of package base.\n\n> ```\n(vector-extend vec new-size [val) → vector?\n vec : vector?\n new-size : (and/c exact-nonnegative-integer? (>=/c (vector-length vec)))\n val : any/c = 0```\n\n\nCreates a fresh vector of length new-size where the prefix is filled with the elements of vec and the remainder with val.\n\nExamples:\n\n> ```racket\n> > ( vector-extend # ( 1 2 3 ) 10 )\n> '#(1 2 3 0 0 0 0 0 0 0)\n> > ( vector-extend # ( 1 2 3 ) 10 #f )\n> '#(1 2 3 #f #f #f #f #f #f #f)\n> > ( vector-extend # ( 1 2 3 ) 3 #f )\n> '#(1 2 3)\n> ```\n\nAdded in version 8.12.0.10 of package base.\n\n> ```\n(vector-filter pred vec) → vector?\n pred : procedure?\n vec : vector?\n```\nReturns a fresh vector with the elements of vec for which pred produces a true value. The pred procedure is applied to each element from first to last.\nExample:\n> ```racket\n> > ( vector-filter even? # ( 1 2 3 4 5 6 ) )\n> '#(2 4 6)\n> ```\n> ```\n(vector-filter-not pred vec) → vector?\n pred : procedure?\n vec : vector?```"}
{"text": "# 4.11 Mutable Pairs and Lists\nLike [vector-filter](#%28def._%28%28lib._racket%2Fvector..rkt%29._vector-filter%29%29), but the meaning of the pred predicate is reversed: the result is a vector of all items for which pred returns #f.\nExample:\n> ```racket\n> > ( vector-filter-not even? # ( 1 2 3 4 5 6 ) )\n> '#(1 3 5)\n> ```\n> ```\n(vector-count proc vec ...+) → exact-nonnegative-integer?\n proc : procedure?\n vec : vector?\n```\nReturns the number of elements of the vec ... (taken in parallel) on which proc does not evaluate to #f.\n\nExamples:\n\n> ```racket\n> > ( vector-count even? # ( 1 2 3 4 5 ) )\n> 2\n> > ( vector-count = # ( 1 2 3 4 5 ) # ( 5 4 3 2 1 ) )\n> 1\n> ```\n\n> ```\n(vector-argmin proc vec) → any/c\n proc : ( → any/c real?)\n vec : vector?```\n\n\nThis returns the first element in the non-empty vector vec that minimizes the result of proc.\n\nExamples:\n\n> ```racket\n> > ( vector-argmin car # ( ( 3 pears ) ( 1 banana ) ( 2 apples ) ) )\n> '(1 banana)\n> > ( vector-argmin car # ( ( 1 banana ) ( 1 orange ) ) )\n> '(1 banana)\n> ```\n\n> ```\n(vector-argmax proc vec) → any/c\n proc : ( → any/c real?)\n vec : vector?\n```\nThis returns the first element in the non-empty vector vec that maximizes the result of proc.\nExamples:\n> ```racket\n> > ( vector-argmax car # ( ( 3 pears ) ( 1 banana ) ( 2 apples ) ) )\n> '(3 pears)\n> > ( vector-argmax car # ( ( 3 pears ) ( 3 oranges ) ) )\n> '(3 pears)\n> ```\n> ```\n(vector-member v vec [is-equal?) → (or/c natural-number/c #f)\n v : any/c\n vec : vector?\n is-equal? : ( → any/c any/c any/c) = equal?```"}
{"text": "# 4.11 Mutable Pairs and Lists\nLocates the first element of vec that is equal to v according to is-equal?. If such an element exists, the index of that element in vec is returned. Otherwise, the result is #f.\nExamples:\n> ```racket\n> > ( vector-member 2 ( vector 1 2 3 4 ) )\n> 1\n> > ( vector-member 9 ( vector 1 2 3 4 ) )\n> #f\n> > ( vector-member 1.0 ( vector 1 2 3 4 ) = )\n> 0\n> ```\nChanged in version 8.15.0.1 of package base: Added the is-equal? argument.\n> ```\n(vector-memv v vec) → (or/c natural-number/c #f)\n v : any/c\n vec : vector?\n```\nLike vector-member, but finds an element using eqv?.\n\nExamples:\n\n> ```racket\n> > ( vector-memv 2 ( vector 1 2 3 4 ) )\n> 1\n> > ( vector-memv 9 ( vector 1 2 3 4 ) )\n> #f\n> ```\n\n> ```\n(vector-memq v vec) → (or/c natural-number/c #f)\n v : any/c\n vec : vector?```\n\n\nLike [vector-member](#%28def._%28%28lib._racket%2Fvector..rkt%29._vector-member%29%29), but finds an element using [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29).\n\nExamples:\n\n> ```racket\n> > ( vector-memq 2 ( vector 1 2 3 4 ) )\n> 1\n> > ( vector-memq 9 ( vector 1 2 3 4 ) )\n> #f\n> ```\n\n> ```\n(vector-sort vec\n less-than? \n [ start \n end \n #:key key \n #:cache-keys? cache-keys?) → vector?\n\n vec : vector?\n less-than? : (any/c any/c . → . any/c)\n start : exact-nonnegative-integer? = 0\n end : (or/c #f exact-nonnegative-integer?) = #f\n key : (or/c #f (any/c . → . any/c)) = #f\n cache-keys? : boolean? = #f\n```\n(inclusive)\t→\t\n(-> and/c vector? (not/c immutable?))```"}
{"text": "# 4.11 Mutable Pairs and Lists\nLike [vector-sort](#%28def._%28%28lib._racket%2Fvector..rkt%29._vector-sort%29%29), but updates indices start (inclusive) through end (exclusive) of vec by sorting them according to the less-than? procedure.\nExamples:\n> ```racket\n> > ( define v1 ( vector 4 3 2 1 ) )\n> > v1\n> '#(4 3 2 1)\n> > ( vector-sort! v1 < )> > v1\n> '#(1 2 3 4)\n> > ( define v2 ( vector 4 3 2 1 ) )\n> > v2\n> '#(4 3 2 1)\n> > ( vector-sort! v2 < 2 #f #:key #f )> > v2\n> '#(4 3 1 2)\n> > ( define v3 ( vector ' ( 4 ) ' ( 3 ) ' ( 2 ) ' ( 1 ) ) )\n> > v3\n> '#((4) (3) (2) (1))\n> > ( vector-sort! v3 < 1 3 #:key car )> > v3\n> '#((4) (2) (3) (1))\n> ```\nAdded in version 6.6.0.5 of package base.\n> ```\n(vector*-copy vec [start end) → vector?\n vec : (and/c vector? (not/c impersonator?))\n start : exact-nonnegative-integer? = 0\n end : exact-nonnegative-integer? = (vector-length v)\n(vector*-append vec ...) → vector?\n vec : (and/c vector? (not/c impersonator?))\n(vector*-set/copy vec pos val) → vector?\n vec : (and/c vector? (not/c impersonator?))\n pos : exact-nonnegative-integer?\n val : any/c\n(vector*-extend vec pos [val) → vector?\n vec : (and/c vector? (not/c impersonator?))\n pos : exact-nonnegative-integer?\n val : any/c = 0"}
{"text": "# 4.11 Mutable Pairs and Lists\n```\nLike vector-copy, vector-append, vector-set/copy, and vector-extend but constrained to work on vectors that are not impersonators.\n\nAdded in version 8.11.1.10 of package base. \nChanged in version 8.12.0.10: Added vector*-extend.\n\n------------------------------------------------------------------------\n\n# 4.13 Stencil Vectors\n\n### 4.13 Stencil Vectors\n\nA stencil vector is like a vector, but it has an associated mask fixnum where the number of bits set in the mask determines the length of the vector. A stencil vector is useful for implementing some data structures \\[Torosyan21\\], such as a hash array mapped trie (HAMT).\n\nConceptually, a stencil vector’s mask indicates which virtual elements of a full-sized stencil vector are present, but mask bits have no effect on access or mutation via stencil-vector-ref and stencil-vector-set!. For example, such a stencil vector has a mask 25, which could also be written #b11001; reading from low bit to high, that mask represents values present at the virtual slots 0, 3, and 4. If that stencil vector’s elements are 'a, 'b, and 'c, then 'a is at virtual slot 0 and accessed with index 0, 'b is at virtual slot 3 and accessed with index 1, and 'c is at virtual slot 4 and accessed with index 2.\n\nThe relative order of bits in a mask is relevant for a functional-update operation with stencil-vector-update. Elements to remove are specified with a removal mask, and elements to add are ordered relative to remaining elements through an addition mask. For example, starting with the stencil vector whose mask is #b11001 with elements 'a, 'b, and 'c, adding new elements 'd and 'e using the addition mask #b100100 produces a stencil vector whose mask is #b111101 and whose elements in order are 'a, 'd, 'b, 'c, and 'e.\n\nThe maximum size of a stencil vector is 58 elements on a 64-bit platform and 26 elements on a 32-bit platform. This limited size enables a compact internal representation and ensures that update operations are relatively simple. Stencil vectors are mutable, although they are intended primarily for use without mutation to implement a persistent data structure.\n\nTwo stencil vectors are equal? if they have the same mask, and if the values in corresponding slots of the stencil vectors are equal?.\n\nA printed vector starts with #\\Boxes in The Racket Guide introduces boxes.\nA box is like a single-element vector, normally used as minimal mutable storage.\nA box can be mutable or immutable. When an immutable box is provided to a procedure like set-box!, the exn:fail:contract exception is raised. Box constants generated by the default reader (see Reading Strings) are immutable. Use immutable? to check whether a box is immutable.\nA literal or printed box starts with #&. See Reading Boxes for information on reading boxes and Printing Boxes for information on printing boxes.\n> ```\n(box? v) → boolean?\n v : any/c```\nReturns #t if v is a box, #f otherwise.\nSee also [immutable-box?](booleans.html#%28def._%28%28lib._racket%2Fmutability..rkt%29._immutable-box~3f%29%29) and [mutable-box?](booleans.html#%28def._%28%28lib._racket%2Fmutability..rkt%29._mutable-box~3f%29%29).\n> ```\n(box v) → box?\n v : any/c\n```\n\n\nReturns a new mutable box that contains v.\n\n> ```\n(box-immutable v) → (and/c box? immutable?)\n v : any/c\n```\nReturns a new immutable box that contains v.\n> ```\n(unbox box) → any/c\n box : box?\n```\n(parameter)\t→\t\n(-> and/c box? (not/c immutable?))```\n\n\nSets the content of box to v.\n\n> ```\n(parameter)\t→\t\n(-> and box? (not/c impersonator?))\n```\nLike unbox and set-box!, but constrained to work on boxes that are not impersonators.\nAdded in version 6.90.0.15 of package base.\n> ```\n(box-cas! box old new) → boolean?\n box : (and/c box? (not/c immutable?) (not/c impersonator?))\n old : any/c\n new : any/c```"}
{"text": "# 4.14 Boxes\nAtomically updates the contents of box to new, provided that box currently contains a value that is [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29) to old, and returns #t in that case. If box does not contain old, then the result is #f.\nIf no other [threads](eval-model.html#%28tech._thread%29) or [futures](futures.html#%28tech._future%29) attempt to access box, the operation is equivalent to\n> ([and](if.html#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29) ([eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29) old ([unbox](#%28def._%28%28quote._~23~25kernel%29._unbox%29%29) box)) ([set-box!](#%28def._%28%28quote._~23~25kernel%29._set-box%21%29%29) box new) #t)\nexcept that [box-cas!](#%28def._%28%28quote._~23~25kernel%29._box-cas%21%29%29) can spuriously fail on some platforms. That is, with low probability, the result can be #f with the value in box left unchanged, even if box contains old.\nWhen Racket is compiled with support for [futures](futures.html#%28tech._future%29), [box-cas!](#%28def._%28%28quote._~23~25kernel%29._box-cas%21%29%29) is guaranteed to use a hardware compare and set operation. Uses of [box-cas!](#%28def._%28%28quote._~23~25kernel%29._box-cas%21%29%29) can be performed safely in a [future](futures.html#%28tech._future%29) (i.e., allowing the future thunk to continue in parallel). See also [Machine Memory Order](memory-order.html).\n------------------------------------------------------------------------"}
{"text": "# 4.15 Hash Tables"}
{"text": "### 4.15 Hash Tables\n> > > [Hash Tables](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=hash-tables.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces hash tables.\nA hash table (or simply hash) maps each of its keys to a single value. For a given hash table, keys are equivalent via [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29), [equal-always?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal-always~3f%29%29), [eqv?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29), or [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29), and keys are retained either strongly, weakly (see [Weak Boxes](weakbox.html)), or like [ephemerons](ephemerons.html#%28tech._ephemeron%29). A hash table is also either mutable or immutable. Immutable hash tables support effectively constant-time access and update, just like mutable hash tables; the constant on immutable operations is usually larger, but the functional nature of immutable hash tables can pay off in certain algorithms. Use [immutable?](booleans.html#%28def._%28%28quote._~23~25kernel%29._immutable~3f%29%29) to check whether a hash table is immutable."}
{"text": "# 4.15 Hash Tables\n> > > Immutable hash tables actually provide O(log N) access and update. Since N is limited by the address space so that log N is limited to less than 30 or 62 (depending on the platform), log N can be treated reasonably as a constant.\nFor [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29)-based hashing, the built-in hash functions on [strings](strings.html#%28tech._string%29), [pairs](pairs.html#%28tech._pair%29), [lists](pairs.html#%28tech._list%29), [vectors](vectors.html#%28tech._vector%29), [prefab](structures.html#%28tech._prefab%29) or transparent [structures](structures.html#%28tech._structure%29), etc., take time proportional to the size of the value. The hash code for a compound data structure, such as a list or vector, depends on hashing each item of the container, but the depth of such recursive hashing is limited (to avoid potential problems with cyclic data). For a non-[list](pairs.html#%28tech._list%29) [pair](pairs.html#%28tech._pair%29), both [car](pairs.html#%28def._%28%28quote._~23~25kernel%29._car%29%29) and [cdr](pairs.html#%28def._%28%28quote._~23~25kernel%29._cdr%29%29) hashing is treated as a deeper hash, but the [cdr](pairs.html#%28def._%28%28quote._~23~25kernel%29._cdr%29%29) of a [list](pairs.html#%28tech._list%29) is treated as having the same hashing depth as the list."}
{"text": "# 4.15 Hash Tables\nA hash table can be used as a two-valued [sequence](sequences.html#%28tech._sequence%29) (see [Sequences](sequences.html)). The keys and values of the hash table serve as elements of the sequence (i.e., each element is a key and its associated value). If a mapping is added to or removed from a mutable hash table during iteration, then an iteration step may fail with [exn:fail:contract](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29), or the iteration may skip or duplicate keys and values. See also [in-hash](sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29), [in-hash-keys](sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-keys%29%29), [in-hash-values](sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-values%29%29), and [in-hash-pairs](sequences.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-pairs%29%29)."}
{"text": "# 4.15 Hash Tables\nTwo hash tables cannot be [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) unless they have the same mutability, use the same key-comparison procedure ([equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29), [equal-always?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal-always~3f%29%29), [eqv?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29), or [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29)), both hold keys strongly, weakly, or like [ephemerons](ephemerons.html#%28tech._ephemeron%29). Empty immutable hash tables are [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29) when they are [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29).\nChanged in version 7.2.0.9 of package base: Made empty immutable hash tables [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29) when they are [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29).\nCaveats concerning concurrent modification: A mutable hash table can be manipulated with [hash-ref](#%28def._%28%28quote._~23~25kernel%29._hash-ref%29%29), [hash-set!](#%28def._%28%28quote._~23~25kernel%29._hash-set%21%29%29), and [hash-remove!](#%28def._%28%28quote._~23~25kernel%29._hash-remove%21%29%29) concurrently by multiple threads, and the operations are protected by a table-specific semaphore as needed. Several caveats apply, however:"}
{"text": "# 4.15 Hash Tables\n- If a thread is terminated while applying [hash-ref](#%28def._%28%28quote._~23~25kernel%29._hash-ref%29%29), [hash-ref-key](#%28def._%28%28quote._~23~25kernel%29._hash-ref-key%29%29), [hash-set!](#%28def._%28%28quote._~23~25kernel%29._hash-set%21%29%29), [hash-remove!](#%28def._%28%28quote._~23~25kernel%29._hash-remove%21%29%29), [hash-ref!](#%28def._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._hash-ref%21%29%29), [hash-update!](#%28def._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._hash-update%21%29%29), or [hash-clear!](#%28def._%28%28quote._~23~25kernel%29._hash-clear%21%29%29) to a hash table that uses [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29), [equal-always?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal-always~3f%29%29), or [eqv?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29) key comparisons, all current and future operations on the hash table may block indefinitely.\n- The [hash-map](#%28def._%28%28quote._~23~25kernel%29._hash-map%29%29), [hash-for-each](#%28def._%28%28quote._~23~25kernel%29._hash-for-each%29%29), and [hash-clear!](#%28def._%28%28quote._~23~25kernel%29._hash-clear%21%29%29) procedures do not use the table’s semaphore to guard the traversal as a whole (if a traversal is needed, in the case of [hash-clear!](#%28def._%28%28quote._~23~25kernel%29._hash-clear%21%29%29)). Changes by one thread to a hash table can affect the keys and values seen by another thread part-way through its traversal of the same hash table."}
{"text": "# 4.15 Hash Tables\n- The [hash-update!](#%28def._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._hash-update%21%29%29) and [hash-ref!](#%28def._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._hash-ref%21%29%29) functions use a table’s semaphore independently for the [hash-ref](#%28def._%28%28quote._~23~25kernel%29._hash-ref%29%29) and [hash-set!](#%28def._%28%28quote._~23~25kernel%29._hash-set%21%29%29) parts of their functionality, which means that the update as a whole is not “atomic.”\n- Adding a mutable hash table as a key in itself is trouble on the grounds that the key is being mutated (see the caveat below), but it is also a kind of concurrent use of the hash table: computing a hash table’s hash code may require waiting on the table’s semaphore, but the semaphore is already held for modifying the hash table, so the hash-table addition can block indefinitely.\nCaveat concerning mutable keys: If a key in an [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29)-based hash table is mutated (e.g., a key string is modified with [string-set!](strings.html#%28def._%28%28quote._~23~25kernel%29._string-set%21%29%29)), then the hash table’s behavior for insertion and lookup operations becomes unpredictable."}
{"text": "# 4.15 Hash Tables\nA literal or printed hash table starts with #hash, #hashalw, #hasheqv, or #hasheq. See [Reading Hash Tables](reader.html#%28part._parse-hashtable%29) for information on [read](Reading.html#%28def._%28%28quote._~23~25kernel%29._read%29%29)ing hash tables and [Printing Hash Tables](printing.html#%28part._print-hashtable%29) for information on [print](Writing.html#%28def._%28%28quote._~23~25kernel%29._print%29%29)ing hash tables.\n> ```\n(hash? v) → boolean?\n v : any/c\n```\nReturns #t if v is a hash table, #f otherwise.\n\nSee also immutable-hash? and mutable-hash?.\n\n> ```\n(hash-equal? ht) → boolean?\n ht : hash?```\n\n\nReturns #t if ht compares keys with [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29), #f if it compares with [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29), [eqv?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29), or [equal-always?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal-always~3f%29%29).\n\n> ```\n(hash-equal-always? ht) → boolean?\n ht : hash?\n```\nReturns #t if ht compares keys with equal-always?, #f if it compares with eq?, eqv?, or equal?.\nAdded in version 8.5.0.3 of package base.\n> ```\n(hash-eqv? ht) → boolean?\n ht : hash?```"}
{"text": "# 4.15 Hash Tables\nReturns #t if ht compares keys with [eqv?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29), #f if it compares with [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29), [equal-always?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal-always~3f%29%29), or [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29).\n> ```\n(hash-eq? ht) → boolean?\n ht : hash?\n```\nReturns #t if ht compares keys with eq?, #f if it compares with equal?, equal-always?, or eqv?.\n\n> ```\n(hash-strong? ht) → boolean?\n ht : hash?```\n\n\nReturns #t if ht retains its keys strongly, #f if it retains keys weakly or like [ephemerons](ephemerons.html#%28tech._ephemeron%29).\n\nAdded in version 8.0.0.10 of package base.\n\n> ```\n(hash-weak? ht) → boolean?\n ht : hash?\n```\nReturns #t if ht retains its keys weakly, #f if it retains keys strongly or like ephemerons.\n> ```\n(hash-ephemeron? ht) → boolean?\n ht : hash?```\nReturns #t if ht retains its keys like [ephemerons](ephemerons.html#%28tech._ephemeron%29), #f if it retains keys strongly or merely weakly.\nAdded in version 8.0.0.10 of package base.\n> ```\n(hash key val ... ...)\n → (and/c hash? hash-equal? immutable? hash-strong?)\n key : any/c\n val : any/c\n(hashalw key val ... ...)\n → (and/c hash? hash-equal-always? immutable? hash-strong?)\n key : any/c\n val : any/c\n(hasheq key val ... ...)\n → (and/c hash? hash-eq? immutable? hash-strong?)\n key : any/c\n val : any/c"}
{"text": "# 4.15 Hash Tables\n(hasheqv key val ... ...)\n → (and/c hash? hash-eqv? immutable? hash-strong?)\n key : any/c\n val : any/c\n```\nCreates an immutable hash table with each given key mapped to the following val; each key must have a val, so the total number of arguments to hash must be even.\n\nThe hash procedure creates a table where keys are compared with equal?, hashalw creates a table where keys are compared with equal-always?, hasheq procedure creates a table where keys are compared with eq?, hasheqv procedure creates a table where keys are compared with eqv?.\n\nThe key to val mappings are added to the table in the order that they appear in the argument list, so later mappings can hide earlier mappings if the keys are equal.\n\nChanged in version 8.5.0.3 of package base: Added hashalw.\n\n> ```\n(make-hash [assocs)\n → (and/c hash? hash-equal? (not/c immutable?) hash-strong?)\n assocs : (listof pair?) = null\n\n(make-hashalw [assocs)\n → (and/c hash? hash-equal-always? (not/c immutable?) hash-strong?)\n assocs : (listof pair?) = null\n\n(make-hasheqv [assocs)\n → (and/c hash? hash-eqv? (not/c immutable?) hash-strong?)\n assocs : (listof pair?) = null\n\n(make-hasheq [assocs)\n → (and/c hash? hash-eq? (not/c immutable?) hash-strong?)\n assocs : (listof pair?) = null```\n\n\nCreates a mutable hash table that holds keys strongly.\n\nThe [make-hash](#%28def._%28%28quote._~23~25kernel%29._make-hash%29%29) procedure creates a table where keys are compared with [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29), [make-hasheq](#%28def._%28%28quote._~23~25kernel%29._make-hasheq%29%29) procedure creates a table where keys are compared with [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29), [make-hasheqv](#%28def._%28%28quote._~23~25kernel%29._make-hasheqv%29%29) procedure creates a table where keys are compared with [eqv?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29), and [make-hashalw](#%28def._%28%28quote._~23~25kernel%29._make-hashalw%29%29) creates a table where keys are compared with [equal-always?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal-always~3f%29%29).\n\nThe table is initialized with the content of assocs. In each element of assocs, the [car](pairs.html#%28def._%28%28quote._~23~25kernel%29._car%29%29) is a key, and the [cdr](pairs.html#%28def._%28%28quote._~23~25kernel%29._cdr%29%29) is the corresponding value. The mappings are added to the table in the order that they appear in assocs, so later mappings can hide earlier mappings.\n\nSee also [make-custom-hash](dicts.html#%28def._%28%28lib._racket%2Fdict..rkt%29._make-custom-hash%29%29).\n\nExamples:\n\n> ```racket\n> > ( make-hash )\n> '#hash()\n> > ( make-hash ' ( [ 0 . 1 ] [ 42 . \"meaning of life\" ] [ 2 . 3 ] ) )\n> '#hash((0 . 1) (2 . 3) (42 . \"meaning of life\"))\n> > ( make-hash ' ( [ 0 . 1 ] [ 1 . 2 ] [ 0 . 3 ] ) )\n> '#hash((0 . 3) (1 . 2))\n> > ( make-hash ( list ( cons 0 1 ) ( cons ' apple ' orange ) ( cons #t #f ) ) )\n> '#hash((#t . #f) (0 . 1) (apple . orange))\n> > ( make-hash ' ( ( 0 1 ) ( 1 2 ) ( 2 3 ) ) )\n> '#hash((0 . (1)) (1 . (2)) (2 . (3)))\n> > ( make-hash ( list ( cons + - ) ) )\n> '#hash((#
| |
|
| |
|
[Sequence Constructors](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=for.html%23%2528part._sequences%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces sequences.\nA sequence encapsulates an ordered collection of values. The elements of a sequence can be extracted with one of the [for](for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29) syntactic forms, with the procedures returned by [sequence-generate](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29), or by converting the sequence into a [stream](streams.html#%28tech._stream%29).\nThe sequence datatype overlaps with many other datatypes. Among built-in datatypes, the sequence datatype includes the following:\n- exact nonnegative integers (see below)\n- strings (see [Strings](strings.html))\n- byte strings (see [Byte Strings](bytestrings.html))\n- lists (see [Pairs and Lists](pairs.html))\n- mutable lists (see [Mutable Pairs and Lists](mpairs.html))\n- vectors (see [Vectors](vectors.html))\n- flvectors (see [Flonum Vectors](flonums.html#%28part._flvectors%29))\n- fxvectors (see [Fixnum Vectors](fixnums.html#%28part._fxvectors%29))\n- hash tables (see [Hash Tables](hashtables.html))\n- dictionaries (see [Dictionaries](dicts.html))\n- sets (see [Sets](sets.html))"}
{"text": "# 4.17.1 Sequences\n- input ports (see [Ports](ports.html))\n- streams (see [Streams](streams.html))\nAn [exact number](numbers.html#%28tech._exact._number%29) k that is a non-negative [integer](numbers.html#%28tech._integer%29) acts as a sequence similar to ([in-range](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29) k), except that k by itself is not a [stream](streams.html#%28tech._stream%29).\nCustom sequences can be defined using structure type properties. The easiest method to define a custom sequence is to use the [gen:stream](streams.html#%28def._%28%28lib._racket%2Fstream..rkt%29._gen~3astream%29%29) [generic interface](struct-generics.html#%28tech._generic._interface%29). Streams are a suitable abstraction for data structures that are directly iterable. For example, a list is directly iterable with [first](pairs.html#%28def._%28%28lib._racket%2Flist..rkt%29._first%29%29) and [rest](pairs.html#%28def._%28%28lib._racket%2Flist..rkt%29._rest%29%29). On the other hand, vectors are not directly iterable: iteration has to go through an index. For data structures that are not directly iterable, the iterator for the data structure can be defined to be a stream (e.g., a structure containing the index of a vector).\nFor example, unrolled linked lists (represented as a list of vectors) themselves do not fit the stream abstraction, but have index-based iterators that can be represented as streams:\nExamples:"}
{"text": "# 4.17.1 Sequences\n> ```racket\n> > ( struct unrolled-list-iterator ( idx lst ) #:methods gen:stream [ ( define ( stream-empty? iter ) ( define lst ( unrolled-list-iterator-lst iter ) ) ( or ( null? lst ) ( and ( >= ( unrolled-list-iterator-idx iter ) ( vector-length ( first lst ) ) ) ( null? ( rest lst ) ) ) ) ) ( define ( stream-first iter ) ( vector-ref ( first ( unrolled-list-iterator-lst iter ) ) ( unrolled-list-iterator-idx iter ) ) ) ( define ( stream-rest iter ) ( define idx ( unrolled-list-iterator-idx iter ) ) ( define lst ( unrolled-list-iterator-lst iter ) ) ( if ( >= idx ( sub1 ( vector-length ( first lst ) ) ) ) ( unrolled-list-iterator 0 ( rest lst ) ) ( unrolled-list-iterator ( add1 idx ) lst ) ) ) ] )\n> > ( define ( make-unrolled-list-iterator ul ) ( unrolled-list-iterator 0 ( unrolled-list-lov ul ) ) )\n> > ( struct unrolled-list ( lov ) #:property prop:sequence make-unrolled-list-iterator )\n> > ( define ul1 ( unrolled-list ' ( # ( cracker biscuit ) # ( cookie scone ) ) ) )\n> > ( for/list ( [ x ul1 ] ) x )\n> '(cracker biscuit cookie scone)\n> ```"}
{"text": "# 4.17.1 Sequences\nThe [prop:sequence](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._prop~3asequence%29%29) property provides more flexibility in specifying iteration, such as when a pre-processing step is needed to prepare the data for iteration. The [make-do-sequence](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-do-sequence%29%29) function creates a sequence given a thunk that returns procedures to implement a sequence, and the [prop:sequence](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._prop~3asequence%29%29) property can be associated with a structure type to implement its implicit conversion to a sequence."}
{"text": "# 4.17.1 Sequences\nFor most sequence types, extracting elements from a sequence has no side-effect on the original sequence value; for example, extracting the sequence of elements from a list does not change the list. For other sequence types, each extraction implies a side effect; for example, extracting the sequence of bytes from a port causes the bytes to be read from the port. A sequence’s state may either span all uses of the sequence, as for a port, or it may be confined to each distinct time that a sequence is initiated by a [for](for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29) form, [sequence->stream](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-~3estream%29%29), [sequence-generate](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29), or [sequence-generate*](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%2A%29%29). Concretely, the thunk passed to [make-do-sequence](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-do-sequence%29%29) is called to [initiate](#%28tech._initiate%29) the sequence each time the sequence is used. Accordingly, different sequences behave differently when they are [initiate](#%28tech._initiate%29)d multiple times."}
{"text": "# 4.17.1 Sequences\n> ```racket\n> > ( define ( double-initiate s1 ) ; initiate the sequence twice ( define-values ( more?.1 next.1 ) ( sequence-generate s1 ) ) ( define-values ( more?.2 next.2 ) ( sequence-generate s1 ) ) ; alternate fetching from sequence via the two initiations ( list ( next.1 ) ( next.2 ) ( next.1 ) ( next.2 ) ) )\n> > ( double-initiate ( open-input-string \"abcdef\" ) )\n> '(97 98 99 100)\n> > ( double-initiate ( list 97 98 99 100 ) )\n> '(97 97 98 98)\n> > ( double-initiate ( in-naturals 97 ) )\n> '(97 97 98 98)\n> ```\nAlso, subsequent elements in a sequence may be “consumed” just by calling the first result of [sequence-generate](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29), even if the second result is never called.\n> ```racket\n> > ( define ( double-initiate-and-use-more? s1 ) ; initiate the sequence twice ( define-values ( more?.1 next.1 ) ( sequence-generate s1 ) ) ( define-values ( more?.2 next.2 ) ( sequence-generate s1 ) ) ; alternate fetching from sequence via the two initiations ; but this time call `more?` in between ( list ( next.1 ) ( more?.1 ) ( next.2 ) ( more?.2 ) ( next.1 ) ( more?.1 ) ( next.2 ) ( more?.2 ) ) )\n> > ( double-initiate-and-use-more? ( open-input-string \"abcdef\" ) )\n> '(97 #t 99 #t 98 #t 100 #t)\n> ```\nIn this example, the state embedded in the first call to [sequence-generate](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._sequence-generate%29%29) “takes” the 98 just by virtue of the invocation of more?.1."}
{"text": "# 4.17.1 Sequences\nIndividual elements of a sequence typically correspond to single values, but an element may also correspond to multiple values. For example, a hash table generates two values—a key and its value—for each element in the sequence."}
{"text": "##### 4.17.1.1 Sequence Predicate and Constructors\n> ```\n(sequence? v) → boolean?\n v : any/c\n```\nReturns #t if v can be used as a sequence, #f otherwise.\n\nExamples:\n\n> ```racket\n> > ( sequence? 42 )\n> #t\n> > ( sequence? ' ( a b c ) )\n> #t\n> > ( sequence? \"word\" )\n> #t\n> > ( sequence? #\\x )\n> #f\n> ```\n\n> ```\n(in-range end) → stream?\n end : real?\n(in-range start end [step) → stream?\n start : real?\n end : real?\n step : real? = 1```\n\n\nReturns a sequence (that is also a [stream](streams.html#%28tech._stream%29)) whose elements are numbers. The single-argument case ([in-range](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29) end) is equivalent to ([in-range](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29) 0 end 1). The first number in the sequence is start, and each successive element is generated by adding step to the previous element. The sequence stops before an element that would be greater or equal to end if step is non-negative, or less or equal to end if step is negative.\n\nAn [in-range](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29) application can provide better performance for number iteration when it appears directly in a [for](for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29) clause.\n\nExample: gaussian sum\n\n> ```racket\n> > ( for/sum ( [ x ( in-range 10 ) ] ) x )\n> 45\n> ```\n\nExample: sum of even numbers\n\n> ```racket\n> > ( for/sum ( [ x ( in-range 0 100 2 ) ] ) x )\n> 2450\n> ```\n\nWhen given zero as step, [in-range](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-range%29%29) returns an infinite sequence. It may also return infinite sequences when step is a very small number, and either step or the sequence elements are floating-point numbers.\n\n> ```\n(in-inclusive-range start end [step) → stream?\n start : real?\n end : real?\n step : real? = 1\n```"}
{"text": "# 4.17.1 Sequences\nSimilar to in-range, but the sequence stopping condition is changed so that the last element is allowed to be equal to end.\nAn in-inclusive-range application can provide better performance for number iteration when it appears directly in a for clause.\nExamples:\n> ```racket\n> > ( sequence → list ( in-inclusive-range 7 11 ) )\n> '(7 8 9 10 11)\n> > ( sequence → list ( in-inclusive-range 7 11 2 ) )\n> '(7 9 11)\n> > ( sequence → list ( in-inclusive-range 7 10 2 ) )\n> '(7 9)\n> ```\nAdded in version 8.0.0.13 of package base.\n> ```\n(in-naturals [start) → stream?\n start : exact-nonnegative-integer? = 0```\nReturns an infinite sequence (that is also a [stream](streams.html#%28tech._stream%29)) of exact integers starting with start, where each element is one more than the preceding element.\nAn [in-naturals](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-naturals%29%29) application can provide better performance for integer iteration when it appears directly in a [for](for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29) clause.\nExample:\n> ```racket\n> > ( for/list ( [ k ( in-naturals ) ] [ x ( in-range 10 ) ] ) ( list k x ) )\n> '((0 0) (1 1) (2 2) (3 3) (4 4) (5 5) (6 6) (7 7) (8 8) (9 9))\n> ```\n> ```\n(in-list lst) → stream?\n lst : list?"}
{"text": "# 4.17.1 Sequences\n```\nReturns a sequence (that is also a stream) that is equivalent to using lst directly as a sequence.\n\n> > > See Pairs and Lists for information on using lists as sequences.\n\nAn in-list application can provide better performance for list iteration when it appears directly in a for clause.\n\nSee for for information on the reachability of list elements during an iteration.\n\nExample:\n\n> ```racket\n> > ( for/list ( [ x ( in-list ' ( 3 1 4 ) ) ] ) ` ( , x , ( * x x ) ) )\n> '((3 9) (1 1) (4 16))\n> ```\n\nChanged in version 6.7.0.4 of package base: Improved element-reachability guarantee for lists in for.\n\n> ```\n(in-mlist mlst) → sequence?\n mlst : mlist?```\n\n\nReturns a sequence equivalent to mlst. Although the expectation is that mlst is [mutable list](mpairs.html#%28tech._mutable._list%29), [in-mlist](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-mlist%29%29) initially checks only whether mlst is a [mutable pair](mpairs.html#%28tech._mutable._pair%29) or [null](pairs.html#%28def._%28%28quote._~23~25kernel%29._null%29%29), since it could change during iteration.\n\n> > > See [Mutable Pairs and Lists](mpairs.html) for information on using mutable lists as sequences.\n\nAn [in-mlist](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-mlist%29%29) application can provide better performance for mutable list iteration when it appears directly in a [for](for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29) clause.\n\nExample:\n\n> ```racket\n> > ( for/list ( [ x ( in-mlist ( mcons \"RACKET\" ( mcons \"LANG\" ' ( ) ) ) ) ] ) ( string-length x ) )\n> '(6 4)\n> ```\n\n> ```\n(in-vector vec [start stop step) → sequence?\n vec : vector?\n start : exact-nonnegative-integer? = 0\n stop : (or/c exact-integer? #f) = #f\n step : (and/c exact-integer? (not/c zero?)) = 1\n```"}
{"text": "# 4.17.1 Sequences\nReturns a sequence equivalent to vec when no optional arguments are supplied.\n> > > See Vectors for information on using vectors as sequences.\nThe optional arguments start, stop, and step are analogous to in-range, except that a #f value for stop is equivalent to (vector-length vec). That is, the first element in the sequence is (vector-ref vec start), and each successive element is generated by adding step to index of the previous element. The sequence stops before an index that would be greater or equal to end if step is non-negative, or less or equal to end if step is negative.\nIf start is not a valid index, then the exn:fail:contract exception is raised, except when start, stop, and (vector-length vec) are equal, in which case the result is an empty sequence.\nExamples:\n> ```racket\n> > ( for ( [ x ( in-vector ( vector 1 ) 1 ) ] ) x )\n> > ( for ( [ x ( in-vector ( vector 1 ) 2 ) ] ) x )\n> in-vector: starting index is out of range\n> starting index: 2\n> valid range: [0, 0]\n> vector: '#(1)\n> > ( for ( [ x ( in-vector ( vector ) 0 0 ) ] ) x )\n> > ( for ( [ x ( in-vector ( vector 1 ) 1 1 ) ] ) x )\n> ```\nIf stop is not in \\[-1, (vector-length vec)\\], then the exn:fail:contract exception is raised.\nIf start is less than stop and step is negative, then the exn:fail:contract exception is raised. Similarly, if start is more than stop and step is positive, then the exn:fail:contract exception is raised.\nAn in-vector application can provide better performance for vector iteration when it appears directly in a for clause.\nExamples:"}
{"text": "# 4.17.1 Sequences\n> ```racket\n> > ( define ( histogram vector-of-words ) ( define a-hash ( make-hash ) ) ( for ( [ word ( in-vector vector-of-words ) ] ) ( hash-set! a-hash word ( add1 ( hash-ref a-hash word 0 ) ) ) ) a-hash )\n> > ( histogram # ( \"hello\" \"world\" \"hello\" \"sunshine\" ) )\n> '#hash((\"hello\" . 2) (\"sunshine\" . 1) (\"world\" . 1))\n> ```\n> ```\n(in-string str [start stop step) → sequence?\n str : string?\n start : exact-nonnegative-integer? = 0\n stop : (or/c exact-integer? #f) = #f\n step : (and/c exact-integer? (not/c zero?)) = 1```\nReturns a sequence equivalent to str when no optional arguments are supplied.\n> > > See [Strings](strings.html) for information on using strings as sequences.\nThe optional arguments start, stop, and step are as in [in-vector](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-vector%29%29).\nAn [in-string](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-string%29%29) application can provide better performance for string iteration when it appears directly in a [for](for.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._for%29%29) clause.\nExamples:\n> ```racket\n> > ( define ( line-count str ) ( for/sum ( [ ch ( in-string str ) ] ) ( if ( char=? #\\newline ch ) 1 0 ) ) )\n> > ( line-count \"this string\\nhas\\nthree \\nnewlines\" )\n> 3\n> ```\n> ```\n(in-bytes bstr [start stop step) → sequence?\n bstr : bytes?\n start : exact-nonnegative-integer? = 0\n stop : (or/c exact-integer? #f) = #f\n step : (and/c exact-integer? (not/c zero?)) = 1"}
{"text": "# 4.17.1 Sequences\n```\n(current-input-port)\t→\t\n(-> input-port? . → . any/c)```\n\n\nReturns a sequence whose elements are produced by calling r on in until it produces [eof](port-ops.html#%28def._%28%28quote._~23~25kernel%29._eof%29%29).\n\n> ```\n(in-input-port-bytes in) → sequence?\n in : input-port?\n```\nReturns a sequence equivalent to (in-port read-byte in).\n> ```\n(in-input-port-chars in) → sequence?\n in : input-port?```\nReturns a sequence whose elements are read as characters from in (equivalent to ([in-port](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-port%29%29) [read-char](Byte_and_String_Input.html#%28def._%28%28quote._~23~25kernel%29._read-char%29%29) in)).\n> ```\n(current-input-port)\t→\t\n(-> current-input-port)\n```\n(p)\t→\t\n(-> current-input-port)```\n\n\nReturns a sequence equivalent to ([in-port](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-port%29%29) ([lambda](lambda.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._lambda%29%29) (p) ([read-bytes-line](Byte_and_String_Input.html#%28def._%28%28quote._~23~25kernel%29._read-bytes-line%29%29) p mode)) in). Note that the default mode is 'any, whereas the default mode of [read-bytes-line](Byte_and_String_Input.html#%28def._%28%28quote._~23~25kernel%29._read-bytes-line%29%29) is 'linefeed.\n\n> ```\n(in-hash hash) → sequence?\n hash : hash?\n(in-hash hash bad-index-v) → sequence?\n hash : hash?\n bad-index-v : any/c\n```\nReturns a sequence equivalent to hash, except when bad-index-v is supplied."}
{"text": "# 4.17.1 Sequences\nLike hash-map, iteration via in-hash can adapt to certain modifications to a mutable hash table while a traversal is in progress. Keys removes or remapped by the traversing thread have no immediate adverse affects; the change does not affect a traversal if the key has been seen already, otherwise the traversal skips a deleted key or uses the remapped key’s new value.\nOther concurrent modifications, including key removal by a different thread, can lead to skipped entries or an exception if an expected entry key was removed before its key or value could be fetched. If bad-index-v is supplied, then bad-index-v is returned as both the key and the value in the case that the hash is modified concurrently so that iteration does not have a valid hash index. Providing bad-index-v is particularly useful when iterating through a hash table with weakly held keys, since entries can be removed asynchronously (i.e., after in-hash has committed to another iteration, but before it can access the entry for the next iteration).\nExamples:\n> ```racket\n> > ( define table ( hash ' a 1 ' b 2 ) )\n> > ( for ( [ ( key value ) ( in-hash table ) ] ) ( printf \"key: ~a value: ~a\\n\" key value ) )\n> key: b value: 2 key: a value: 1\n> ```\n> > > See Hash Tables for information on using hash tables as sequences.\nChanged in version 7.0.0.10 of package base: Added the optional bad-index-v argument. \nChanged in version 8.18.0.11: Strengthened the guarantees about traversal with same-thread modifications to a mutable hash table.\n> ```"}
{"text": "# 4.17.1 Sequences\n(in-hash-keys hash) → sequence?\n hash : hash?\n(in-hash-keys hash bad-index-v) → sequence?\n hash : hash?\n bad-index-v : any/c```\nReturns a sequence whose elements are the keys of hash, using bad-index-v in the same way as [in-hash](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29), and with concurrent-modification guarantees analogous to those of [in-hash](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29).\nExamples:\n> ```racket\n> > ( define table ( hash ' a 1 ' b 2 ) )\n> > ( for ( [ key ( in-hash-keys table ) ] ) ( printf \"key: ~a\\n\" key ) )\n> key: b key: a\n> ```\nChanged in version 7.0.0.10 of package base: Added the optional bad-index-v argument. \nChanged in version 8.18.0.11: Strengthened the guarantees about traversal with same-thread modifications to a mutable hash table.\n> ```\n(in-hash-values hash) → sequence?\n hash : hash?\n(in-hash-values hash bad-index-v) → sequence?\n hash : hash?\n bad-index-v : any/c"}
{"text": "# 4.17.1 Sequences\n```\nReturns a sequence whose elements are the values of hash, using bad-index-v in the same way as in-hash, and with concurrent-modification guarantees analogous to those of in-hash.\n\nExamples:\n\n> ```racket\n> > ( define table ( hash ' a 1 ' b 2 ) )\n> > ( for ( [ value ( in-hash-values table ) ] ) ( printf \"value: ~a\\n\" value ) )\n> value: 2 value: 1\n> ```\n\nChanged in version 7.0.0.10 of package base: Added the optional bad-index-v argument. \nChanged in version 8.18.0.11: Strengthened the guarantees about traversal with same-thread modifications to a mutable hash table.\n\n> ```\n(in-hash-pairs hash) → sequence?\n hash : hash?\n(in-hash-pairs hash bad-index-v) → sequence?\n hash : hash?\n bad-index-v : any/c```\n\n\nReturns a sequence whose elements are pairs, each containing a key and its value from hash (as opposed to using hash directly as a sequence to get the key and value as separate values for each element).\n\nThe bad-index-v argument, if supplied, is used in the same way as by [in-hash](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29). When an invalid index is encountered, the pair in the sequence with have bad-index-v as both its [car](pairs.html#%28def._%28%28quote._~23~25kernel%29._car%29%29) and [cdr](pairs.html#%28def._%28%28quote._~23~25kernel%29._cdr%29%29). The concurrent-modification guarantees for [in-hash-pairs](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash-pairs%29%29) are analogous to those of [in-hash](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-hash%29%29).\n\nExamples:\n\n> ```racket\n> > ( define table ( hash ' a 1 ' b 2 ) )\n> > ( for ( [ key+value ( in-hash-pairs table ) ] ) ( printf \"key and value: ~a\\n\" key+value ) )\n> key and value: (b . 2) key and value: (a . 1)\n> ```\n\nChanged in version 7.0.0.10 of package base: Added the optional bad-index-v argument. \nChanged in version 8.18.0.11: Strengthened the guarantees about traversal with same-thread modifications to a mutable hash table.\n\n> ```\n(in-mutable-hash hash) → sequence?\n hash : (and/c hash? (not/c immutable?) hash-strong?)\n\n(in-mutable-hash hash bad-index-v) → sequence?\n hash : (and/c hash? (not/c immutable?) hash-strong?)\n bad-index-v : any/c\n\n(in-mutable-hash-keys hash) → sequence?\n hash : (and/c hash? (not/c immutable?) hash-strong?)\n\n(in-mutable-hash-keys hash bad-index-v) → sequence?\n hash : (and/c hash? (not/c immutable?) hash-strong?)\n bad-index-v : any/c\n\n(in-mutable-hash-values hash) → sequence?\n hash : (and/c hash? (not/c immutable?) hash-strong?)\n\n(in-mutable-hash-values hash bad-index-v) → sequence?\n hash : (and/c hash? (not/c immutable?) hash-strong?)\n bad-index-v : any/c\n\n(in-mutable-hash-pairs hash) → sequence?\n hash : (and/c hash? (not/c immutable?) hash-strong?)\n\n(in-mutable-hash-pairs hash bad-index-v) → sequence?\n hash : (and/c hash? (not/c immutable?) hash-strong?)\n bad-index-v : any/c\n\n(in-immutable-hash hash) → sequence?\n hash : (and/c hash? immutable?)\n\n(in-immutable-hash hash bad-index-v) → sequence?\n hash : (and/c hash? immutable?)\n bad-index-v : any/c\n\n(in-immutable-hash-keys hash) → sequence?\n hash : (and/c hash? immutable?)\n\n(in-immutable-hash-keys hash bad-index-v) → sequence?\n hash : (and/c hash? immutable?)\n bad-index-v : any/c\n\n(in-immutable-hash-values hash) → sequence?\n hash : (and/c hash? immutable?)\n\n(in-immutable-hash-values hash bad-index-v) → sequence?\n hash : (and/c hash? immutable?)\n bad-index-v : any/c\n\n(in-immutable-hash-pairs hash) → sequence?\n hash : (and/c hash? immutable?)\n\n(in-immutable-hash-pairs hash bad-index-v) → sequence?\n hash : (and/c hash? immutable?)\n bad-index-v : any/c\n\n(in-weak-hash hash) → sequence?\n hash : (and/c hash? hash-weak?)\n\n(in-weak-hash hash bad-index-v) → sequence?\n hash : (and/c hash? hash-weak?)\n bad-index-v : any/c\n\n(in-weak-hash-keys hash) → sequence?\n hash : (and/c hash? hash-weak?)\n\n(in-weak-hash-keys hash bad-index-v) → sequence?\n hash : (and/c hash? hash-weak?)\n bad-index-v : any/c\n\n(in-weak-hash-values hash) → sequence?\n hash : (and/c hash? hash-weak?)\n\n(in-weak-hash-keys hash bad-index-v) → sequence?\n hash : (and/c hash? hash-weak?)\n bad-index-v : any/c\n\n(in-weak-hash-pairs hash) → sequence?\n hash : (and/c hash? hash-weak?)\n\n(in-weak-hash-pairs hash bad-index-v) → sequence?\n hash : (and/c hash? hash-weak?)\n bad-index-v : any/c\n\n(in-ephemeron-hash hash) → sequence?\n hash : (and/c hash? hash-ephemeron?)\n\n(in-ephemeron-hash hash bad-index-v) → sequence?\n hash : (and/c hash? hash-ephemeron?)\n bad-index-v : any/c\n\n(in-ephemeron-hash-keys hash) → sequence?\n hash : (and/c hash? hash-ephemeron?)\n\n(in-ephemeron-hash-keys hash bad-index-v) → sequence?\n hash : (and/c hash? hash-ephemeron?)\n bad-index-v : any/c\n\n(in-ephemeron-hash-values hash) → sequence?\n hash : (and/c hash? hash-ephemeron?)\n\n(in-ephemeron-hash-keys hash bad-index-v) → sequence?\n hash : (and/c hash? hash-ephemeron?)\n bad-index-v : any/c\n\n(in-ephemeron-hash-pairs hash) → sequence?\n hash : (and/c hash? hash-ephemeron?)\n\n(in-ephemeron-hash-pairs hash bad-index-v) → sequence?\n hash : (and/c hash? hash-ephemeron?)\n bad-index-v : any/c\n```"}
{"text": "# 4.17.1 Sequences\nSequence constructors for specific kinds of hash tables. These may perform better than the analogous in-hash forms.\nAdded in version 6.4.0.6 of package base. \nChanged in version 7.0.0.10: Added the optional bad-index-v argument. \nChanged in version 8.0.0.10: Added ephemeron variants.\n> ```\n(in-directory [dir use-dir?) → (sequence/c path?)\n dir : (or/c #f path-string?) = #f\n use-dir? : ((and/c path? complete-path?) . → . any/c)\n = (lambda (dir-path) #t)```\nReturns a sequence that produces all of the paths for files, directories, and links within dir, except for the contents of any directory for which use-dir? returns #f. If dir is not #f, then every produced path starts with dir as its prefix. If dir is #f, then paths in and relative to the current directory are produced.\nAn [in-directory](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._in-directory%29%29) sequence traverses nested subdirectories recursively (filtered by use-dir?). To generate a sequence that includes only the immediate content of a directory, use the result of [directory-list](Filesystem.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._directory-list%29%29) as a sequence.\nThe immediate content of each directory is reported as sorted by [path ```racket\n> > ( current-directory ( path-only ( collection-file-path \"main.rkt\" \"info\" ) ) )\n> > ( for/list ( [ f ( in-directory ) ] ) f )\n> '(#\n |
\n\n |
\n\n |
| (stream-cons #:eager first-expr rest-expr) |
| (stream-cons first-expr #:eager rest-expr) |
| (stream-cons #:eager first-expr #:eager rest-expr) |
\n\n |
| (stream-lazy #:who who-expr stream-expr) |
\n\n | ||||||||||
|
\n\n |
\n |
| |
|
\n\n |
\n\n |
\n | |||||||||||||||
|
\n |
\n | ||||||||||
|
\n\n |
\n\n |
\n\n |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
\n |
[The apply Function](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=application.html%23%2528part._apply%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [apply](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._apply%29%29).\n\nApplies proc using the content of ([list*](pairs.html#%28def._%28%28quote._~23~25kernel%29._list%2A%29%29) v [...](stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29) lst) as the (by-position) arguments. The #:\\[The apply Function](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=application.html%23%2528part._apply%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [keyword-apply](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._keyword-apply%29%29).\nLike [apply](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._apply%29%29), but kw-lst and kw-val-lst supply by-keyword arguments in addition to the by-position arguments of the vs and lst, and in addition to the directly supplied keyword arguments in the #:\\\n | |||
| #:extra-constructor-name make-arity-at-least) | |||
| value : exact-nonnegative-integer? |
\n |
\n\n |
\n\n |
| |
|
\n |
[Programmer-Defined Datatypes](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=define-struct.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces structure types via [struct](define-struct.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._struct%29%29).\nA structure type is a record datatype composing a number of fields. A structure, an instance of a structure type, is a first-class value that contains a value for each field of the structure type. A structure instance is created with a type-specific [constructor](define-struct.html#%28tech._constructor%29) procedure, and its field values are accessed and changed with type-specific [accessor](define-struct.html#%28tech._accessor%29) and [mutator](define-struct.html#%28tech._mutator%29) procedures. In addition, each structure type has a [predicate](define-struct.html#%28tech._predicate%29) procedure that answers #t for instances of the structure type and #f for any other value."}
{"text": "# 5 Structures\nA structure type’s fields are essentially unnamed, though names are supported for error-reporting purposes. The constructor procedure takes one value for each field of the structure type, except that some of the fields of a structure type can be automatic fields; the [automatic fields](#%28tech._automatic._field%29) are initialized to a constant that is associated with the structure type, and the corresponding arguments are omitted from the constructor procedure. All automatic fields in a structure type follow the non-automatic fields.\nA structure type can be created as a structure subtype of an existing base structure type. An instance of a structure subtype can always be used as an instance of the base structure type, but the subtype gets its own predicate procedure, and it may have its own fields in addition to the fields of the base type.\nA structure subtype “inherits” the fields of its base type. If the base type has m fields, and if n fields are specified for the new structure subtype, then the resulting structure type has m+n fields. The value for automatic fields can be different in a subtype than in its base type."}
{"text": "# 5 Structures\nIf m′ of the original m fields are non-automatic (where m′\\[Serialization](serialization.html) also provides information on reading and writing structures.\nTwo structure values are [eqv?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eqv~3f%29%29) if and only if they are [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29). Two structure values are [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) if they are [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29). By default, two structure values are also [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) if they are instances of the same structure type, no fields are opaque, and the results of applying [struct->vector](structutils.html#%28def._%28%28quote._~23~25kernel%29._struct-~3evector%29%29) to the structs are [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29). (Consequently, [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) testing for structures may depend on the current inspector.) A structure type can override the default [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) definition through the [gen:equal+hash](Equality.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._gen~3aequal%2Bhash%29%29) or [gen:equal-mode+hash](Equality.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._gen~3aequal-mode%2Bhash%29%29) [generic interface](struct-generics.html#%28tech._generic._interface%29)."}
{"text": "# 5 Structures\n| |\n|-----------------------------------------------------------------------------------------------------------------------------------------|\n| [5.1 Defining Structure Types: struct](define-struct.html) |\n| [5.2 Creating Structure Types](creatingmorestructs.html) |\n| [5.3 Structure Type Properties](structprops.html) |\n| [5.4 Generic Interfaces](struct-generics.html) |\n| [5.5 Copying and Updating Structures](struct-copy.html) |\n| [5.6 Structure Utilities](structutils.html) |\n| [5.6.1 Additional Structure Utilities](structutils.html#%28part._.Additional_.Structure_.Utilities%29) |\n| [5.7 Structure Type Transformer Binding](structinfo.html) |\n------------------------------------------------------------------------"}
{"text": "# 5.1 Defining Structure Types: struct"}
{"text": "### 5.1 Defining Structure Types: [struct](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._struct%29%29)\n> > > [Programmer-Defined Datatypes](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=define-struct.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces [struct](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._struct%29%29).\n> ```\nsyntax\n(struct id maybe-super (field ...)\n> struct-option ... )\nmaybe-super = \n | super-id\nfield = field-id\n | [field-id field-option ...]\nstruct-option = #:mutable\n | #:super super-expr\n | #:inspector inspector-expr\n | #:auto-value auto-expr\n | #:guard guard-expr\n | #:property prop-expr val-expr\n | #:properties prop-list-expr\n | #:transparent\n | #:prefab\n | #:sealed\n | #:authentic\n | #:name name-id\n | #:extra-name name-id\n | #:constructor-name constructor-id\n | #:extra-constructor-name constructor-id\n | #:reflection-name symbol-expr\n | #:methods gen:name-id method-defs\n | #:omit-define-syntaxes\n | #:omit-define-values\nfield-option = #:mutable\n | #:auto\nmethod-defs = (definition ...)"}
{"text": "### 5.1 Defining Structure Types: [struct](#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._struct%29%29)\n```\nCreates a new structure type (or uses a pre-existing structure type if #:prefab is specified), and binds transformers and variables related to the structure type.\n\nA struct form with n fields defines up to 4+2n names:\n\n- struct:id, a structure type descriptor value that represents the structure type.\n\n- constructor-id (which defaults to id), a constructor procedure that takes m arguments and returns a new instance of the structure type, where m is the number of fields that do not include an #:auto option.\n\n- name-id (which defaults to id), a transformer binding that encapsulates information about the structure type declaration. This binding is used to define subtypes, and it also works with the shared and match forms. For detailed information about the binding of name-id, see Structure Type Transformer Binding.\n\nThe constructor-id and name-id can be the same, in which case name-id performs both roles. In that case, the expansion of name-id as an expression produces an otherwise inaccessible identifier that is bound to the constructor procedure; the expanded identifier has a 'constructor-for property whose value is an identifier that is free-identifier=? to name-id as well as a syntax property accessible via syntax-procedure-alias-property with an identifier that is free-identifier=? to name-id.\n\n- id?, a predicate procedure that returns #t for instances of the structure type (constructed by constructor-id or the constructor for a subtype) and #f for any other value.\n\n- id-field-id, for each field; an accessor procedure that takes an instance of the structure type and extracts the value for the corresponding field.\n\n- set-id-field-id!, for each field that includes a #:mutable option, or when the #:mutable option is specified as a struct-option; a mutator procedure that takes an instance of the structure type and a new field value. The structure is destructively updated with the new value, and #\n\n |
\n\n | ||||||||||
|
\n |
\n |
[Classes and Objects](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=classes.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces classes and objects.\n\n| | |\n|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------:|\n| ([require](require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._require%29%29) [racket/class]()) | package: [base](https://pkgs.racket-lang.org/package/base \"Install this package using `raco pkg install base`\") |\n\nThe bindings documented in this section are provided by the [racket/class]() and [racket](index.html) libraries, but not [racket/base](index.html).\n\nA class specifies\n\n- a collection of fields;\n\n- a collection of methods;\n\n- initial value expressions for the fields; and\n\n- initialization variables that are bound to initialization arguments.\n\nIn the context of the class system, an object is a collection of bindings for fields that are instantiated according to a class description.\n\nThe class system allows a program to define a new class (a derived class) in terms of an existing class (the superclass) using inheritance, overriding, and augmenting:\n\n- inheritance: An object of a derived class supports methods and instantiates fields declared by the derived class’s superclass, as well as methods and fields declared in the derived class expression.\n\n- overriding: Some methods declared in a superclass can be replaced in the derived class. References to the overridden method in the superclass use the implementation in the derived class.\n\n- augmenting: Some methods declared in a superclass can be merely extended in the derived class. The superclass method specifically delegates to the augmenting method in the derived class.\n\nAn interface is a collection of method names to be implemented by a class, potentially with default implementations some methods, combined with a derivation requirement. A class implements an interface when it\n\n- declares (or inherits) a public method for each method in the interface (that does not have an implementation in the interface);\n\n- is derived from the class required by the interface, if any; and\n\n- specifically declares its intention to implement the interface.\n\nA class can implement any number of interfaces. A derived class automatically implements any interface that its superclass implements. Each class also implements an implicitly-defined interface that is associated with the class. The implicitly-defined interface contains all of the class’s public method names, and it requires that all other implementations of the interface are derived from the class. When a class implements an interface but does not explicitly declare an implementation of a method that has a default implementation in the interface, then the default implementation is used for the class.\n\nA new interface can extend one or more interfaces with additional method names; each class that implements the extended interface also implements the original interfaces. The derivation requirements of the original interface must be consistent, and the extended interface inherits the most specific derivation requirement from the original interfaces.\n\nClasses, objects, and interfaces are all values. However, a class or interface is not an object (i.e., there are no “meta-classes” or “meta-interfaces”).\n\n| |\n|--------------------------------------------------------------------------------------------------------------------------|\n| [6.1 Creating Interfaces](createinterface.html) |\n| [6.2 Creating Classes](createclass.html) |\n| [6.2.1 Initialization Variables](createclass.html#%28part._clinitvars%29) |\n| [6.2.2 Fields](createclass.html#%28part._clfields%29) |\n| [6.2.3 Methods](createclass.html#%28part._clmethods%29) |\n| [6.2.3.1 Method Definitions](createclass.html#%28part._clmethoddefs%29) |\n| [6.2.3.2 Inherited and Superclass Methods](createclass.html#%28part._classinherit%29) |\n| [6.2.3.3 Internal and External Names](createclass.html#%28part._extnames%29) |\n| [6.3 Creating Objects](objcreation.html) |\n| [6.4 Field and Method Access](ivaraccess.html) |\n| [6.4.1 Methods](ivaraccess.html#%28part._methodcalls%29) |\n| [6.4.2 Fields](ivaraccess.html#%28part._.Fields%29) |\n| [6.4.3 Generics](ivaraccess.html#%28part._.Generics%29) |\n| [6.5 Mixins](mixins.html) |\n| [6.6 Traits](trait.html) |\n| [6.7 Object and Class Contracts](Object_and_Class_Contracts.html) |\n| [6.8 Object Equality and Hashing](objectequality.html) |\n| [6.9 Object Serialization](objectserialize.html) |\n| [6.10 Object Printing](objectprinting.html) |\n| [6.11 Object, Class, and Interface Utilities](objectutils.html) |\n| [6.12 Surrogates](Surrogates.html) |\n\n------------------------------------------------------------------------\n\n# 6.1 Creating Interfaces\n\n### 6.1 Creating Interfaces\n\n> > > [Classes and Objects](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=classes.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces classes, objects, and interfaces.\n\n> \n\n | ||||||||||||||||||||||||||||||
|
Classes and Objects in The Racket Guide introduces classes and objects.\n> \n |
\n |
\n |
"} {"text": "# 6.2 Creating Classes\n |
\n |
\n |
\n |
\n |
\n |
\n |
| ([init-rest](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._init-rest%29%29)) |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
"} {"text": "# 6.2 Creating Classes\n |
| ([define/public](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._define%2Fpublic%29%29) (id . formals) body ...+) |
\n |
| ([define/pubment](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._define%2Fpubment%29%29) (id . formals) body ...+) |
\n |
| ([define/public-final](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._define%2Fpublic-final%29%29) (id . formals) body ...+) |
\n |
| ([define/override](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._define%2Foverride%29%29) (id . formals) body ...+) |
\n |
| ([define/overment](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._define%2Foverment%29%29) (id . formals) body ...+) |
\n |
| ([define/override-final](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._define%2Foverride-final%29%29) (id . formals) body ...+) |
\n |
| ([define/augment](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._define%2Faugment%29%29) (id . formals) body ...+) |
\n |
| ([define/augride](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._define%2Faugride%29%29) (id . formals) body ...+) |
\n |
| ([define/augment-final](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._define%2Faugment-final%29%29) (id . formals) body ...+) |
\n |
| ([define/private](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._define%2Fprivate%29%29) (id . formals) body ...+) |
\n\n |
| (super id arg ... . arg-list-expr) |
\n\n |
| (inner default-expr id arg ... . arg-list-expr) |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n |
\n |
\n |
\n |
| (send obj-expr method-id arg ... . arg-list-expr) |
\n |
\n\n | ||||||||||
|
\n\n | ||||||||||
|
\n\n |
\n |
\n |
\n |
\n |
\n |
| ([send-generic](#%28form._%28%28lib._racket%2Fprivate%2Fclass-internal..rkt%29._send-generic%29%29) obj-expr generic-expr arg ... . arg-list-expr) |
\n\n | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
\n\n | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
\n\n |
\n\n |
\n |
\n |
\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
| (tag id sig-id) |
\n\n |
\n\n |
\n\n |
| (invoke-unit unit-expr (import tagged-sig-spec ...)) |
\n | ||||||||||
|
\n\n |
\n\n |
\n\n |
| (define-signature-form (sig-form-id id) body ...+) |
| (define-signature-form (sig-form-id id intro-id) body ...+) |
\n\n | |||||||||||||||||||||||||||||||||||
|
\n\n |
Contracts in The Racket Guide introduces contracts.\n\nThe contract system guards one part of a program from another. Programmers specify the behavior of a module’s exports via (provide (contract-out ....)) or (require (contract-in ...)), and the contract system enforces those constraints.\n\n| | |\n|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------:|\n| (require [racket/contract]()) | package: base |\n\nThe bindings documented in this section are provided by the [racket/contract]() and racket libraries, but not racket/base.\n\nContracts come in two forms: those constructed by the various operations listed in this section of the manual, and various ordinary Racket values that double as contracts, including\n\n- symbols, booleans, keywords, and null, which are treated as contracts that recognize themselves, using eq?,\n\n- strings, byte strings, characters, +nan.0, and +nan.f, which are treated as contracts that recognize themselves using equal?,\n\n- numbers (except +nan.0 and +nan.f), which are treated as contracts that recognize themselves using =,\n\n- regular expressions, which are treated as contracts that recognize byte strings and strings that match the regular expression, and\n\n- predicates: any procedure of arity 1 is treated as a predicate. During contract checking, it is applied to the values that appear and should return #f to indicate that the contract failed, and anything else to indicate it passed.\n\nContract combinators are functions such as → and listof that take contracts and produce other contracts.\n\nContracts in Racket are subdivided into three different categories:\n\n- Flat contracts can be fully checked immediately for a given value. These kinds of contracts are essentially predicate functions. Using flat-contract-predicate, you can extract the predicate from an arbitrary flat contract; some flat contracts can be applied like functions, in which case they accept a single argument and return #t or #f to indicate if the given value would be accepted by the contract. All of the flat contracts returned by functions in this library can be used directly as predicates, but ordinary Racket values that double as flat contracts (e.g., numbers or symbols) cannot.\n\nThe function flat-contract? recognizes a flat contract.\n\n- Chaperone contracts may wrap a value in such a way that it signals contract violations later, as the value is used, but are guaranteed to not otherwise change behavior. For example, a function contract wraps a function value and later checks inputs and outputs; any properties that the function value had before being wrapped by the contract are preserved by the contract wrapper.\n\nAll flat contracts may be used where chaperone contracts are expected (but not vice-versa). The function chaperone-contract? recognizes a chaperone contract.\n\n- Impersonator contracts may wrap values and do not provide any guarantees. Impersonator contracts may hide properties of values, or even make them completely opaque (e.g, new-∀/c).\n\nAll contracts may be used where impersonator contracts are expected. The function impersonator-contract? recognizes an impersonator contract.\n\nFor more about this hierarchy, see the section “Impersonators and Chaperones” as well as a research paper \\[Strickland12\\] on chaperones, impersonators, and how they can be used to implement contracts.\n\nChanged in version 6.1.1.8 of package base: Changed +nan.0 and +nan.f to be equal?-based contracts.\n\n| |\n|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| 8.1 Data-structure Contracts |\n| 8.2 Function Contracts |\n| 8.3 Parametric Contracts |\n| 8.4 Lazy Data-structure Contracts |\n| 8.5 Structure Type Property Contracts |\n| 8.6 Attaching Contracts to Values |\n| 8.6.1 Nested Contract Boundaries |\n| 8.6.2 Low-level Contract Boundaries |\n| 8.7 Building New Contract Combinators |\n| 8.7.1 Blame Objects |\n| 8.7.2 Contracts as structs |\n| 8.7.3 Obligation Information in Check Syntax |\n| 8.7.4 Utilities for Building New Combinators |\n| 8.8 Contract Utilities |\n| 8.9 racket/contract/base |\n| 8.10 Collapsible Contracts |\n| 8.11 Legacy Contracts |\n| 8.12 Random generation |\n\n------------------------------------------------------------------------\n\n# 8.1 Data-structure Contracts\n\n### 8.1 Data-structure Contracts\n\n> ```\n(flat-contract-with-explanation get-explanation\n [ #:name name) \n\n → flat-contract?\n get-explanation : ( → any/c (or/c boolean? ( → blame? any)))\n name : any/c = (object-name get-explanation)```\n\n\nProvides a way to use flat contracts that, when a contract fails, provide more information about the failure.\n\nIf get-explanation returns a boolean, then that boolean value is treated as the predicate in a [flat contract](contracts.html#%28tech._flat._contract%29). If it returns a procedure, then it is treated similarly to returning #f, except the result procedure is called to actually signal the contract violation.\n\nThe name argument is used as the name of the contract; it defaults to the name of the get-explanation function.\n\n> ```racket\n> ( flat-contract-with-explanation\n> ( λ ( val )\n> ( cond\n> [ ( even? val ) #t ]\n> [ else\n> ( λ ( blame )\n> ( define more-information ...do-some-complex-computation-here... )\n> ( raise-blame-error blame val\n> ' ( expected: \"an even number\" given: \"~e\"\n> \"and, here is more help: ~s\" )\n> val more-information ) ) ] ) ) )\n> ```\n\n> ```\n(flat-named-contract name\n flat-contract \n [ generator) → flat-contract?\n\n name : any/c\n flat-contract : flat-contract?\n generator : (or/c #f ( → exact-nonnegative-integer? ( → any/c)))\n = #f\n```"}
{"text": "# 7.10 Single-Unit Modules\nProduces a flat contract like flat-contract, but with the name name.\nFor example,\n> ```racket\n> ( define/contract i\n> ( flat-named-contract\n> ' odd-integer\n> ( lambda ( x ) ( and ( integer? x ) ( odd? x ) ) ) )\n> 2 )\n> ```\nThe generator argument adds a generator for the flat-named-contract. See contract-random-generate for more information.\n> \n |
\n |
\n\n |
| n : [real?](number-types.html#%28def._%28%28quote._~23~25kernel%29._real~3f%29%29) |
\n |
| n : real? |
\n\n |
\n\n |
\n\n |
\n\n | ||||||||||||||||||||
| ([cons/dc](#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._cons%2Fdc%29%29) [car-id (cdr-id) contract-expr] [cdr-id contract-expr] cons/dc-option) | ||||||||||||||||||||
|
\n\n | |||||||||||||||
| |||||||||||||||
|
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
| ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
\n\n |
\n\n |
\n\n |
\n\n | ||||||||||||||||||||||||||||||||||||||||
| (with-contract blame-id results-spec free-var-list ... body ...+) | ||||||||||||||||||||||||||||||||||||||||
|
\n\n |
| (define/contract (head args) contract-expr free-var-list body ...+) |
\n\n |
|
|
\n |
| (with-contract-continuation-mark blame+neg-party body ...) |
\n |
\n\n | |||
| #:extra-constructor-name [make-exn:fail:contract:blame](#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fblame..rkt%29._make-exn~3afail~3acontract~3ablame%29%29)) | |||
| object : [blame?](#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fblame..rkt%29._blame~3f%29%29) |
\n |
\n |
\n |
\n |
| : continuation-mark-key? |
\n |
\n |
\n |
| latest-blame : [blame?](Building_New_Contract_Combinators.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fblame..rkt%29._blame~3f%29%29) |
| missing-party : [any/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29) |
| latest-ctc : [contract?](contract-utilities.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fguts..rkt%29._contract~3f%29%29) |
\n | ||||||||||||||||||||
| proj-list : ([listof](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._listof%29%29) ([->](function-contracts.html#%28form._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._-~3e%29%29) [any/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29) [any/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29) [any/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29))) | ||||||||||||||||||||
| contract-list : ([listof](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._listof%29%29) [contract?](contract-utilities.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fguts..rkt%29._contract~3f%29%29)) | ||||||||||||||||||||
| blame-list : ([listof](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._listof%29%29) [blame?](Building_New_Contract_Combinators.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fblame..rkt%29._blame~3f%29%29)) | ||||||||||||||||||||
| missing-party-list : ([listof](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._listof%29%29) [any/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29)) |
\n\n |
| c-c : collapsible-contract? |
| neg-party : any/c |
| ref : (or/c #f impersonator?) |
\n\n | ||||||||||
| count : natural-number/c | ||||||||||
| prev : (or/c collapsible-count-property? any/c) |
\n\n | ||||||
| checking-wrapper : impersonator? |
\n |
Pattern Matching in The Racket Guide introduces pattern matching.\nThe match form and related forms support general pattern matching on Racket values. See also Regular Expressions for information on regular-expression matching on strings, bytes, and streams.\n| | |\n|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------:|\n| (require [racket/match]()) | package: base |\nThe bindings documented in this section are provided by the [racket/match]() and racket libraries, but not racket/base.\n> \n | |||||||||||||||||||||||||||||||||||
|
\n | |||||
|
\n |
| |
|
| |
|
| |
|
\n |
\n |
\n |
\n |
\n |
\n |
\n |
\n |
| |
|
\n |
| ([==](#%28form._%28%28lib._racket%2Fmatch..rkt%29._~3d~3d%29%29) val) |
\n |
[Exceptions](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=exns.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces exceptions.\n\nSee [Exceptions](eval-model.html#%28part._exn-model%29) for information on the Racket exception model. It is based on a proposal by Friedman, Haynes, and Dybvig \\[[Friedman95](doc-bibliography.html#%28cite._.Friedman95%29)\\].\n\nWhenever a primitive error occurs in Racket, an exception is raised. The value that is passed to the current [exception handler](eval-model.html#%28tech._exception._handler%29) for a primitive error is always an instance of the [exn](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn%29%29) structure type. Every [exn](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn%29%29) structure value has a message field that is a string, the primitive error message. The default exception handler recognizes exception values with the [exn?](#%28def._%28%28quote._~23~25kernel%29._exn~3f%29%29) predicate and passes the error message to the current [error display handler](#%28tech._error._display._handler%29) (see [error-display-handler](#%28def._%28%28quote._~23~25kernel%29._error-display-handler%29%29)).\n\nPrimitive procedures that accept a procedure argument with a particular required arity (e.g., [call-with-input-file](file-ports.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._call-with-input-file%29%29), [call/cc](cont.html#%28def._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._call%2Fcc%29%29)) check the argument’s arity immediately, raising [exn:fail:contract](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) if the arity is incorrect.\n\n#### 10.2.1 Error Message Conventions\n\nRacket’s error message convention is to produce error messages with the following shape:\n\n> ```racket\n> ‹ srcloc › : ‹ name › : ‹ message › ;\n> ‹ continued-message › ...\n> ‹ field › : ‹ detail ›\n> ...\n> ```\n\nThe message starts with an optional source location, ‹srcloc›, which is followed by a colon and space when present. The message continues with an optional ‹name› that usually identifies the complaining function, syntactic form, or other entity, but may also refer to an entity being complained about; the ‹name› is also followed by a colon and space when present.\n\nThe ‹message› should be relatively short, and it should be largely independent of specific values that triggered the error. More detailed explanation that requires multiple lines should continue with each line indented by a single space, in which case ‹message› should end in a semi-colon (but the semi-colon should be omitted if ‹continued-message› is not present). Message text should be lowercase—using semi-colons to separate sentences if needed, although long explanations may be better deferred to extra fields.\n\nSpecific values that triggered the error or other helpful information should appear in separate ‹field› lines, each of which is indented by two spaces. If a ‹detail› is especially long or takes multiple lines, it should start on its own line after the ‹field› label, and each of its lines should be indented by three spaces. Field names should be all lowercase.\n\nA ‹field› name should end with ... if the field provides relatively detailed information that might be distracting in common cases but useful in others. For example, when a contract failure is reported for a particular argument of a function, other arguments to the function might be shown in an “other arguments...” field. The intent is that fields whose names end in ... might be hidden by default in an environment such as DrRacket.\n\nMake ‹field› names as short as possible, relying on ‹message› or ‹continued message› text to clarify the meaning for a field. For example, prefer “given” to “given turtle” as a field name, where ‹message› is something like “given turtle is too sleepy” to clarify that “given” refers to a turtle.\n\n#### 10.2.2 Raising Exceptions\n\n> ```\n(raise v [barrier?) → any\n v : any/c\n barrier? : any/c = #t\n```"}
{"text": "# 10.1 Multiple Values\n(parameter)\t→\t\n(-> error message-str v ...)```\nRaises the exception [exn:fail](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail%29%29), which contains an error string. The different forms produce the error string in different ways:\n- ([error](#%28def._%28%28quote._~23~25kernel%29._error%29%29) message-sym) creates a message string by concatenating \"error: \" with the string form of message-sym. Use this form sparingly.\n- ([error](#%28def._%28%28quote._~23~25kernel%29._error%29%29) message-str v [...](stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29)) creates a message string by concatenating message-str with string versions of the vs (as produced by the current error value conversion handler; see [error-value->string-handler](#%28def._%28%28quote._~23~25kernel%29._error-value-~3estring-handler%29%29)). A space is inserted before each v. Use this form sparingly, because it does not conform well to Racket’s [error message conventions](#%28tech._error._message._convention%29); consider [raise-arguments-error](#%28def._%28%28quote._~23~25kernel%29._raise-arguments-error%29%29), instead.\n- ([error](#%28def._%28%28quote._~23~25kernel%29._error%29%29) who-sym format-str v [...](stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29)) creates a message string equivalent to the string created by"}
{"text": "# 10.1 Multiple Values\n > ([format](Writing.html#%28def._%28%28quote._~23~25kernel%29._format%29%29) ([string-append](strings.html#%28def._%28%28quote._~23~25kernel%29._string-append%29%29) \"\\~s: \" format-str) who-sym v [...](stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29))\n When possible, use functions such as [raise-argument-error](#%28def._%28%28quote._~23~25kernel%29._raise-argument-error%29%29), instead, which construct messages that follow Racket’s [error message conventions](#%28tech._error._message._convention%29).\nIn all cases, the constructed message string is passed to [make-exn:fail](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail%29%29), and the resulting exception is raised.\nExamples:\n> ```racket\n> > ( error ' failed )\n> error: failed\n> > ( error \"failed\" 23 ' pizza ( list 1 2 3 ) )\n> failed 23 'pizza '(1 2 3)\n> > ( error ' method-a \"failed because ~a\" \"no argument supplied\" )\n> method-a: failed because no argument supplied\n> ```\n> ```\n(parameter)\t→\t\n(-> raise-user-error message-str v ...)"}
{"text": "# 10.1 Multiple Values\n```\n(parameter)\t→\t\n(-> raise-argument-error name\n expected\n bad-pos\n v ...)```\n\n\nCreates an [exn:fail:contract](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) value and [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29)s it as an exception. The name argument is used as the source procedure’s name in the error message. The expected argument is used as a description of the expected contract (i.e., as a string, but the string is intended to contain a contract expression).\n\nIn the first form, v is the value received by the procedure that does not have the expected type.\n\nIn the second form, the bad argument is indicated by an index bad-pos (counting from 0), and all of the original arguments v are provided (in order). The resulting error message names the bad argument and also lists the other arguments. If bad-pos is not less than the number of vs, the [exn:fail:contract](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) exception is raised.\n\nThe error message generated by [raise-argument-error](#%28def._%28%28quote._~23~25kernel%29._raise-argument-error%29%29) is adjusted via [error-contract->adjusted-string](#%28def._%28%28quote._~23~25kernel%29._error-contract-~3eadjusted-string%29%29) and then [error-message->adjusted-string](#%28def._%28%28quote._~23~25kernel%29._error-message-~3eadjusted-string%29%29) using the default 'racket realm.\n\nExamples:\n\n> ```racket\n> > ( define ( feed-machine bits ) ( unless ( integer? bits ) ( raise-argument-error ' feed-machine \"integer?\" bits ) ) \"fed the machine\" )\n> > ( feed-machine ' turkey )\n> feed-machine: contract violation\n> expected: integer?\n> given: 'turkey\n> > ( define ( feed-cow animal ) ( unless ( eq? animal ' cow ) ( raise-argument-error ' feed-cow \"'cow\" animal ) ) \"fed the cow\" )\n> > ( feed-cow ' turkey )\n> feed-cow: contract violation\n> expected: 'cow\n> given: 'turkey\n> > ( define ( feed-animals cow sheep goose cat ) ( unless ( eq? goose ' goose ) ( raise-argument-error ' feed-animals \"'goose\" 2 cow sheep goose cat ) ) \"fed the animals\" )\n> > ( feed-animals ' cow ' sheep ' dog ' cat )\n> feed-animals: contract violation\n> expected: 'goose\n> given: 'dog\n> argument position: 3rd\n> other arguments...:\n> 'cow\n> 'sheep\n> 'cat\n> ```\n\n> ```\n(parameter)\t→\t\n(-> raise-argument-error* name\n realm\n expected\n bad-pos\n v ...)\n```"}
{"text": "# 10.1 Multiple Values\n(parameter)\t→\t\n(-> raise-result-error name\n expected\n bad-pos\n v ...)```\nLike [raise-argument-error](#%28def._%28%28quote._~23~25kernel%29._raise-argument-error%29%29), but the error message describe v as a “result” instead of an “argument.”\n> ```\n(parameter)\t→\t\n(-> raise-result-error* name\n realm\n expected\n bad-pos\n v ...)\n```\n(parameter)\t→```\n\n\nCreates an [exn:fail:contract](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) value and [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29)s it as an exception. The name is used as the source procedure’s name in the error message. The message is the error message; if message contains newline characters, each extra line should be suitably indented (with one extra space at the start of each line), but it should not end with a newline character. Each field must have a corresponding v, and the two are rendered on their own line in the error message; each v is formatted using the error value conversion handler (see [error-value->string-handler](#%28def._%28%28quote._~23~25kernel%29._error-value-~3estring-handler%29%29)), unless v is a [unquoted-printing string](#%28tech._unquoted._printing._string%29), in which case the string content is [display](Writing.html#%28def._%28%28quote._~23~25kernel%29._display%29%29)ed without using the error value conversion handler. When a string produced by the error value conversion handler or in an unquoted-printing string contains a newline but does not start with a newline, then the string is started on its own line with extra spaces added before each line to indent the string content.\n\nThe error message generated by [raise-arguments-error](#%28def._%28%28quote._~23~25kernel%29._raise-arguments-error%29%29) is adjusted via [error-message->adjusted-string](#%28def._%28%28quote._~23~25kernel%29._error-message-~3eadjusted-string%29%29) using the default 'racket realm.\n\nExamples:\n\n> ```racket\n> > ( raise-arguments-error ' eat \"fish is smaller than its given meal\" \"fish\" 12 \"meal\" 13 )\n> eat: fish is smaller than its given meal\n> fish: 12\n> meal: 13\n> > ( raise-arguments-error ' eat \"not edible\" \"candidate\" ( unquoted-printing-string \"a banana made\\nof wax\" ) )\n> eat: not edible\n> candidate:\n> a banana made\n> of wax\n> ```\n\nChanged in version 8.15.0.2 of package base: Added indentation for v strings that contain newlines.\n\n> ```\n(parameter)\t→\n```"}
{"text": "# 10.1 Multiple Values\n(parameter)\t→\t\n(-> or/c #f exact-integer?)```\nCreates an [exn:fail:contract](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract%29%29) value and [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29)s it as an exception to report an out-of-range error. The type-description string describes the value for which the index is meant to select an element, and index-prefix is a prefix for the word “index.” The index argument is the rejected index. The in-value argument is the value for which the index was meant. The lower-bound and upper-bound arguments specify the valid range of indices, inclusive; if upper-bound is below lower-bound, the value is characterized as “empty.” If alt-lower-bound is not #f, and if index is between alt-lower-bound and upper-bound, then the error is report as index being less than the “starting” index lower-bound.\nSince upper-bound is inclusive, a typical value is one less than the size of a collection—for example, ([sub1](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._sub1%29%29) ([vector-length](vectors.html#%28def._%28%28quote._~23~25kernel%29._vector-length%29%29) vec)), ([sub1](generic-numbers.html#%28def._%28%28quote._~23~25kernel%29._sub1%29%29) ([length](pairs.html#%28def._%28%28quote._~23~25kernel%29._length%29%29) lst)), and so on."}
{"text": "# 10.1 Multiple Values\nThe error message generated by [raise-range-error](#%28def._%28%28quote._~23~25kernel%29._raise-range-error%29%29) is adjusted via [error-message->adjusted-string](#%28def._%28%28quote._~23~25kernel%29._error-message-~3eadjusted-string%29%29) using the default 'racket realm.\nExamples:\n> ```racket\n> > ( raise-range-error ' vector-ref \"vector\" \"starting \" 5 # ( 1 2 3 4 ) 0 3 )\n> vector-ref: starting index is out of range\n> starting index: 5\n> valid range: [0, 3]\n> vector: '#(1 2 3 4)\n> > ( raise-range-error ' vector-ref \"vector\" \"ending \" 5 # ( 1 2 3 4 ) 0 3 )\n> vector-ref: ending index is out of range\n> ending index: 5\n> valid range: [0, 3]\n> vector: '#(1 2 3 4)\n> > ( raise-range-error ' vector-ref \"vector\" \"\" 3 # ( ) 0 -1 )\n> vector-ref: index is out of range for empty vector\n> index: 3\n> > ( raise-range-error ' vector-ref \"vector\" \"ending \" 1 # ( 1 2 3 4 ) 2 3 0 )\n> vector-ref: ending index is smaller than starting index\n> ending index: 1\n> starting index: 2\n> valid range: [0, 3]\n> vector: '#(1 2 3 4)\n> ```\n> ```\n(parameter)\t→\t\n(-> or/c #f exact-integer?)"}
{"text": "# 10.1 Multiple Values\n```\n(parameter)\t→\t\n(-> raise-type-error name expected bad-pos v ...)```\n\n\nLike [raise-argument-error](#%28def._%28%28quote._~23~25kernel%29._raise-argument-error%29%29), but with Racket’s old formatting conventions, and where expected is used as a “type” description instead of a contract expression. Use [raise-argument-error](#%28def._%28%28quote._~23~25kernel%29._raise-argument-error%29%29) or [raise-result-error](#%28def._%28%28quote._~23~25kernel%29._raise-result-error%29%29), instead.\n\nThe error message generated by [raise-type-error](#%28def._%28%28quote._~23~25kernel%29._raise-type-error%29%29) is adjusted via [error-message->adjusted-string](#%28def._%28%28quote._~23~25kernel%29._error-message-~3eadjusted-string%29%29) using the default 'racket realm.\n\n> ```\n(parameter)\t→\n```\n(parameter)\t→\t\n(-> parameter)```\nCreates an [exn:fail:contract:arity](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract~3aarity%29%29) value and [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29)s it as an exception. The name is used for the source procedure’s name in the error message."}
{"text": "# 10.1 Multiple Values\nThe arity-v value must be a possible result from [procedure-arity](procedures.html#%28def._%28%28quote._~23~25kernel%29._procedure-arity%29%29), except that it does not have to be normalized (see [procedure-arity?](procedures.html#%28def._%28%28quote._~23~25kernel%29._procedure-arity~3f%29%29) for the details of normalized arities); [raise-arity-error](#%28def._%28%28quote._~23~25kernel%29._raise-arity-error%29%29) will normalize the arity and use the normalized form in the error message. If name is a procedure, its actual arity is ignored.\nThe arg-v arguments are the actual supplied arguments, which are shown in the error message (using the error value conversion handler; see [error-value->string-handler](#%28def._%28%28quote._~23~25kernel%29._error-value-~3estring-handler%29%29)); also, the number of supplied arg-vs is explicitly mentioned in the message.\nThe error message generated by [raise-arity-error](#%28def._%28%28quote._~23~25kernel%29._raise-arity-error%29%29) is adjusted via [error-message->adjusted-string](#%28def._%28%28quote._~23~25kernel%29._error-message-~3eadjusted-string%29%29) using the default 'racket realm.\nExample:\n> ```racket\n> > ( raise-arity-error ' unite ( arity-at-least 13 ) \"Virginia\" \"Maryland\" )\n> unite: arity mismatch;\n> the expected number of arguments does not match the given\n> number\n> expected: at least 13\n> given: 2\n> arguments...:\n> \"Virginia\"\n> \"Maryland\"\n> ```\n> ```\n(parameter)\t→\t\n(-> or/c symbol? procedure?)"}
{"text": "# 10.1 Multiple Values\n```\n(parameter)\t→\t\n(-> or/c symbol? procedure?)```\n\n\nThe same as [raise-arity-error](#%28def._%28%28quote._~23~25kernel%29._raise-arity-error%29%29), but using the arity representation described with [procedure-arity-mask](procedures.html#%28def._%28%28quote._~23~25kernel%29._procedure-arity-mask%29%29).\n\nAdded in version 7.0.0.11 of package base.\n\n> ```\n(parameter)\t→\t\n(-> or/c symbol? procedure?)\n```\n(parameter)\t→\t\n(-> or/c symbol? #f)```\nLike [raise-arity-error](#%28def._%28%28quote._~23~25kernel%29._raise-arity-error%29%29), but reports a “result” mismatch instead of an “argument” mismatch. The name argument can be #f to omit an initial source for the error. The detail-str argument, if non-#f, should be a string that starts with a newline, since it is added near the end of the generated error message.\nThe error message generated by [raise-result-arity-error](#%28def._%28%28quote._~23~25kernel%29._raise-result-arity-error%29%29) is adjusted via [error-message->adjusted-string](#%28def._%28%28quote._~23~25kernel%29._error-message-~3eadjusted-string%29%29) using the default 'racket realm.\nExample:\n> ```racket\n> > ( raise-result-arity-error ' let-values 2 \"\\n in: example\" ' a 2.0 \"three\" )\n> let-values: result arity mismatch;\n> expected number of values not received\n> expected: 2\n> received: 3\n> in: example\n> arguments...:\n> 'a\n> 2.0\n> \"three\"\n> ```\nAdded in version 6.90.0.26 of package base.\n> ```\n(parameter)\t→\t\n(-> or/c symbol? #f)"}
{"text": "# 10.1 Multiple Values\n```\n(parameter)\t→\t\n(-> or/c symbol? #f)```\n\n\nCreates an [exn:fail:syntax?](#%28def._%28%28quote._~23~25kernel%29._exn~3afail~3asyntax~3f%29%29) value and [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29)s it as an exception. Macros use this procedure to report syntax errors.\n\nThe name argument is usually #f when expr is provided; it is described in more detail below. The message is used as the main body of the error message; if message contains newline characters, each new line should be suitably indented (with one space at the start), and it should not end with a newline character.\n\nThe optional expr argument is the erroneous source syntax object or S-expression (but the expression #f cannot be represented by itself; it must be wrapped as a [syntax object](syntax-model.html#%28tech._syntax._object%29)). The optional sub-expr argument is a syntax object or S-expression (again, #f cannot represent itself) within expr that more precisely locates the error. Both may appear in the generated error-message text if [error-print-source-location](#%28def._%28%28quote._~23~25kernel%29._error-print-source-location%29%29) is #t. Source location information in the error-message text is similarly extracted from sub-expr or expr when at least one is a syntax object and [error-print-source-location](#%28def._%28%28quote._~23~25kernel%29._error-print-source-location%29%29) is #t.\n\nIf sub-expr is provided and not #f, it is used (in syntax form) for the exprs field of the generated exception record, else the expr is used if provided and not #f. In either case, the syntax object is [cons](pairs.html#%28def._%28%28quote._~23~25kernel%29._cons%29%29)ed onto extra-sources to produce the exprs field, or extra-sources is used directly for exprs if neither expr nor sub-expr is provided and not #f. The extra-sources argument is also used directly for exprs in the unusual case that the sub-expr or expr that would be included in exprs cannot be converted to a syntax object (because it contains a cycle).\n\nThe form name used in the generated error message is determined through a combination of the name, expr, and sub-expr arguments:\n\n- When name is #f, and when expr is either an identifier or a syntax pair containing an identifier as its first element, then the form name from the error message is the identifier’s symbol.\n\n- When name is #f and when expr is not an identifier or a syntax pair containing an identifier as its first element, then the form name in the error message is \"?\".\n\n- When name is a symbol, then the symbol is used as the form name in the generated error message.\n\nThe message-suffix string is appended to the end of the error message. If not \"\", it should normally start with a newline and two spaces to add extra fields to the message (see [Error Message Conventions](#%28part._err-msg-conventions%29)).\n\nIf specified, exn should be a constructor or function that has the same signature as the [exn:fail:syntax](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3asyntax%29%29) constructor.\n\nExamples:\n\n> ```racket\n> > ( raise-syntax-error #f \"bad syntax\" ' ( bad syntax ) )\n> ?: bad syntax\n> in: (bad syntax)\n> > ( raise-syntax-error #f \"unbound identifier\" ' unbound-id #:exn exn:fail:syntax:unbound )\n> ?: unbound identifier\n> in: unbound-id\n> ```\n\nChanged in version 6.90.0.18 of package base: Added the message-suffix optional argument. \nChanged in version 8.4.0.6: Added the exn optional argument.\n\n> ```\n(unquoted-printing-string? v) → boolean?\n v : any/c\n\n(unquoted-printing-string s) → unquoted-printing-string?\n s : string?\n\n(unquoted-printing-string-value ups) → string?\n ups : unquoted-printing-string?\n```"}
{"text": "# 10.1 Multiple Values\nAn unquoted-printing string wraps a string and prints, writes, and displays the same way that the string displays. An unquoted-printing string is especially useful with raise-arguments-error to serve as a field “value” that causes literal text to be printed as the field content.\nThe unquoted-printing-string? procedure returns #t if v is a unquoted-printing string, #f otherwise. The unquoted-printing-string creates a unquoted-printing string value that encapsulates the string s, and unquoted-printing-string-value returns the string within a unquoted-printing string.\nAdded in version 6.10.0.2 of package base."}
{"text": "#### 10.2.3 Handling Exceptions\n> ```\n(call-with-exception-handler f thunk) → any\n f : (any/c . → . any)\n thunk : ( → any)```\nInstalls f as the [exception handler](eval-model.html#%28tech._exception._handler%29) for the [dynamic extent](eval-model.html#%28tech._dynamic._extent%29) of the call to thunk. If an exception is raised during the evaluation of thunk (in an extension of the current continuation that does not have its own exception handler), then f is applied to the [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29)d value in the continuation of the [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29) call (but the continuation is normally extended with a [continuation barrier](eval-model.html#%28tech._continuation._barrier%29); see [Prompts, Delimited Continuations, and Barriers](eval-model.html#%28part._prompt-model%29) and [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29))."}
{"text": "# 10.1 Multiple Values\nAny procedure that takes one argument can be an exception handler. Normally, an exception handler escapes from the context of the [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29) call via [abort-current-continuation](cont.html#%28def._%28%28quote._~23~25kernel%29._abort-current-continuation%29%29) or some other escape mechanism. To propagate an exception to the “previous” exception handler—that is, the exception handler associated with the rest of the continuation after the point where the called exception handler was associated with the continuation—an exception handler can simply return a result instead of escaping, in which case the [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29) call propagates the value to the previous exception handler (still in the dynamic extent of the call to [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29), and under the same barrier, if any). If an exception handler returns a result and no previous handler is available, the [uncaught-exception handler](#%28tech._uncaught._exception._handler%29) is used."}
{"text": "# 10.1 Multiple Values\nA call to an exception handler is [parameterize-break](breakhandler.html#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._parameterize-break%29%29)ed to disable breaks, and it is wrapped with [call-with-exception-handler](#%28def._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._call-with-exception-handler%29%29) to install an exception handler that reports both the original and newly raised exceptions via the [error display handler](#%28tech._error._display._handler%29) and then escapes via the [error escape handler](#%28tech._error._escape._handler%29).\n> ```\n(uncaught-exception-handler)\t→\t\n(-> any/c . → . any)\n(uncaught-exception-handler f) → void?\n f\t:\t\n(-> any/c . → . any)"}
{"text": "# 10.1 Multiple Values\n```\n(parameter)\t→```\n\n\nEvaluates each pred-expr and handler-expr in the order that they are specified, and then evaluates the bodys with a new exception handler during its dynamic extent.\n\nThe new exception handler processes an exception only if one of the pred-expr procedures returns a true value when applied to the exception, otherwise the exception handler is invoked from the continuation of the [with-handlers](#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._with-handlers%29%29) expression (by raising the exception again). If an exception is handled by one of the handler-expr procedures, the result of the entire [with-handlers](#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._with-handlers%29%29) expression is the return value of the handler.\n\nWhen an exception is raised during the evaluation of bodys, each predicate procedure pred-expr is applied to the exception value; if a predicate returns a true value, the corresponding handler-expr procedure is invoked with the exception as an argument. The predicates are tried in the order that they are specified.\n\nBefore any predicate or handler procedure is invoked, the continuation of the entire [with-handlers](#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._with-handlers%29%29) expression is restored, but also [parameterize-break](breakhandler.html#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._parameterize-break%29%29)ed to disable breaks. Thus, breaks are disabled by default during the predicate and handler procedures (see [Breaks](breakhandler.html)), and the exception handler is the one from the continuation of the [with-handlers](#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._with-handlers%29%29) expression.\n\nThe [exn:fail?](#%28def._%28%28quote._~23~25kernel%29._exn~3afail~3f%29%29) procedure is useful as a handler predicate to catch all error exceptions. Avoid using ([lambda](lambda.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._lambda%29%29) (x) #t) as a predicate, because the [exn:break](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3abreak%29%29) exception typically should not be caught (unless it will be re-raised to cooperatively break). Beware, also, of catching and discarding exceptions, because discarding an error message can make debugging unnecessarily difficult; instead of discarding an error message, consider logging it via [log-error](logging.html#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._log-error%29%29) or a logging form created by [define-logger](logging.html#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._define-logger%29%29).\n\nExamples:\n\n> ```racket\n> > ( with-handlers ( [ exn:fail:syntax? ( λ ( e ) ( displayln \"got a syntax error\" ) ) ] ) ( raise-syntax-error #f \"a syntax error\" ) )\n> got a syntax error\n> > ( with-handlers ( [ exn:fail:syntax? ( λ ( e ) ( displayln \"got a syntax error\" ) ) ] [ exn:fail? ( λ ( e ) ( displayln \"fallback clause\" ) ) ] ) ( raise-syntax-error #f \"a syntax error\" ) )\n> got a syntax error\n> ```\n\n> ```\nsyntax\n\n(with-handlers* ([pred-expr handler-expr] ...)\n> body ...+ )\n```"}
{"text": "# 10.1 Multiple Values\n(error-escape-handler)\t→\t\n(-> any)\n(error-escape-handler proc) → void?\n proc\t:\t\n(-> any)```\nA parameter for the error escape handler, which takes no arguments and escapes from the dynamic context of an exception. The default error escape handler escapes using ([abort-current-continuation](cont.html#%28def._%28%28quote._~23~25kernel%29._abort-current-continuation%29%29) ([default-continuation-prompt-tag](cont.html#%28def._%28%28quote._~23~25kernel%29._default-continuation-prompt-tag%29%29)) [void](void.html#%28def._%28%28quote._~23~25kernel%29._void%29%29)).\nThe error escape handler is normally called directly by an exception handler, in a [parameterization](eval-model.html#%28tech._parameterization%29) that sets the [error display handler](#%28tech._error._display._handler%29) and [error escape handler](#%28tech._error._escape._handler%29) to the default handlers, and it is normally [parameterize-break](breakhandler.html#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._parameterize-break%29%29)ed to disable breaks. To escape from a run-time error in a different context, use [raise](#%28def._%28%28quote._~23~25kernel%29._raise%29%29) or [error](#%28def._%28%28quote._~23~25kernel%29._error%29%29)."}
{"text": "# 10.1 Multiple Values\nDue to a [continuation barrier](eval-model.html#%28tech._continuation._barrier%29) around exception-handling calls, an error escape handler cannot invoke a full continuation that was created prior to the exception, but it can abort to a prompt (see [call-with-continuation-prompt](cont.html#%28def._%28%28quote._~23~25kernel%29._call-with-continuation-prompt%29%29)) or invoke an escape continuation (see [call-with-escape-continuation](cont.html#%28def._%28%28quote._~23~25kernel%29._call-with-escape-continuation%29%29)).\n> ```\n(error-display-handler)\t→\t\n(-> string? any/c . → . any)\n(error-display-handler proc) → void?\n proc\t:\t\n(-> string? any/c . → . any)\n```\n(error-print-width)\t→\t\n(-> error-print-width)\n(error-print-width width) → void?\n width\t:\t\n(-> error-print-width)```\n\n\nA parameter whose value is used as the maximum number of characters used to print a Racket value that is embedded in a primitive error message.\n\n> ```\n(error-print-context-length)\t→\t\n(-> error-print-context-length cnt)\n(error-print-context-length cnt) → void?\n cnt\t:\t\n(-> error-print-context-length cnt)\n```\n(error-print-source-location)\t→\t\n(-> error-print-source-location include?)```"}
{"text": "# 10.1 Multiple Values\nA [parameter](eval-model.html#%28tech._parameter%29) that controls whether read and syntax error messages include source information, such as the source line and column or the expression. This parameter also controls the error message when a module-defined variable is accessed before its definition is executed; the parameter determines whether the message includes a module name. Only the message field of an [exn:fail:read](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3aread%29%29), [exn:fail:syntax](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3asyntax%29%29), or [exn:fail:contract:variable](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract~3avariable%29%29) structure is affected by the parameter. The default is #t.\n> ```\n(parameter)\t→\t\n(-> any/c exact-nonnegative-integer?\n . → .\n string?)"}
{"text": "# 10.1 Multiple Values\n```\n(parameter)\t→\t\n(-> see print-unreadable)```\n\n\nA [parameter](eval-model.html#%28tech._parameter%29) that determines the error syntax conversion handler, which is used to print a syntax form that is embedded in an error message, such as from [raise-syntax-error](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._raise-syntax-error%29%29) when [error-print-source-location](#%28def._%28%28quote._~23~25kernel%29._error-print-source-location%29%29) is #t.\n\nThe arguments to the handler are analogous to the arguments for a [error value conversion handler](#%28tech._error._value._conversion._handler%29) as configured with [error-value->string-handler](#%28def._%28%28quote._~23~25kernel%29._error-value-~3estring-handler%29%29), except that #f can be provided instead of an integer for the length, meaning that the printed form should not be truncated. The first argument is normally a [syntax object](syntax-model.html#%28tech._syntax._object%29), but in the same way that [raise-syntax-error](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._raise-syntax-error%29%29) accepts other S-expressions, the error syntax conversion handler must also handle representations that are not syntax objects.\n\nAdded in version 8.2.0.8 of package base.\n\n> ```\n(parameter)\t→\t\n(-> syntax? . → . (or/c symbol? #f))\n```\n(parameter)\t→\t\n(-> any/c exact-nonnegative-integer?\n . → .\n string?)```"}
{"text": "# 10.1 Multiple Values\nSimilar to [error-value->string-handler](#%28def._%28%28quote._~23~25kernel%29._error-value-~3estring-handler%29%29), but intended for a module path. The default [write](Writing.html#%28def._%28%28quote._~23~25kernel%29._write%29%29)s the module path to a string.\nAdded in version 8.16.0.3 of package base."}
{"text": "#### 10.2.5 Built-in Exception Types\n> \n | |||
| #:extra-constructor-name [make-exn](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn%29%29) | |||
| #:transparent) | |||
| message : [string?](strings.html#%28def._%28%28quote._~23~25kernel%29._string~3f%29%29) | |||
| continuation-marks : [continuation-mark-set?](contmarks.html#%28def._%28%28quote._~23~25kernel%29._continuation-mark-set~3f%29%29) |
\n | |||
| #:extra-constructor-name [make-exn:fail](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:contract](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3acontract%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:contract:arity](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3acontract~3aarity%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name | |||
| [make-exn:fail:contract:divide-by-zero](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3acontract~3adivide-by-zero%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name | |||
| [make-exn:fail:contract:non-fixnum-result](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3acontract~3anon-fixnum-result%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:contract:continuation](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3acontract~3acontinuation%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:contract:variable](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3acontract~3avariable%29%29) | |||
| #:transparent) | |||
| id : [symbol?](symbols.html#%28def._%28%28quote._~23~25kernel%29._symbol~3f%29%29) |
\n | |||
| #:extra-constructor-name [make-exn:fail:syntax](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3asyntax%29%29) | |||
| #:transparent) | |||
| exprs : ([listof](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._listof%29%29) [syntax?](stxops.html#%28def._%28%28quote._~23~25kernel%29._syntax~3f%29%29)) |
\n | |||
| #:extra-constructor-name [make-exn:fail:syntax:unbound](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3asyntax~3aunbound%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:syntax:missing-module](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3asyntax~3amissing-module%29%29) | |||
| #:transparent) | |||
| path : [module-path?](Module_Names_and_Loading.html#%28def._%28%28quote._~23~25kernel%29._module-path~3f%29%29) |
\n | |||
| #:extra-constructor-name [make-exn:fail:read](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3aread%29%29) | |||
| #:transparent) | |||
| srclocs : ([listof](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._listof%29%29) [srcloc?](#%28def._%28%28quote._~23~25kernel%29._srcloc~3f%29%29)) |
\n | |||
| #:extra-constructor-name [make-exn:fail:read:eof](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3aread~3aeof%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:read:non-char](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3aread~3anon-char%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:filesystem](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3afilesystem%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:filesystem:exists](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3afilesystem~3aexists%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:filesystem:version](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3afilesystem~3aversion%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:filesystem:errno](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3afilesystem~3aerrno%29%29) | |||
| #:transparent) | |||
| errno : ([cons/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._cons%2Fc%29%29) [exact-integer?](number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-integer~3f%29%29) ([or/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29) 'posix 'windows 'gai)) |
\n | ||||||
| #:extra-constructor-name | ||||||
| [make-exn:fail:filesystem:missing-module](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3afilesystem~3amissing-module%29%29) | ||||||
| #:transparent) | ||||||
| path : [module-path?](Module_Names_and_Loading.html#%28def._%28%28quote._~23~25kernel%29._module-path~3f%29%29) |
\n | |||
| #:extra-constructor-name [make-exn:fail:network](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3anetwork%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:network:errno](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3anetwork~3aerrno%29%29) | |||
| #:transparent) | |||
| errno : ([cons/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._cons%2Fc%29%29) [exact-integer?](number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-integer~3f%29%29) ([or/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29) 'posix 'windows 'gai)) |
\n | |||
| #:extra-constructor-name [make-exn:fail:out-of-memory](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3aout-of-memory%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:unsupported](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3aunsupported%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:fail:user](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3afail~3auser%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:break](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3abreak%29%29) | |||
| #:transparent) | |||
| continuation : [continuation?](cont.html#%28def._%28%28quote._~23~25kernel%29._continuation~3f%29%29) |
\n | |||
| #:extra-constructor-name [make-exn:break:hang-up](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3abreak~3ahang-up%29%29) | |||
| #:transparent) |
\n | |||
| #:extra-constructor-name [make-exn:break:terminate](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-exn~3abreak~3aterminate%29%29) | |||
| #:transparent) |
\n |
\n\n | |||
| #:extra-constructor-name [make-srcloc](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._make-srcloc%29%29) | |||
| #:transparent) | |||
| source : [any/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fprivate%2Fmisc..rkt%29._any%2Fc%29%29) | |||
| line : ([or/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29) [exact-positive-integer?](number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-positive-integer~3f%29%29) #f) | |||
| column : ([or/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29) [exact-nonnegative-integer?](number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-nonnegative-integer~3f%29%29) #f) | |||
| position : ([or/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29) [exact-positive-integer?](number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-positive-integer~3f%29%29) #f) | |||
| span : ([or/c](data-structure-contracts.html#%28def._%28%28lib._racket%2Fcontract%2Fbase..rkt%29._or%2Fc%29%29) [exact-nonnegative-integer?](number-types.html#%28def._%28%28quote._~23~25kernel%29._exact-nonnegative-integer~3f%29%29) #f) |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n |
\n\n | ||||||||||
|
\n\n | |||||||||||||||||||||||||
|
[Continuations](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=conts.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces continuations.\nSee [Sub-expression Evaluation and Continuations](eval-model.html#%28part._cont-model%29) and [Prompts, Delimited Continuations, and Barriers](eval-model.html#%28part._prompt-model%29) for general information about continuations. Racket’s support for prompts and composable continuations \\[[Flatt07](doc-bibliography.html#%28cite._.Flatt07%29)\\] closely resembles Sitaram’s % and fcontrol operator \\[[Sitaram93](doc-bibliography.html#%28cite._.Sitaram93%29)\\].\nRacket installs a [continuation barrier](eval-model.html#%28tech._continuation._barrier%29) around evaluation in the following contexts, preventing full-continuation jumps into the evaluation context protected by the barrier:\n- applying an exception handler, an error escape handler, or an error display handler (see [Exceptions](exns.html));\n- applying a macro transformer (see [Syntax Transformers](stxtrans.html)), evaluating a compile-time expression, or applying a module name resolver (see [Resolving Module Names](Module_Names_and_Loading.html#%28part._modnameresolver%29));"}
{"text": "# 10.4 Continuations\n- applying a custom-port procedure (see [Custom Ports](customport.html)), an event guard procedure (see [Events](sync.html)), or a parameter guard procedure (see [Parameters](parameters.html));\n- applying a security-guard procedure (see [Security Guards](securityguards.html));\n- applying a will procedure (see [Wills and Executors](willexecutor.html)); or\n- evaluating or loading code from the stand-alone Racket command line (see [Running Racket or GRacket](running-sa.html)).\nIn addition, extensions of Racket may install barriers in additional contexts. Finally, [call-with-continuation-barrier](#%28def._%28%28quote._~23~25kernel%29._call-with-continuation-barrier%29%29) applies a thunk barrier between the application and the current continuation.\n> ```\n(call-with-continuation-prompt proc\n [ prompt-tag \n handler] \n arg ...) → any\n proc : procedure?\n prompt-tag : continuation-prompt-tag?\n = (default-continuation-prompt-tag)\n handler : (or/c procedure? #f) = #f\n arg : any/c"}
{"text": "# 10.4 Continuations\n```\n(parameter)\t→```\n\n\nResets the current continuation to that of the nearest prompt tagged by prompt-tag in the current continuation; if no such prompt exists, the [exn:fail:contract:continuation](exns.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._exn~3afail~3acontract~3acontinuation%29%29) exception is raised. The vs are delivered as arguments to the target prompt’s handler procedure.\n\nThe protocol for vs supplied to an abort is specific to the prompt-tag. When [abort-current-continuation](#%28def._%28%28quote._~23~25kernel%29._abort-current-continuation%29%29) is used with ([default-continuation-prompt-tag](#%28def._%28%28quote._~23~25kernel%29._default-continuation-prompt-tag%29%29)), generally, a single thunk should be supplied that is suitable for use with the default prompt handler. Similarly, when [call-with-continuation-prompt](#%28def._%28%28quote._~23~25kernel%29._call-with-continuation-prompt%29%29) is used with ([default-continuation-prompt-tag](#%28def._%28%28quote._~23~25kernel%29._default-continuation-prompt-tag%29%29)), the associated handler should generally accept a single thunk argument.\n\nEach [thread](eval-model.html#%28tech._thread%29)’s continuation starts with a prompt for ([default-continuation-prompt-tag](#%28def._%28%28quote._~23~25kernel%29._default-continuation-prompt-tag%29%29)) that uses the default handler, which accepts a single thunk to apply (with the prompt intact).\n\n> ```\n(make-continuation-prompt-tag)\t→\t\n(-> make-continuation-prompt-tag name)\n(make-continuation-prompt-tag name) → continuation-prompt-tag?\n name\t:\t\n(-> make-continuation-prompt-tag name)\n```"}
{"text": "# 10.4 Continuations\nCreates a prompt tag that is not equal? to the result of any other value (including prior or future results from make-continuation-prompt-tag). The optional name argument, if supplied, specifies the name of the prompt tag for printing or object-name.\nChanged in version 7.9.0.13 of package base: The name argument gives the name of the prompt tag.\n> ```\n(default-continuation-prompt-tag) → continuation-prompt-tag?```\nReturns a constant prompt tag for which a prompt is installed at the start of every thread’s continuation; the handler for each thread’s initial prompt accepts any number of values and returns. The result of [default-continuation-prompt-tag](#%28def._%28%28quote._~23~25kernel%29._default-continuation-prompt-tag%29%29) is the default tag for any procedure that accepts a prompt tag.\n> ```\n(default-continuation-prompt-tag)\t→\t\n(-> continuation? . → . any)\n```\n(default-continuation-prompt-tag)\t→\t\n(-> continuation? . → . any)```\n\n\nThe [call/cc](#%28def._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._call%2Fcc%29%29) binding is an alias for [call-with-current-continuation](#%28def._%28%28quote._~23~25kernel%29._call-with-current-continuation%29%29).\n\n> ```\n(call-with-composable-continuation proc\n [ prompt-tag) → any\n\n proc : (continuation? . → . any)\n prompt-tag : continuation-prompt-tag?\n = (default-continuation-prompt-tag)\n```\n(parameter)\t→\t\n(-> continuation? . → . any)```"}
{"text": "# 10.4 Continuations\nLike [call-with-current-continuation](#%28def._%28%28quote._~23~25kernel%29._call-with-current-continuation%29%29), but proc is not called in tail position, and the continuation procedure supplied to proc can only be called during the dynamic extent of the [call-with-escape-continuation](#%28def._%28%28quote._~23~25kernel%29._call-with-escape-continuation%29%29) call.\nA continuation obtained from [call-with-escape-continuation](#%28def._%28%28quote._~23~25kernel%29._call-with-escape-continuation%29%29) is actually a kind of prompt. Escape continuations are provided mainly for backwards compatibility, since they pre-date general prompts in Racket. In the [BC](implementations.html#%28tech._bc%29) implementation of Racket, [call-with-escape-continuation](#%28def._%28%28quote._~23~25kernel%29._call-with-escape-continuation%29%29) is implemented more efficiently than [call-with-current-continuation](#%28def._%28%28quote._~23~25kernel%29._call-with-current-continuation%29%29), so [call-with-escape-continuation](#%28def._%28%28quote._~23~25kernel%29._call-with-escape-continuation%29%29) can sometimes replace [call-with-current-continuation](#%28def._%28%28quote._~23~25kernel%29._call-with-current-continuation%29%29) to improve performance in those older Racket variants.\n> ```\n(call/ec proc) → any\n proc : (continuation? . → . any)"}
{"text": "# 10.4 Continuations\n```\nThe call/ec binding is an alias for call-with-escape-continuation.\n\n> ```\n(call-in-continuation k proc) → any\n k : continuation?\n proc : ( → any)```\n\n\nSimilar to applying the continuation k, but instead of delivering values to the continuation, proc is called with k as the continuation of the call (so the result of proc is returned to the continuation). If k is a composable continuation, the continuation of the call to proc is the current continuation extended with k.\n\nExamples:\n\n> ```racket\n> > ( + 1 ( call/cc ( lambda ( k ) ( call-in-continuation k ( lambda ( ) 4 ) ) ) ) )\n> 5\n> > ( + 1 ( call/cc ( lambda ( k ) ( let ( [ n 0 ] ) ( dynamic-wind void ( lambda ( ) ; n accessed after post thunk ( call-in-continuation k ( lambda ( ) n ) ) ) ( lambda ( ) ( set! n 4 ) ) ) ) ) ) )\n> 5\n> > ( + 1 ( with-continuation-mark ' n 4 ( call/cc ( lambda ( k ) ( with-continuation-mark ' n 0 ( call-in-continuation k ( lambda ( ) ; ' n mark accessed in continuation ( continuation-mark-set-first #f ' n ) ) ) ) ) ) ) )\n> 5\n> ```\n\nAdded in version 7.6.0.17 of package base.\n\n> \n\n |
\n\n |
| |
|
| |
|
| |
|
| |
|
| |
| |
| |
|
| |
| |
| |
|
See also Buffered Asynchronous Channels.\n\n> ```\n(thread-send thd v [fail-thunk) → any\n thd : thread?\n v : any/c\n fail-thunk : (or/c ( → any) #f)\n = (lambda () (raise-mismatch-error ....))```\n\n\nQueues v as a message to thd without blocking. If the message is queued, the result is [#\n\n |
\n\n |
\n |
See also [Thread Mailboxes](threads.html#%28part._threadmbox%29).\n\nAn asynchronous channel is like a [channel](channel.html#%28tech._channel%29), but it buffers values so that a send operation does not wait on a receive operation.\n\nIn addition to its use with procedures that are specific to asynchronous channels, an asynchronous channel can be used as a [synchronizable event](sync.html#%28tech._synchronizable._event%29) (see [Events](sync.html)). An asynchronous channel is [ready for synchronization](sync.html#%28tech._ready._for._synchronization%29) when [async-channel-get](#%28def._%28%28lib._racket%2Fasync-channel..rkt%29._async-channel-get%29%29) would not block; the asynchronous channel’s [synchronization result](sync.html#%28tech._synchronization._result%29) is the same as the [async-channel-get](#%28def._%28%28lib._racket%2Fasync-channel..rkt%29._async-channel-get%29%29) result.\n\n> ```\n(async-channel? v) → boolean?\n v : any/c\n```"}
{"text": "# 11.2.3 Semaphores\nReturns #t if v is an asynchronous channel, #f otherwise.\n> ```\n(make-async-channel [limit) → async-channel?\n limit : (or/c exact-positive-integer? #f) = #f```\nReturns an asynchronous channel with a buffer limit of limit items. A get operation blocks when the channel is empty, and a put operation blocks when the channel has limit items already. If limit is #f, the channel buffer has no limit (so a put never blocks).\n> ```\n(async-channel-get ach) → any/c\n ach : async-channel?\n```\n\n\nBlocks until at least one value is available in ach, and then returns the first of the values that were put into async-channel.\n\n> ```\n(async-channel-try-get ach) → any/c\n ach : async-channel?\n```\nIf at least one value is immediately available in ach, returns the first of the values that were put into ach. If async-channel is empty, the result is #f.\n> ```\n(parameter)\t→\n```\n\n\nPuts v into ach, blocking if ach’s buffer is full until space is available.\n\n> ```\n(async-channel-put-evt ach v) → evt?\n ach : async-channel?\n v : any/c\n```\nReturns a [synchronizable event](sync.html#%28tech._synchronizable._event%29) that is [ready for synchronization](sync.html#%28tech._ready._for._synchronization%29) when ([async-channel-put](#%28def._%28%28lib._racket%2Fasync-channel..rkt%29._async-channel-put%29%29) ach v) would return a value (i.e., when the channel holds fewer values already than its limit); the [synchronization result](sync.html#%28tech._synchronization._result%29) of a asynchronous channel-put event is the asynchronous channel-put event itself.\nExamples:"}
{"text": "# 11.2.3 Semaphores\n> ```racket\n> ( define ( server input-channel output-channel ) ( thread ( lambda ( ) ( define ( get ) ( async-channel-get input-channel ) ) ( define ( put x ) ( async-channel-put output-channel x ) ) ( define ( do-large-computation ) ( sqrt 9 ) ) ( let loop ( [ data ( get ) ] ) ( case data [ ( quit ) ( void ) ] [ ( add ) ( begin ( put ( + 1 ( get ) ) ) ( loop ( get ) ) ) ] [ ( long ) ( begin ( put ( do-large-computation ) ) ( loop ( get ) ) ) ] ) ) ) ) ) ( define to-server ( make-async-channel ) ) ( define from-server ( make-async-channel ) )\n> > ( server to-server from-server )\n> #[Parallelism with Futures](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=parallelism.html%23%2528part._effective-futures%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces futures.\n| | |\n|:----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------:|\n| ([require](require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._require%29%29) [racket/future]()) | package: [base](https://pkgs.racket-lang.org/package/base \"Install this package using `raco pkg install base`\") |\nThe bindings documented in this section are provided by the [racket/future]() and [racket](index.html) libraries, but not [racket/base](index.html)."}
{"text": "# 11.4 Futures\n> > > Support for parallelism via [future](#%28def._%28%28lib._racket%2Ffuture..rkt%29._future%29%29) is normally enabled for all platforms in the [CS](implementations.html#%28tech._c%29) implementation of Racket. In the [BC](implementations.html#%28tech._bc%29) implementation, support for parallelism is enabled by default for Windows, Linux x86/x86_64, and Mac OS x86/x86_64. To enable support for other platforms building Racket [BC](implementations.html#%28tech._bc%29), use --enable-futures with configure.\nThe [future](#%28def._%28%28lib._racket%2Ffuture..rkt%29._future%29%29) and [touch](#%28def._%28%28lib._racket%2Ffuture..rkt%29._touch%29%29) functions from [racket/future]() provide access to parallelism as supported by the hardware and operating system. In contrast to [thread](threads.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._thread%29%29), which provides concurrency for arbitrary computations without parallelism, [future](#%28def._%28%28lib._racket%2Ffuture..rkt%29._future%29%29) provides parallelism. A future executes its work in parallel (assuming that support for parallelism is available) until it detects an attempt to perform an operation that cannot run safely in parallel. Similarly, work in a future is suspended if it depends in some way on the current continuation, such as raising an exception. Operations that suspend a future are blocking operations. A suspended computation for a future is resumed when [touch](#%28def._%28%28lib._racket%2Ffuture..rkt%29._touch%29%29) is applied to the future."}
{"text": "# 11.4 Futures\n“Safe” parallel execution of a future means that all operations provided by the system must be able to enforce contracts and produce results as documented. “Safe” does not preclude concurrent access to mutable data that is visible in the program. For example, a computation in a future might use [set!](set_.html#%28form._%28%28quote._~23~25kernel%29._set%21%29%29) to modify a shared variable, in which case concurrent assignment to the variable can be visible in other futures and threads. Furthermore, guarantees about the visibility of effects and ordering are determined by the operating system and hardware—which rarely support, for example, the guarantee of sequential consistency that is provided for [thread](threads.html#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._thread%29%29)-based concurrency; see also [Machine Memory Order](memory-order.html). A system operation that seems obviously safe may have an internal implementation that cannot run in parallel; see [Parallelism with Futures](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=parallelism.html%23%2528part._effective-futures%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) for more discussion and an introduction to using [future-visualizer](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?tag=%28mod-path._.%27future-visualizer.%27%29&version=8.18.0.13)) to understand the behavior of system operations."}
{"text": "# 11.4 Futures\nA future never runs in parallel if all of the [custodians](eval-model.html#%28tech._custodian%29) that allow its creating thread to run are shut down. Such futures can execute through a call to [touch](#%28def._%28%28lib._racket%2Ffuture..rkt%29._touch%29%29), however."}
{"text": "#### 11.4.1 Creating and Touching Futures\n> ```\n(future thunk) → future?\n thunk : ( → any)\n(touch f) → any\n f : future?\n```\nThe future procedure returns a future value that encapsulates thunk. The touch function forces the evaluation of the thunk inside the given future, returning the values produced by thunk. After touch forces the evaluation of a thunk, the resulting values are retained by the future in place of thunk, and additional touches of the future return those values.\n\nBetween a call to future and touch for a given future, the given thunk may run speculatively in parallel to other computations, as described above.\n\nExample:\n\n> ```racket\n> > ( let ( [ f ( future ( lambda ( ) ( + 1 2 ) ) ) ] ) ( list ( + 3 4 ) ( touch f ) ) )\n> '(7 3)\n> ```\n\n> ```\n(futures-enabled?) → boolean?```\n\n\nReturns whether parallel support for futures is enabled in the current Racket configuration.\n\n> ```\n(current-future)\t→\t\n(-> or/c #f future?)\n```\nReturns the descriptor of the future whose thunk execution is the current continuation; that is, if a future descriptor f is returned, (touch f) will produce the result of the current continuation. If a future thunk itself uses touch, future-thunk executions can be nested, in which case the descriptor of the most immediately executing future is returned. If the current continuation does not return to the touch of any future, the result is #f.\n> ```\n(future? v) → boolean?\n v : any/c```\nReturns #t if v is a future value, #f otherwise.\n> ```\n(would-be-future thunk) → future?\n thunk : ( → any)"}
{"text": "# 11.4 Futures\n```\nReturns a future that never runs in parallel, but that consistently logs all potentially “unsafe” operations during the execution of the future’s thunk (i.e., operations that interfere with parallel execution).\n\nWith a normal future, certain circumstances might prevent the logging of unsafe operations. For example, when executed with debug-level logging,\n\n> ```racket\n> ( touch ( future ( lambda ( )\n> ( printf \"hello1\" )\n> ( printf \"hello2\" )\n> ( printf \"hello3\" ) ) ) )\n> ```\n\nmight log three messages, one for each printf invocation. However, if the touch is performed before the future has a chance to start running in parallel, the future thunk evaluates in the same manner as any ordinary thunk, and no unsafe operations are logged. Replacing future with would-be-future ensures the logging of all three calls to printf.\n\n> ```\n(processor-count) → exact-positive-integer?```\n\n\nReturns the number of parallel computation units (e.g., processors or cores) that are available on the current machine.\n\nThis is the same binding as available from [racket/place](places.html).\n\n>
| |
|
[Parallelism with Places](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=parallelism.html%23%2528part._effective-places%2529&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces places.\n| | |\n|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------:|\n| ([require](require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._require%29%29) [racket/place]()) | package: [base](https://pkgs.racket-lang.org/package/base \"Install this package using `raco pkg install base`\") |\n| ([require](require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._require%29%29) [racket/place/dynamic]()) | |"}
{"text": "# 11.5 Places\nThe bindings documented in this section are provided by the [racket/place](), [racket/place/dynamic](), and [racket](index.html) libraries, but not [racket/base](index.html).\n[Places](#%28tech._place%29) enable the development of parallel programs that take advantage of machines with multiple processors, cores, or hardware threads.\n> > > Currently, parallel support for places is enabled on all platforms that support Racket [CS](implementations.html#%28tech._c%29), the default implementation of Racket. The [3m](implementations.html#%28tech._3m%29) implementation also supports parallel execution of places by default on Windows, Linux x86/x86_64, and Mac OS x86/x86_64. To enable support for other platforms with [3m](implementations.html#%28tech._3m%29), use --enable-places with configure when building Racket. The [place-enabled?](#%28def._%28%28lib._racket%2Fplace..rkt%29._place-enabled~3f%29%29) function reports whether places run in parallel.\n> > >\n> > > Implementation and operating-system constraints may limit the scalability of places. For example, although places can perform garbage collections in parallel in the [CS](implementations.html#%28tech._c%29) implementation or independently in the [3m](implementations.html#%28tech._3m%29) implementation, a garbage collection may need to manipulate a page table that is shared across all places, and that shared page table can be a bottleneck with enough places—perhaps around 8 or 16."}
{"text": "# 11.5 Places\nA place is a parallel task that is effectively a separate instance of the Racket virtual machine, although all places run within a single operating-system process. Places communicate through place channels, which are endpoints for a two-way buffered communication.\nTo a first approximation, place channels support only immutable, transparent values as messages. In addition, place channels themselves can be sent across channels to establish new (possibly more direct) lines of communication in addition to any existing lines. Finally, mutable values produced by [shared-flvector](flonums.html#%28def._%28%28lib._racket%2Fflonum..rkt%29._shared-flvector%29%29), [make-shared-flvector](flonums.html#%28def._%28%28lib._racket%2Fflonum..rkt%29._make-shared-flvector%29%29), [shared-fxvector](fixnums.html#%28def._%28%28lib._racket%2Ffixnum..rkt%29._shared-fxvector%29%29), [make-shared-fxvector](fixnums.html#%28def._%28%28lib._racket%2Ffixnum..rkt%29._make-shared-fxvector%29%29), [shared-bytes](bytestrings.html#%28def._%28%28quote._~23~25kernel%29._shared-bytes%29%29), and [make-shared-bytes](bytestrings.html#%28def._%28%28quote._~23~25kernel%29._make-shared-bytes%29%29) can be sent across place channels; mutation of such values is visible to all places that share the value, because they are allowed in a shared memory space. See [place-message-allowed?](#%28def._%28%28lib._racket%2Fplace..rkt%29._place-message-allowed~3f%29%29)."}
{"text": "# 11.5 Places\nA [place channel](#%28tech._place._channel%29) can be used as a [synchronizable event](sync.html#%28tech._synchronizable._event%29) (see [Events](sync.html)) to receive a value through the channel. A [place channel](#%28tech._place._channel%29) is [ready for synchronization](sync.html#%28tech._ready._for._synchronization%29) when a message is available on the channel, and the [place channel](#%28tech._place._channel%29)’s [synchronization result](sync.html#%28tech._synchronization._result%29) is the message (which is removed on synchronization). A place can also receive messages with [place-channel-get](#%28def._%28%28lib._racket%2Fplace..rkt%29._place-channel-get%29%29), and messages can be sent with [place-channel-put](#%28def._%28%28lib._racket%2Fplace..rkt%29._place-channel-put%29%29).\nTwo [place channels](#%28tech._place._channel%29) are [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) if they are endpoints for the same underlying channels while both or neither is a [place descriptor](#%28tech._place._descriptor%29). [Place channels](#%28tech._place._channel%29) can be [equal?](Equality.html#%28def._%28%28quote._~23~25kernel%29._equal~3f%29%29) without being [eq?](Equality.html#%28def._%28%28quote._~23~25kernel%29._eq~3f%29%29) after being sent messages through a [place channel](#%28tech._place._channel%29)."}
{"text": "# 11.5 Places\nConstraints on messages across a place channel—and therefore on the kinds of data that places share—enable greater parallelism than [future](futures.html#%28def._%28%28lib._racket%2Ffuture..rkt%29._future%29%29), even including separate [garbage collection](eval-model.html#%28tech._garbage._collection%29) of separate places. At the same time, the setup and communication costs for places can be higher than for [futures](futures.html#%28tech._future%29).\nFor example, the following expression launches two places, echoes a message to each, and then waits for the places to terminate:\n> ```racket\n> ( let ( [ pls ( for/list ( [ i ( in-range 2 ) ] )\n> ( dynamic-place \"place-worker.rkt\" ' place-main ) ) ] )\n> ( for ( [ i ( in-range 2 ) ]\n> [ p pls ] )\n> ( place-channel-put p i )\n> ( printf \"~a\\n\" ( place-channel-get p ) ) )\n> ( for-each place-wait pls ) )\n> ```\nThe \"place-worker.rkt\" module (in a file that is separate from the above code) must export the place-main function that each place executes, where place-main must accept a single [place channel](#%28tech._place._channel%29) argument:\n> > \"place-worker.rkt\"\n> >\n> > > ```racket\n> > > #lang racket\n> > > ( provide place-main )\n> > > ( define ( place-main pch )\n> > > ( place-channel-put pch ( format \"Hello from place ~a\"\n> > > ( place-channel-get pch ) ) ) )\n> > > ```"}
{"text": "# 11.5 Places\nPlace channels are subject to [garbage collection](eval-model.html#%28tech._garbage._collection%29), like other Racket values, and a [thread](eval-model.html#%28tech._thread%29) that is blocked reading from a [place channel](#%28tech._place._channel%29) can be garbage collected if [place channel](#%28tech._place._channel%29)’s writing end becomes unreachable. However, unlike normal [channel](channel.html#%28tech._channel%29) blocking, if otherwise unreachable threads are mutually blocked on place channels that are reachable only from the same threads, the threads and place channels are all considered reachable, instead of unreachable.\nWhen a place is created, its [parameter](eval-model.html#%28tech._parameter%29) values are generally set to the initial values of the parameters in the creating place, except that the current values of the following parameters are used: [current-library-collection-paths](collects.html#%28def._%28%28quote._~23~25kernel%29._current-library-collection-paths%29%29), [current-library-collection-links](collects.html#%28def._%28%28quote._~23~25kernel%29._current-library-collection-links%29%29), and [current-compiled-file-roots](eval.html#%28def._%28%28quote._~23~25kernel%29._current-compiled-file-roots%29%29).\nA newly created place is registered with the [current custodian](eval-model.html#%28tech._current._custodian%29), so that the place is terminated when the custodian is shut down."}
{"text": "#### 11.5.1 Using Places\n> ```\n(place-enabled?) → boolean?\n```\nReturns #t if Racket is configured so that dynamic-place and place create places that can run in parallel, #f if dynamic-place and place are simulated using thread.\n\n> ```\n(place? v) → boolean?\n v : any/c```\n\n\nReturns #t if v is a place descriptor value, #f otherwise. Every [place descriptor](#%28tech._place._descriptor%29) is also a [place channel](#%28tech._place._channel%29).\n\n> ```\n(place-channel? v) → boolean?\n v : any/c\n```\n(parameter)\t→\t\n(-> or/c module-path? path?)```\nCreates a [place](#%28tech._place%29) to run the procedure that is identified by module-path and start-name. The result is a [place descriptor](#%28tech._place._descriptor%29) value that represents the new parallel task; the place descriptor is returned immediately. The place descriptor value is also a [place channel](#%28tech._place._channel%29) that permits communication with the place.\nThe module indicated by module-path must export a function with the name start-name. The function must accept a single argument, which is a [place channel](#%28tech._place._channel%29) that corresponds to the other end of communication for the [place descriptor](#%28tech._place._descriptor%29) returned by [place](#%28form._%28%28lib._racket%2Fplace..rkt%29._place%29%29)."}
{"text": "# 11.5 Places\nIf location is provided, it must be a [place location](#%28tech._place._location%29), such as a distributed places node produced by [create-place-node](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=distributed-places&rel=index.html%23%2528def._%2528%2528lib._racket%252Fplace%252Fdistributed..rkt%2529._create-place-node%2529%2529&version=8.18.0.13).\nWhen the [place](#%28tech._place%29) is created, the initial [exit handler](Exiting.html#%28tech._exit._handler%29) terminates the place, using the argument to the exit handler as the place’s completion value. Use ([exit](Exiting.html#%28def._%28%28quote._~23~25kernel%29._exit%29%29) v) to immediately terminate a place with the completion value v. Since a completion value is limited to an exact integer between 0 and 255, any other value for v is converted to 0.\nIf the function indicated by module-path and start-name returns, then the place terminates with the [completion value](#%28tech._completion._value%29) 0."}
{"text": "# 11.5 Places\nIn the created place, the [current-input-port](port-ops.html#%28def._%28%28quote._~23~25kernel%29._current-input-port%29%29) parameter is set to an empty input port, while the values of the [current-output-port](port-ops.html#%28def._%28%28quote._~23~25kernel%29._current-output-port%29%29) and [current-error-port](port-ops.html#%28def._%28%28quote._~23~25kernel%29._current-error-port%29%29) parameters are connected to the current ports in the creating place. If the output ports in the creating place are [file-stream ports](file-ports.html#%28tech._file._stream._port%29), then the connected ports in the created place share the underlying streams, otherwise a [thread](eval-model.html#%28tech._thread%29) in the creating place pumps bytes from the created place’s ports to the current ports in the creating place.\nMost [parameters](eval-model.html#%28tech._parameter%29) in the created place have their original initial values, but the created place inherits the creating place’s values for the following parameters: [current-directory](Filesystem.html#%28def._%28%28quote._~23~25kernel%29._current-directory%29%29), [current-library-collection-paths](collects.html#%28def._%28%28quote._~23~25kernel%29._current-library-collection-paths%29%29), [current-library-collection-links](collects.html#%28def._%28%28quote._~23~25kernel%29._current-library-collection-links%29%29), and [current-compiled-file-roots](eval.html#%28def._%28%28quote._~23~25kernel%29._current-compiled-file-roots%29%29)."}
{"text": "# 11.5 Places\nThe module-path argument must not be a module path of the form ([quote](quote.html#%28form._%28%28quote._~23~25kernel%29._quote%29%29) sym) unless the module is predefined (see [module-predefined?](Module_Names_and_Loading.html#%28def._%28%28quote._~23~25kernel%29._module-predefined~3f%29%29)).\nThe [dynamic-place](#%28def._%28%28lib._racket%2Fplace..rkt%29._dynamic-place%29%29) binding is protected in the sense of [protect-out](require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._protect-out%29%29), so access to this operation can be prevented by adjusting the code inspector (see [Code Inspectors](modprotect.html)).\nChanged in version 8.2.0.7 of package base: Changed created place to inherit the creating place’s [current-directory](Filesystem.html#%28def._%28%28quote._~23~25kernel%29._current-directory%29%29) value.\n> ```\n(current-output-port)\t→\t\n(-> or/c output-port? #f)\n```\n(parameter)\t→```\n\n\nReturns the [completion value](#%28tech._completion._value%29) of the place indicated by p, blocking until the place has terminated.\n\nIf any pumping threads were created to connect a non-[file-stream port](file-ports.html#%28tech._file._stream._port%29) to the ports in the place for p (see [dynamic-place](#%28def._%28%28lib._racket%2Fplace..rkt%29._dynamic-place%29%29)), [place-wait](#%28def._%28%28lib._racket%2Fplace..rkt%29._place-wait%29%29) returns only when the pumping threads have completed.\n\n> ```\n(place-dead-evt p) → evt?\n p : place?\n```\n(parameter)\t→```"}
{"text": "# 11.5 Places\nImmediately terminates the place, setting the place’s [completion value](#%28tech._completion._value%29) to 1 if the place does not have a completion value already.\n> ```\n(parameter)\t→\t\n(-> or/c #f 'hang-up 'terminate)\n```\nSends the main thread of place p a break; see Breaks.\n\n> ```\n(place-channel) → place-channel? place-channel?```\n\n\nReturns two [place channels](#%28tech._place._channel%29). Data sent through the first channel can be received through the second channel, and data sent through the second channel can be received from the first.\n\nTypically, one place channel is used by the current [place](#%28tech._place%29) to send messages to a destination [place](#%28tech._place%29); the other place channel is sent to the destination [place](#%28tech._place%29) (via an existing [place channel](#%28tech._place._channel%29)).\n\n> ```\n(place-channel-put pch v) → void\n pch : place-channel?\n v : place-message-allowed?\n```\nSends a message v on channel pch. Since place channels are asynchronous, place-channel-put calls are non-blocking.\nSee place-message-allowed? form information on automatic coercions in v, such as converting a mutable string to an immutable string.\n> ```\n(place-channel-get pch) → place-message-allowed?\n pch : place-channel?```\nReturns a message received on channel pch, blocking until a message is available.\n> ```\n(place-channel-put/get pch v) → any/c\n pch : place-channel?\n v : any/c"}
{"text": "# 11.5 Places\n```\n\n\nSends an immutable message v on channel pch and then waits for a message (perhaps a reply) on the same channel.\n\n> ```\n(place-message-allowed? v) → boolean?\n v : any/c\n```\nReturns #t if v is allowed as a message on a place channel, #f otherwise.\nIf ([place-enabled?](#%28def._%28%28lib._racket%2Fplace..rkt%29._place-enabled~3f%29%29)) returns #f, then the result is always #t and no conversions are performed on v as a message. Otherwise, the following kinds of data are allowed as messages:\n- [numbers](numbers.html#%28tech._number%29), [characters](characters.html#%28tech._character%29), [booleans](booleans.html#%28tech._boolean%29), [keywords](keywords.html#%28tech._keyword%29), and [#\n\n |
\n\n |
\n | |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
\n |
\n |
\n |
\n |
\n |
\n | ||||||
|
\n | ||||||
|
\n |
\n\n |
\n\n |
\n\n |
| |
|
\n |
\n |
\n |
\n |
\n\n |
\n\n |
[Tainted Syntax](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=stx-certs.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13) introduces syntax taints.\nA tainted identifier is rejected by the macro expander for use as either a binding or expression. If a syntax object stx is [tainted](#%28tech._tainted%29), then any syntax object in the result of ([syntax-e](stxops.html#%28def._%28%28quote._~23~25kernel%29._syntax-e%29%29) stx) is [tainted](#%28tech._tainted%29), and [datum->syntax](stxops.html#%28def._%28%28quote._~23~25kernel%29._datum-~3esyntax%29%29) with stx as its first argument produces a [tainted](#%28tech._tainted%29) syntax object. Any syntax object in the result of ([syntax-property](stxprops.html#%28def._%28%28quote._~23~25kernel%29._syntax-property%29%29) stx key) is also tainted if it is in a position within the value that would be reached by [datum->syntax](stxops.html#%28def._%28%28quote._~23~25kernel%29._datum-~3esyntax%29%29)’s conversion. Taints cannot be removed."}
{"text": "# 12.8 Syntax Taints\nA syntax object is tainted when it is included in an exception by the macro expander or when it is produced by a function like [expand](Expanding_Top-Level_Forms.html#%28def._%28%28quote._~23~25kernel%29._expand%29%29) using a [code inspector](modprotect.html#%28tech._code._inspector%29) that is not the original code inspector. The function [syntax-taint](#%28def._%28%28quote._~23~25kernel%29._syntax-taint%29%29) also returns a tainted syntax object.\nPrevious versions of Racket included a notion of arming and disarming syntax to trigger taints or avoid taints. That indirection is no longer supported, and the operations [syntax-arm](#%28def._%28%28quote._~23~25kernel%29._syntax-arm%29%29), [syntax-disarm](#%28def._%28%28quote._~23~25kernel%29._syntax-disarm%29%29), [syntax-rearm](#%28def._%28%28quote._~23~25kernel%29._syntax-rearm%29%29), and [syntax-protect](#%28def._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._syntax-protect%29%29) now have no effect on their arguments. Along similar lines, the syntax properties (see [Syntax Object Properties](stxprops.html)) 'taint-mode and 'certify-mode were formerly used to control syntax arming and are no longer specifically recognized by the macro expander.\n> ```\n(syntax-tainted? stx) → boolean?\n stx : syntax?"}
{"text": "# 12.8 Syntax Taints\n```\nReturns #t if stx is tainted, #f otherwise.\n\n> ```\n(syntax-arm stx [inspector use-mode?) → syntax?\n stx : syntax?\n inspector : (or/c inspector? #f) = #f\n use-mode? : any/c = #f```\n\n\nReturns stx.\n\nChanged in version 8.2.0.4 of package base: Changed to just return stx instead of returning “armed” syntax.\n\n> ```\n(syntax-protect stx) → syntax?\n stx : syntax?\n```\nReturns stx.\nChanged in version 8.2.0.4 of package base: Changed to just return stx instead of returning “armed” syntax.\n> ```\n(syntax-disarm stx inspector) → syntax?\n stx : syntax?\n inspector : (or/c inspector? #f)\n```\n\n\nReturns stx.\n\nChanged in version 8.2.0.4 of package base: Changed to just return stx instead of potentially “disarming” syntax.\n\n> ```\n(syntax-rearm stx from-stx [use-mode?) → syntax?\n stx : syntax?\n from-stx : syntax?\n use-mode? : any/c = #f\n```\nReturns stx.\nChanged in version 8.2.0.4 of package base: Changed to just return stx instead of potentially “arming” syntax.\n> ```\n(syntax-taint stx) → syntax?\n stx : syntax?\n```\n\n\nReturns [tainted](#%28tech._tainted%29) version of stx, which is stx if it is already tainted.\n\n------------------------------------------------------------------------\n\n# 12.9 Expanding Top-Level Forms\n\n### 12.9 Expanding Top-Level Forms\n\n> ```\n(current-code-inspector)\t→\t\n(-> current-code-inspector)\n```\n(current-code-inspector)\t→\t\n(-> i.e., the value of (current-code-inspector) when Racket starts)```"}
{"text": "# 12.8 Syntax Taints\nLike ([expand](#%28def._%28%28quote._~23~25kernel%29._expand%29%29) stx insp), except that the argument must be a [syntax object](syntax-model.html#%28tech._syntax._object%29), and its lexical context is not enriched before expansion.\nChanged in version 8.2.0.4 of package base: Added the insp argument and tainting.\n> ```\n(current-code-inspector)\t→\t\n(-> current-code-inspector)\n```\n(current-code-inspector)\t→\t\n(-> current-code-inspector)```\n\n\nLike ([expand-once](#%28def._%28%28quote._~23~25kernel%29._expand-once%29%29) stx), except that the argument must be a [syntax object](syntax-model.html#%28tech._syntax._object%29), and its lexical context is not enriched before expansion.\n\nChanged in version 8.2.0.4 of package base: Added the insp argument and tainting.\n\n> ```\n(current-code-inspector)\t→\t\n(-> current-code-inspector)\n```\n(current-code-inspector)\t→\t\n(-> current-code-inspector)```\nLike ([expand-to-top-form](#%28def._%28%28quote._~23~25kernel%29._expand-to-top-form%29%29) stx), except that the argument must be a [syntax object](syntax-model.html#%28tech._syntax._object%29), and its lexical context is not enriched before expansion.\nChanged in version 8.2.0.4 of package base: Added the insp argument and tainting."}
{"text": "#### 12.9.1 Information on Expanded Modules\nInformation for an expanded [module](module.html#%28form._%28%28quote._~23~25kernel%29._module%29%29) declaration is stored in a set of [syntax properties](stxprops.html#%28tech._syntax._property%29) (see [Syntax Object Properties](stxprops.html)) attached to the syntax object:\n- 'module-body-context — a syntax object whose [lexical information](syntax-model.html#%28tech._lexical._information%29) corresponds to the inside of the module, so it includes the expansion’s [outside-edge scope](syntax-model.html#%28tech._outside._edge._scope%29) and its [inside-edge scope](syntax-model.html#%28tech._inside._edge._scope%29); that is, the syntax object simulates an identifier that is present in the original module body and inaccessible to manipulation by any macro, so that its lexical information includes bindings for the module’s imports and definitions.\n Added in version 6.4.0.1 of package base.\n- 'module-body-inside-context — a syntax object whose [lexical information](syntax-model.html#%28tech._lexical._information%29) corresponds to an identifier that starts with no lexical context and is moved into the macro, so that it includes only the expansions’s [inside-edge scope](syntax-model.html#%28tech._inside._edge._scope%29).\n Added in version 6.4.0.1 of package base."}
{"text": "# 12.8 Syntax Taints\n- 'module-body-context-simple? — a boolean, where #t indicates that the bindings of the module’s body (as recorded in the [lexical information](syntax-model.html#%28tech._lexical._information%29) of the value of the 'module-body-inside-context property) can be directly reconstructed from modules directly imported into the module, including imported for-syntax, for-meta, and for-template.\n Added in version 6.4.0.1 of package base.\nChanged in version 7.0 of package base: Removed 'module-variable-provides, 'module-syntax-provides, 'module-indirect-provides, and 'module-indirect-for-meta-provides properties.\n------------------------------------------------------------------------"}
{"text": "# 12.10 Serializing Syntax"}
{"text": "### 12.10 Serializing Syntax\n> ```\n(current-namespace)\t→\t\n(-> listof symbol?)\n```\nConverts stx to a serialized form that is suitable for use with s-exp → fasl or serialize. Although stx could be serialized with (compile \\`(quote-syntax ,stx)) and then writing the compiled form, syntax-serialize provides more control over serialization:\n\n- The preserve-property-keys lists syntax-property keys to whose values should be preserved in serialization, even if the property value was not added as preserved with syntax-property (so it would be discarded in compiled form). The values associated with the properties to preserve must be serializable in the sense required by syntax-property for a preserved property.\n\n- The provides-namespace argument constrains how much the serialized syntax object can rely on bulk bindings, which are shared binding tables provided by exporting modules. If provides-namespace is #f, then complete binding information is recorded in the syntax object’s serialized form, and no bulk bindings will be needed from the namespace at deserialization. Otherwise, bulk bindings will be used only for modules declared in provides-namespace (i.e., the deserialize-time namespace will have the same module declarations as provides-namespace); note that supplying a namespace with no module bindings is equivalent to supplying #f.\n\n- The base-module-path-index argument specifies a module path index to which binding information in stx is relative. For example, if a syntax object originates from quote-syntax in the body of a module, then base-module-path-index could usefully be the enclosing module’s module path index as produced by (variable-reference → module-path-index (#%variable-reference)) within the module. On deserialization, a different module path index can be supplied to substitute in place of base-module-path-index, which shifts any binding that is relative to the serialize-time module’s identity to be relative to the module identity supplied at deserialize time. If base-module-path-index is #f, then no shifting is supported at deserialize time, and any base-module-path-index supplied at that time is ignored.\n\nA serialized syntax object is otherwise similar to compiled code: it is version-specific, and deserialization will require a sufficiently powerful code inspector.\n\nAdded in version 8.0.0.13 of package base.\n\n> ```\n(syntax-deserialize\n v \n [ #:base-module-path-index base-module-path-index) \n\n → syntax?\n v : any/c\n base-module-path-index : (or/c module-path-index? #f) = #f```\n\n\nConverts the result of [syntax-serialize](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._syntax-serialize%29%29) back to a syntax object. See [syntax-serialize](#%28def._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._syntax-serialize%29%29) for more information.\n\nAdded in version 8.0.0.13 of package base.\n\n------------------------------------------------------------------------\n\n# 12.11 File Inclusion\n\n### 12.11 File Inclusion\n\n| | |\n|:-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------:|\n| ([require](require.html#%28form._%28%28lib._racket%2Fprivate%2Fbase..rkt%29._require%29%29) [racket/include]()) | package: [base](https://pkgs.racket-lang.org/package/base \"Install this package using `raco pkg install base`\") |\n\nThe bindings documented in this section are provided by the [racket/include]() and [racket](index.html) libraries, but not [racket/base](index.html).\n\n> \n\n | |||||||||||||||
|
\n\n |
\n\n |
\n\n |
\n | ||||||
|
\n | ||||||
|
\n\n |
Byte Strings also provides information on bytestrings.\n> ```\n(string-port? p) → boolean?\n p : port?```\nReturns #t if p is a [string port](#%28tech._string._port%29), #f otherwise.\nAdded in version 6.0.1.6 of package base.\n> ```\n(open-input-bytes bstr [name) → (and/c input-port? string-port?)\n bstr : bytes?\n name : any/c = 'string"}
{"text": "# 13.1.6 String Ports\n```\nCreates an input string port that reads characters from bstr (see Byte Strings). Modifying bstr afterward does not affect the byte stream produced by the port. The optional name argument is used as the name for the returned port.\n\nExamples:\n\n> ```racket\n> > ( define sp ( open-input-bytes #\"(apples 42 day)\" ) )\n> > ( define sexp1 ( read sp ) )\n> > ( first sexp1 )\n> 'apples\n> > ( rest sexp1 )\n> '(42 day)\n> > ( read-line ( open-input-bytes #\"the cow jumped over the moon\\nthe little dog\\n\" ) )\n> \"the cow jumped over the moon\"\n> ```\n\n> > > Strings also provides information on strings.\n\n> ```\n(open-input-string str [name) → (and/c input-port? string-port?)\n str : string?\n name : any/c = 'string```\n\n\nCreates an input [string port](#%28tech._string._port%29) that reads bytes from the UTF-8 encoding (see [Encodings and Locales](encodings.html)) of str. The optional name argument is used as the name for the returned port.\n\nExamples:\n\n> ```racket\n> > ( define sp ( open-input-string \"(λ (x) x)\" ) )\n> > ( read sp )\n> '(λ (x) x)\n> > ( define names ( open-input-string \"Günter Harder\\nFrédéric Paulin\\n\" ) )\n> > ( read-line names )\n> \"Günter Harder\"\n> > ( read-line names )\n> \"Frédéric Paulin\"\n> ```\n\n> ```\n(open-output-bytes [name) → (and/c output-port? string-port?)\n name : any/c = 'string\n```\nCreates an output string port that accumulates the output into a byte string. The optional name argument is used as the name for the returned port.\nExamples:"}
{"text": "# 13.1.6 String Ports\n> ```racket\n> > ( define op1 ( open-output-bytes ) )\n> > ( write ' ( ( 1 2 3 ) ( \"Tom\" \"Dick\" ) ( ' a ' b ' c ) ) op1 )\n> > ( get-output-bytes op1 )\n> #\"((1 2 3) (\\\"Tom\\\" \\\"Dick\\\") ((quote a) (quote b) (quote c)))\"\n> > ( define op2 ( open-output-bytes ) )\n> > ( write \"Hi \" op2 )\n> > ( write \"there\" op2 )\n> > ( get-output-bytes op2 )\n> #\"\\\"Hi \\\"\\\"there\\\"\"\n> > ( define op3 ( open-output-bytes ) )\n> > ( write-bytes #\"Hi \" op3 )\n> 3\n> > ( write-bytes #\"there\" op3 )\n> 5\n> > ( get-output-bytes op3 )\n> #\"Hi there\"\n> ```\n> ```\n(open-output-string [name) → (and/c output-port? string-port?)\n name : any/c = 'string```\nThe same as [open-output-bytes](#%28def._%28%28quote._~23~25kernel%29._open-output-bytes%29%29).\nExamples:\n> ```racket\n> > ( define op1 ( open-output-string ) )\n> > ( write ' ( ( 1 2 3 ) ( \"Tom\" \"Dick\" ) ( ' a ' b ' c ) ) op1 )\n> > ( get-output-string op1 )\n> \"((1 2 3) (\\\"Tom\\\" \\\"Dick\\\") ((quote a) (quote b) (quote c)))\"\n> > ( define op2 ( open-output-string ) )\n> > ( write \"Hi \" op2 )\n> > ( write \"there\" op2 )\n> > ( get-output-string op2 )\n> \"\\\"Hi \\\"\\\"there\\\"\"\n> > ( define op3 ( open-output-string ) )\n> > ( write-string \"Hi \" op3 )\n> 3\n> > ( write-string \"there\" op3 )\n> 5\n> > ( get-output-string op3 )\n> \"Hi there\"\n> ```\n> ```\n(get-output-bytes out\n [ reset? \n start-pos \n end-pos) → bytes?\n out : (and/c output-port? string-port?)\n reset? : any/c = #f\n start-pos : exact-nonnegative-integer? = 0\n end-pos : exact-nonnegative-integer? = #f"}
{"text": "# 13.1.6 String Ports\n```\nReturns the bytes accumulated in the string port out so far in a freshly allocated byte string (including any bytes written after the port’s current position, if any). The out port must be an output string port produced by open-output-bytes (or open-output-string) or a structure whose prop:output-port property refers to such an output port (transitively).\n\nIf reset? is true, then all bytes are removed from the port, and the port’s position is reset to 0; if reset? is #f, then all bytes remain in the port for further accumulation (so they are returned for later calls to get-output-bytes or get-output-string), and the port’s position is unchanged.\n\nThe start-pos and end-pos arguments specify the range of bytes in the port to return; supplying start-pos and end-pos is the same as using subbytes on the result of get-output-bytes, but supplying them to get-output-bytes can avoid an allocation. The end-pos argument can be #f, which corresponds to not passing a second argument to subbytes.\n\nExamples:\n\n> ```racket\n> > ( define op ( open-output-bytes ) )\n> > ( write ' ( ( 1 2 3 ) ( \"Tom\" \"Dick\" ) ( ' a ' b ' c ) ) op )\n> > ( get-output-bytes op )\n> #\"((1 2 3) (\\\"Tom\\\" \\\"Dick\\\") ((quote a) (quote b) (quote c)))\"\n> > ( get-output-bytes op #f 3 16 )\n> #\" 2 3) (\\\"Tom\\\" \"\n> > ( get-output-bytes op #t )\n> #\"((1 2 3) (\\\"Tom\\\" \\\"Dick\\\") ((quote a) (quote b) (quote c)))\"\n> > ( get-output-bytes op )\n> #\"\"\n> ```\n\n> ```\n(get-output-string out) → string?\n out : (and/c output-port? string-port?)```\n\n\nReturns ([bytes->string/utf-8](bytestrings.html#%28def._%28%28quote._~23~25kernel%29._bytes-~3estring%2Futf-8%29%29) ([get-output-bytes](#%28def._%28%28quote._~23~25kernel%29._get-output-bytes%29%29) out) #\\\\uFFFD).\n\nExamples:\n\n> ```racket\n> > ( define i ( open-input-string \"hello world\" ) )\n> > ( define o ( open-output-string ) )\n> > ( write ( read i ) o )\n> > ( get-output-string o )\n> \"hello\"\n> ```\n\n------------------------------------------------------------------------\n\n# 13.1.7 Pipes\n\n#### 13.1.7 Pipes\n\nA Racket pipe is internal to Racket, and not related to OS-level pipes for communicating between different processes.OS-level pipes may be created by [subprocess](subprocess.html#%28def._%28%28quote._~23~25kernel%29._subprocess%29%29), opening an existing named file on a Unix filesystem, or starting Racket with pipes for its original input, output, or error port. Such pipes are [file-stream ports](file-ports.html#%28tech._file._stream._port%29), unlike the pipes produced by [make-pipe](#%28def._%28%28quote._~23~25kernel%29._make-pipe%29%29).\n\n> ```\n(pipe-port? p) → boolean?\n p : port?\n```"}
{"text": "# 13.1.6 String Ports\nReturns #t if p is either end of a pipe created by make-pipe, #f otherwise.\nAdded in version 8.15.0.9 of package base.\n> ```\n(make-pipe [limit input-name output-name)\n → (and/c input-port? pipe-port?)\n(and/c output-port? pipe-port?)\n limit : exact-positive-integer? = #f\n input-name : any/c = 'pipe\n output-name : any/c = 'pipe```\nReturns two port values: the first port is an input port and the second is an output port. Data written to the output port is read from the input port, with no intermediate buffering. Unlike some other kinds of ports, pipe ports do not need to be explicitly closed to be reclaimed by [garbage collection](eval-model.html#%28part._gc-model%29).\nIf limit is #f, the new pipe holds an unlimited number of unread bytes (i.e., limited only by the available memory). If limit is a positive number, then the pipe will hold at most limit unread/unpeeked bytes; writing to the pipe’s output port thereafter will block until a read or peek from the input port makes more space available. (Peeks effectively extend the port’s capacity until the peeked bytes are read.)\nThe optional input-name and output-name are used as the names for the returned input and output ports, respectively.\n> ```\n(pipe-content-length pipe-port) → exact-nonnegative-integer?\n pipe-port : pipe-port?"}
{"text": "# 13.1.6 String Ports\n```\nReturns the number of bytes contained in a pipe, where pipe-port is either of the pipe’s ports produced by make-pipe. The pipe’s content length counts all bytes that have been written to the pipe and not yet read (though possibly peeked).\n\n------------------------------------------------------------------------\n\n# 13.1.8 Structures as Ports\n\n#### 13.1.8 Structures as Ports\n\n> \n\n |
\n\n |
See also [Syntax Objects](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=stx-obj.html&version=8.18.0.13) in [The Racket Guide](https://plt.cs.northwestern.edu/new-snapshots/new-snapshots/doc/local-redirect/index.html?doc=guide&rel=index.html&version=8.18.0.13).\n\n> ```\n(current-input-port)\t→\t\n(-> current-input-port)\n```\n(current-input-port)\t→\t\n(-> object-name in)```"}
{"text": "# 13.4 Reading\nAnalogous to calling [read/recursive](#%28def._%28%28quote._~23~25kernel%29._read%2Frecursive%29%29), but the resulting value encapsulates S-expression structure with source-location information. As with [read/recursive](#%28def._%28%28quote._~23~25kernel%29._read%2Frecursive%29%29), when [read-syntax/recursive](#%28def._%28%28quote._~23~25kernel%29._read-syntax%2Frecursive%29%29) is used within the dynamic extent of [read-syntax](#%28def._%28%28quote._~23~25kernel%29._read-syntax%29%29), the result from [read-syntax/recursive](#%28def._%28%28quote._~23~25kernel%29._read-syntax%2Frecursive%29%29) is either a special-comment value, end-of-file, or opaque graph-structure placeholder (not a syntax object). The placeholder can be embedded in an S-expression or syntax object returned by a reader macro, etc., and it will be replaced with the actual syntax object before the outermost [read-syntax](#%28def._%28%28quote._~23~25kernel%29._read-syntax%29%29) returns."}
{"text": "# 13.4 Reading\nUsing [read/recursive](#%28def._%28%28quote._~23~25kernel%29._read%2Frecursive%29%29) within the dynamic extent of [read-syntax](#%28def._%28%28quote._~23~25kernel%29._read-syntax%29%29) does not allow graph structure for reading to be included in the outer [read-syntax](#%28def._%28%28quote._~23~25kernel%29._read-syntax%29%29) parsing, and neither does using [read-syntax/recursive](#%28def._%28%28quote._~23~25kernel%29._read-syntax%2Frecursive%29%29) within the dynamic extent of [read](#%28def._%28%28quote._~23~25kernel%29._read%29%29). In those cases, [read/recursive](#%28def._%28%28quote._~23~25kernel%29._read%2Frecursive%29%29) and [read-syntax/recursive](#%28def._%28%28quote._~23~25kernel%29._read-syntax%2Frecursive%29%29) produce results like [read](#%28def._%28%28quote._~23~25kernel%29._read%29%29) and [read-syntax](#%28def._%28%28quote._~23~25kernel%29._read-syntax%29%29), except that a special-comment value is returned when the input stream starts with a comment (after whitespace).\nSee [Readtables](readtables.html) for an extended example that uses [read-syntax/recursive](#%28def._%28%28quote._~23~25kernel%29._read-syntax%2Frecursive%29%29).\nChanged in version 6.2 of package base: Adjusted use of readtable in the same way as for [read/recursive](#%28def._%28%28quote._~23~25kernel%29._read%2Frecursive%29%29).\n> ```\n(current-input-port)\t→\t\n(-> or/c (any/c any/c . → . any) #f)"}
{"text": "# 13.4 Reading\n```\n(read-case-sensitive)\t→\t\n(-> read-case-sensitive on?)```\n\n\nA [parameter](eval-model.html#%28tech._parameter%29) that controls parsing and printing of symbols. When this parameter’s value is #f, the reader case-folds symbols (e.g., producing 'hi when the input is any one of hi, Hi, HI, or hI). The parameter also affects the way that [write](Writing.html#%28def._%28%28quote._~23~25kernel%29._write%29%29) prints symbols containing uppercase characters; if the parameter’s value is #f, then symbols are printed with uppercase characters quoted by a \\\\ or \\|. The parameter’s value is overridden by quoting \\\\ or \\| vertical-bar quotes and the #cs and #ci prefixes; see [Reading Symbols](reader.html#%28part._parse-symbol%29) for more information. While a module is loaded, the parameter is set to #t (see [current-load](eval.html#%28def._%28%28quote._~23~25kernel%29._current-load%29%29)).\n\n> ```\n(read-square-bracket-as-paren)\t→\t\n(-> read-square-bracket-as-paren on?)\n```\n(read-curly-brace-as-paren)\t→\t\n(-> read-curly-brace-as-paren on?)```\nA [parameter](eval-model.html#%28tech._parameter%29) that controls whether { and } are treated as parentheses. See [Reading Pairs and Lists](reader.html#%28part._parse-pair%29) for more information.\n> ```\n(read-square-bracket-with-tag)\t→\t\n(-> read-square-bracket-with-tag on?)"}
{"text": "# 13.4 Reading\n```\n(read-curly-brace-with-tag)\t→\t\n(-> read-curly-brace-with-tag on?)```\n\n\nA [parameter](eval-model.html#%28tech._parameter%29) that controls whether { and } are treated as parentheses, but the resulting list tagged with #%braces. See [Reading Pairs and Lists](reader.html#%28part._parse-pair%29) for more information.\n\nAdded in version 6.3.0.5 of package base.\n\n> ```\n(read-accept-box)\t→\t\n(-> read-accept-box on?)\n```\n(read-accept-compiled)\t→\t\n(-> read-accept-compiled on?)```\nA [parameter](eval-model.html#%28tech._parameter%29) that controls parsing #\\~ compiled input. See [The Reader](reader.html) and [current-compile](eval.html#%28def._%28%28quote._~23~25kernel%29._current-compile%29%29) for more information.\n> ```\n(read-accept-bar-quote)\t→\t\n(-> read-accept-bar-quote on?)\n```\n(read-accept-graph)\t→\t\n(-> read-accept-graph on?)```\n\n\nA parameter value that controls parsing input with sharing in [read](#%28def._%28%28quote._~23~25kernel%29._read%29%29) mode. See [Reading Graph Structure](reader.html#%28part._parse-graph%29) for more information.\n\n> ```\n(read-syntax-accept-graph)\t→\t\n(-> read-syntax-accept-graph on?)\n```\n(read-decimal-as-inexact)\t→\t\n(-> read-decimal-as-inexact on?)```\nA [parameter](eval-model.html#%28tech._parameter%29) that controls parsing input numbers with a decimal point or exponent (but no explicit exactness tag). See [Reading Numbers](reader.html#%28part._parse-number%29) for more information.\n> ```\n(read-single-flonum)\t→\t\n(-> read-single-flonum on?)"}
{"text": "# 13.4 Reading\n```\n(read-accept-dot)\t→\t\n(-> read-accept-dot on?)```\n\n\nA [parameter](eval-model.html#%28tech._parameter%29) that controls parsing input with a dot, which is normally used for literal cons cells. See [Reading Pairs and Lists](reader.html#%28part._parse-pair%29) for more information.\n\n> ```\n(read-accept-infix-dot)\t→\t\n(-> read-accept-infix-dot on?)\n```\n(read-cdot)\t→\t\n(-> read-cdot on?)```\nA [parameter](eval-model.html#%28tech._parameter%29) that controls parsing input with a dot, in a C structure accessor style. See [Reading with C-style Infix-Dot Notation](reader.html#%28part._parse-cdot%29) for more information.\nAdded in version 6.3.0.5 of package base.\n> ```\n(read-accept-quasiquote)\t→\t\n(-> read-accept-quasiquote on?)\n```\n(read-accept-reader)\t→\t\n(-> read-accept-reader on?)```\n\n\nA [parameter](eval-model.html#%28tech._parameter%29) that controls whether #reader, #lang, or #! are allowed for selecting a parser. See [Reading via an Extension](reader.html#%28part._parse-reader%29) for more information.\n\n> ```\n(read-accept-lang)\t→\t\n(-> read-accept-lang on?)\n```\n(current-readtable)\t→\t\n(-> or/c readtable? #f)\n(current-readtable readtable) → void?\n readtable\t:\t\n(-> or/c readtable? #f)```\nA parameter whose value determines a readtable that adjusts the parsing of S-expression input, where #f implies the default behavior. See [Readtables](readtables.html) for more information.\n> ```\n(parameter)\t→\t\n(-> any)"}
{"text": "# 13.4 Reading\n```\n(current-reader-guard)\t→\t\n(-> any/c . → . any)\n(current-reader-guard proc) → void?\n proc\t:\t\n(-> any/c . → . any)```\n\n\nA parameter whose value converts or rejects (by raising an exception) a module-path datum following #reader. See [Reading via an Extension](reader.html#%28part._parse-reader%29) for more information.\n\n> ```\n(read-on-demand-source)\t→\t\n(-> or/c #f #t (and/c path? complete-path?))\n(read-on-demand-source mode) → void?\n mode\t:\t\n(-> or/c #f #t (and/c path? complete-path?))\n```\n(parameter)\t→\t\n(-> case →\n (input-port? . → . any)\n (input-port? any/c . → . any))```\nGets or sets the port read handler for in. The handler called to read from the port when the built-in [read](#%28def._%28%28quote._~23~25kernel%29._read%29%29) or [read-syntax](#%28def._%28%28quote._~23~25kernel%29._read-syntax%29%29) procedure is applied to the port. (The port read handler is not used for [read/recursive](#%28def._%28%28quote._~23~25kernel%29._read%2Frecursive%29%29) or [read-syntax/recursive](#%28def._%28%28quote._~23~25kernel%29._read-syntax%2Frecursive%29%29).)\nA port read handler is applied to either one argument or two arguments:\n- A single argument is supplied when the port is used with [read](#%28def._%28%28quote._~23~25kernel%29._read%29%29); the argument is the port being read. The return value is the value that was read from the port (or end-of-file)."}
{"text": "# 13.4 Reading\n- Two arguments are supplied when the port is used with [read-syntax](#%28def._%28%28quote._~23~25kernel%29._read-syntax%29%29); the first argument is the port being read, and the second argument is a value indicating the source. The return value is a syntax object that was read from the port (or end-of-file).\nThe default port read handler reads standard Racket expressions with Racket’s built-in parser (see [The Reader](reader.html)). It handles a special result from a custom input port (see [make-input-port](customport.html#%28def._%28%28quote._~23~25kernel%29._make-input-port%29%29)) by treating it as a single expression, except that special-comment values (see [Special Comments](special-comments.html)) are treated as whitespace.\nThe default port read handler itself can be customized through a readtable; see [Readtables](readtables.html) for more information.\n------------------------------------------------------------------------"}
{"text": "# 13.5 Writing"}
{"text": "### 13.5 Writing\n> ```\n(current-output-port)\t→\t\n(-> current-output-port)\n```\n(current-output-port)\t→\t\n(-> current-output-port)```\n\n\nDisplays datum to out, similar to [write](#%28def._%28%28quote._~23~25kernel%29._write%29%29), but usually in such a way that byte- and character-based datatypes are written as raw bytes or characters. If out has a handler associated to it via [port-display-handler](#%28def._%28%28quote._~23~25kernel%29._port-display-handler%29%29), then the handler is called. Otherwise, the [default printer](printing.html) is used (in [display](#%28def._%28%28quote._~23~25kernel%29._display%29%29) mode), as configured by various parameters.\n\nSee [The Printer](printing.html) for more information about the default printer. In particular, note that [display](#%28def._%28%28quote._~23~25kernel%29._display%29%29) may require memory proportional to the depth of the value being printed, due to the initial cycle check.\n\n> ```\n(current-output-port)\t→\t\n(-> current-output-port)\n```\n(current-output-port)\t→\t\n(-> current-output-port)```\nThe same as ([write](#%28def._%28%28quote._~23~25kernel%29._write%29%29) datum out) followed by ([newline](Byte_and_String_Output.html#%28def._%28%28quote._~23~25kernel%29._newline%29%29) out).\nAdded in version 6.1.1.8 of package base.\n> ```\n(current-output-port)\t→\t\n(-> current-output-port)"}
{"text": "# 13.5 Writing\n```\n(current-output-port)\t→\t\n(-> current-output-port)```\n\n\nThe same as ([print](#%28def._%28%28quote._~23~25kernel%29._print%29%29) datum out quote-depth) followed by ([newline](Byte_and_String_Output.html#%28def._%28%28quote._~23~25kernel%29._newline%29%29) out).\n\nThe [println](#%28def._%28%28lib._racket%2Fprivate%2Fmisc..rkt%29._println%29%29) function is not equivalent to println in other languages, because [println](#%28def._%28%28lib._racket%2Fprivate%2Fmisc..rkt%29._println%29%29) uses printing conventions that are closer to [write](#%28def._%28%28quote._~23~25kernel%29._write%29%29) than to [display](#%28def._%28%28quote._~23~25kernel%29._display%29%29). For a closer analog to println in other languages, use [displayln](#%28def._%28%28lib._racket%2Fprivate%2Fmisc..rkt%29._displayln%29%29).\n\nAdded in version 6.1.1.8 of package base.\n\n> ```\n(parameter)\t→\n```\n(error-print-width)\t→\t\n(-> see char-whitespace?)```\nThe same as ([fprintf](#%28def._%28%28quote._~23~25kernel%29._fprintf%29%29) ([current-output-port](port-ops.html#%28def._%28%28quote._~23~25kernel%29._current-output-port%29%29)) form v [...](stx-patterns.html#%28form._%28%28lib._racket%2Fprivate%2Fstxcase-scheme..rkt%29._......%29%29)).\n> ```\n(parameter)\t→"}
{"text": "# 13.5 Writing\n```\n(current-error-port)\t→```\n\n\nFormats to a string. The result is the same as\n\n> ```racket\n> ( let ( [ o ( open-output-string ) ] )\n> ( fprintf o form v ... )\n> ( get-output-string o ) )\n> ```\n\nExample:\n\n> ```racket\n> > ( format \"~a as a string is ~s.\\n\" ' ( 3 4 ) \"(3 4)\" )\n> \"(3 4) as a string is \\\"(3 4)\\\".\\n\"\n> ```\n\n> ```\n(print-pair-curly-braces)\t→\t\n(-> print-pair-curly-braces on?)\n```\n(print-mpair-curly-braces)\t→\t\n(-> print-mpair-curly-braces on?)```\nA [parameter](eval-model.html#%28tech._parameter%29) that controls pair printing. If the value is true, then mutable pairs print using { and } instead of ( and ). The default is #t.\n> ```\n(print-unreadable)\t→\t\n(-> print-unreadable on?)\n```\n(print-graph)\t→\t\n(-> print-graph on?)```\n\n\nA [parameter](eval-model.html#%28tech._parameter%29) that controls printing data with sharing; defaults to #f. See [The Printer](printing.html) for more information.\n\n> ```\n(print-struct)\t→\t\n(-> print-struct on?)\n```\n(print-box)\t→\t\n(-> print-box on?)```\nA [parameter](eval-model.html#%28tech._parameter%29) that controls printing box values; defaults to #t. See [Printing Boxes](printing.html#%28part._print-box%29) for more information.\n> ```\n(print-vector-length)\t→\t\n(-> print-vector-length on?)\n```\n(print-hash-table)\t→\t\n(-> print-hash-table on?)```\n\n\nA [parameter](eval-model.html#%28tech._parameter%29) that controls printing hash tables; defaults to #t. See [Printing Hash Tables](printing.html#%28part._print-hashtable%29) for more information.\n\n> ```\n(print-boolean-long-form)\t→\t\n(-> print-boolean-long-form on?)\n```"}
{"text": "# 13.5 Writing\n(print-reader-abbreviations)\t→\t\n(-> print-reader-abbreviations on?)```\nA [parameter](eval-model.html#%28tech._parameter%29) that controls printing of two-element lists that start with [quote](quote.html#%28form._%28%28quote._~23~25kernel%29._quote%29%29), 'quasiquote, 'unquote, 'unquote-splicing, 'syntax, 'quasisyntax, 'unsyntax, or 'unsyntax-splicing; defaults to #f. See [Printing Pairs and Lists](printing.html#%28part._print-pairs%29) for more information.\n> ```\n(print-as-expression)\t→\t\n(-> print-as-expression on?)\n```\n(print-syntax-width)\t→\t\n(-> or/c +inf.0 0 (and/c exact-integer? (>/c 3)))\n(print-syntax-width width) → void?\n width\t:\t\n(-> or/c +inf.0 0 (and/c exact-integer? (>/c 3)))```\n\n\nA [parameter](eval-model.html#%28tech._parameter%29) that controls printing of [syntax objects](syntax-model.html#%28tech._syntax._object%29). Up to width characters are used to show the datum form of a syntax object within #\\