fix pollen/top in main-preproc
parent
81a5a8b0cb
commit
95d5f0213e
@ -0,0 +1,609 @@
|
||||
#lang scribble/doc
|
||||
|
||||
@title{Quick: An Introduction to Racket with Pictures}
|
||||
|
||||
@author["Matthew Flatt"]
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
|
||||
@(require scribble/manual
|
||||
"mreval.rkt"
|
||||
"keep.rkt"
|
||||
scribble/urls
|
||||
scribble/struct
|
||||
racket/class
|
||||
|
||||
(for-label racket/base
|
||||
racket/gui/base
|
||||
racket/class
|
||||
slideshow pict
|
||||
slideshow/code
|
||||
pict/flash)
|
||||
|
||||
(for-syntax racket/base))
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
|
||||
This tutorial provides a brief introduction to the Racket
|
||||
programming language by using one of its picture-drawing
|
||||
libraries. Even if you don't intend to use Racket for your artistic
|
||||
endeavours, the picture library supports interesting and enlightening
|
||||
examples. After all, a picture is worth five hundred ``hello world''s.
|
||||
|
||||
Along the same lines, we assume that you will run the examples using
|
||||
@link[url:download-drracket]{DrRacket}. Using DrRacket is the fastest
|
||||
way to get a sense of what the language and system feels like, even if
|
||||
you eventually use Racket with Emacs, vi, or some other editor.
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Ready...}
|
||||
|
||||
@link[url:download-drracket]{Download Racket}, install, and then
|
||||
start DrRacket.
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Set...}
|
||||
|
||||
@margin-note{See @seclink[#:indirect? #t
|
||||
#:doc '(lib "scribblings/drracket/drracket.scrbl")
|
||||
"interface-essentials"]{the DrRacket documentation}
|
||||
for a brief overview of
|
||||
the DrRacket IDE.}
|
||||
To draw pictures, we must first load some picture functions, which are
|
||||
part of a library for creating slide presentations. Copy the
|
||||
following into the @defterm{definitions area}, which is the top text
|
||||
area that you see in DrRacket:
|
||||
|
||||
@racketmod[slideshow]
|
||||
|
||||
Then click the @onscreen{Run} button. You'll see the text caret move
|
||||
to the bottom text area, which is the @defterm{interactions area}.
|
||||
|
||||
If you've used DrRacket before, you might need to reset DrRacket to
|
||||
use the language declared in the source via the @menuitem["Language"
|
||||
"Choose Language..."] menu item before clicking @onscreen{Run}.
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Go!}
|
||||
|
||||
When you type an expression after the @onscreen{>} in the interactions
|
||||
window and hit Enter, DrRacket evaluates the expression and prints its
|
||||
result. An expression can be just a value, such as the number
|
||||
@racket[5] or the string @racket["art gallery"]:
|
||||
|
||||
@ss-interaction[5 "art gallery"]
|
||||
|
||||
An expression can also be a function call. To call a function, put
|
||||
an open parenthesis before the function name, then expressions for the
|
||||
function arguments, and then a close parenthesis, like this:
|
||||
|
||||
@ss-interaction[(circle 10)]
|
||||
|
||||
A result from the @racket[circle] function is a picture value, which
|
||||
prints as an expression result in much the same way that numbers or
|
||||
strings print. The argument to @racket[circle] determines the
|
||||
circle's size in pixels. As you might guess, there's a
|
||||
@racket[rectangle] function that takes two arguments instead of one:
|
||||
|
||||
@ss-interaction[(rectangle 10 20)]
|
||||
|
||||
Try giving @racket[circle] the wrong number of arguments, just to see
|
||||
what happens:
|
||||
|
||||
@ss-interaction[(circle 10 20)]
|
||||
|
||||
Note that DrRacket highlights in pink the expression that triggered
|
||||
the error (but pink highlighting is not shown in this documentation).
|
||||
|
||||
In addition to basic picture constructors like @racket[circle] and
|
||||
@racket[rectangle], there's a @racket[hc-append] function that
|
||||
combines pictures. When you start composing function calls in Racket,
|
||||
it looks like this:
|
||||
|
||||
@ss-interaction[(hc-append (circle 10) (rectangle 10 20))]
|
||||
|
||||
The hyphen in the name @racket[hc-append] is just a part of the
|
||||
identifier; it's not @racketidfont{hc} minus
|
||||
@racketidfont{append}. The function name starts with @racket[h]
|
||||
because it combines pictures horizontally, and the next letter is
|
||||
@racket[c] because the pictures are centered vertically.
|
||||
|
||||
If you wonder what other functions exist---perhaps a way to stack
|
||||
pictures vertically and left-aligned?---move the text caret to the
|
||||
name @racket[hc-append] and press the F1 key in DrRacket. A browser
|
||||
window will open, and it will give you a link to the documentation for
|
||||
@racket[hc-append]. Click the link, and you'll see lots of other
|
||||
functions.
|
||||
|
||||
If you're reading this in HTML form, you can also just click on
|
||||
@racket[hc-append] or any other imported identifier that is used in
|
||||
this tutorial.
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Definitions}
|
||||
|
||||
To use a particular circle and rectangle picture many times, it's
|
||||
simpler to give them names. Move back to the definitions area (the top
|
||||
area) and add two definitions, so that the complete content of the
|
||||
definitions area looks like this:
|
||||
|
||||
@ss-racketmod+eval[
|
||||
slideshow
|
||||
(define c (circle 10))
|
||||
(define r (rectangle 10 20))
|
||||
]
|
||||
|
||||
Then click @onscreen{Run} again. Now, you can just type @racket[c] or
|
||||
@racket[r]:
|
||||
|
||||
@ss-interaction[r (hc-append c r) (hc-append 20 c r c)]
|
||||
|
||||
As you can see, the @racket[hc-append] function accepts an optional
|
||||
number argument before the picture arguments, and it accepts any
|
||||
number of picture arguments. When a number is provided, it specifies
|
||||
the amount of space to add between pictures.
|
||||
|
||||
We could have evaluated the @racket[define] forms for @racket[c] and
|
||||
@racket[r] in the interactions area instead of the definitions
|
||||
area. In practice, though, the definitions area is where your program
|
||||
lives---it's the file that you save---while the interaction area is
|
||||
for transient explorations and debugging tasks.
|
||||
|
||||
Let's add a function definition to the program. A function definition
|
||||
uses @racket[define], just like our shape definitions, but with an
|
||||
open parenthesis before the function name, and names for the function
|
||||
arguments before the matching close parenthesis:
|
||||
|
||||
@ss-racketblock+eval[
|
||||
(define (square n)
|
||||
(code:comment @#,t{A semi-colon starts a line comment.})
|
||||
(code:comment @#,t{The expression below is the function body.})
|
||||
(filled-rectangle n n))
|
||||
]
|
||||
|
||||
The syntax of the definition mirrors the syntax of a function
|
||||
call:
|
||||
|
||||
@ss-interaction[(square 10)]
|
||||
|
||||
In the same way that definitions can be evaluated in the interactions
|
||||
area, expressions can be included in the definitions area. When a
|
||||
program is run, expression results from the definition area are shown
|
||||
in the interaction area. From now on, we'll write our example
|
||||
definitions and expressions together, and you can put them in
|
||||
whichever area you prefer. The examples will build on each other,
|
||||
however, so it's best to put at least the definitions in the
|
||||
definition area.
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Local Binding}
|
||||
|
||||
The @racket[define] form can be used in some places to create local
|
||||
bindings. For example, it can be used inside a function body:
|
||||
|
||||
@ss-def+int[
|
||||
(define (four p)
|
||||
(define two-p (hc-append p p))
|
||||
(vc-append two-p two-p))
|
||||
(four (circle 10))
|
||||
]
|
||||
|
||||
More typically, Racketeers use the @racket[let] or @racket[let*] form
|
||||
for local binding. An advantage of @racket[let] is that it can be used
|
||||
in any expression position. Also, it binds many identifiers at once,
|
||||
instead of requiring a separate @racket[define] for each identifier:
|
||||
|
||||
@ss-def+int[
|
||||
(define (checker p1 p2)
|
||||
(let ([p12 (hc-append p1 p2)]
|
||||
[p21 (hc-append p2 p1)])
|
||||
(vc-append p12 p21)))
|
||||
(checker (colorize (square 10) "red")
|
||||
(colorize (square 10) "black"))
|
||||
]
|
||||
|
||||
A @racket[let] form binds many identifiers at the same time, so the
|
||||
bindings cannot refer to each other. The @racket[let*] form, in
|
||||
contrast, allows later bindings to use earlier bindings:
|
||||
|
||||
@ss-def+int[
|
||||
(define (checkerboard p)
|
||||
(let* ([rp (colorize p "red")]
|
||||
[bp (colorize p "black")]
|
||||
[c (checker rp bp)]
|
||||
[c4 (four c)])
|
||||
(four c4)))
|
||||
(checkerboard (square 10))
|
||||
]
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Functions are Values}
|
||||
|
||||
Instead of calling @racket[circle] as a function, try evaluating just
|
||||
@racket[circle] as an expression:
|
||||
|
||||
@ss-interaction[circle]
|
||||
|
||||
That is, the identifier @racket[circle] is bound to a function
|
||||
(a.k.a. ``procedure''), just like @racket[c] is bound to a
|
||||
circle. Unlike a circle picture, there's not a simple way of
|
||||
completely printing the function, so DrRacket just prints
|
||||
@procedure{circle}.
|
||||
|
||||
This example shows that functions are values, just like numbers and
|
||||
pictures (even if they don't print as nicely). Since functions are
|
||||
values, you can define functions that expect other functions as
|
||||
arguments:
|
||||
|
||||
@ss-def+int[
|
||||
(define (series mk)
|
||||
(hc-append 4 (mk 5) (mk 10) (mk 20)))
|
||||
(series circle)
|
||||
(series square)
|
||||
]
|
||||
|
||||
When calling a function that accepts a function argument, the
|
||||
argument function often isn't needed anywhere else. Having to write
|
||||
down the function via @racket[define] would be a hassle, because you
|
||||
have to make up a name and find a place to put the function
|
||||
definition. The alternative is to use @racket[lambda], which creates an
|
||||
anonymous function:
|
||||
|
||||
@ss-interaction[(series (lambda (size) (checkerboard (square size))))]
|
||||
|
||||
The parenthesized names after a @racket[lambda] are the arguments to
|
||||
the function, and the expression after the argument names is the
|
||||
function body. Using the word ``lambda'' instead of ``function'' or
|
||||
``procedure'' is part of Racket's history and culture.
|
||||
|
||||
A @racket[define] form for a function is really a shorthand for a
|
||||
simple @racket[define] using @racket[lambda] as the value. For
|
||||
example, the @racket[series] definition could be written as
|
||||
|
||||
@racketblock[
|
||||
(define series
|
||||
(lambda (mk)
|
||||
(hc-append 4 (mk 5) (mk 10) (mk 20))))
|
||||
]
|
||||
|
||||
Most Racketeers prefer to use the shorthand function form with
|
||||
@racket[define] instead of expanding to @racket[lambda].
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Lexical Scope}
|
||||
|
||||
Racket is a lexically scoped language, which means that whenever an
|
||||
identifier is used as an expression, something in the textual
|
||||
environment of the expression determines the identifier's
|
||||
binding. This rule applies to identifiers in a @racket[lambda] body as
|
||||
well as anywhere else.
|
||||
|
||||
In the following @racket[rgb-series] function, the uses
|
||||
of @racket[mk] in each @racket[lambda] form refer to the argument of
|
||||
@racket[rgb-series], since that's the binding that is textually in
|
||||
scope:
|
||||
|
||||
@ss-def+int[
|
||||
(define (rgb-series mk)
|
||||
(vc-append
|
||||
(series (lambda (sz) (colorize (mk sz) "red")))
|
||||
(series (lambda (sz) (colorize (mk sz) "green")))
|
||||
(series (lambda (sz) (colorize (mk sz) "blue")))))
|
||||
(rgb-series circle)
|
||||
(rgb-series square)
|
||||
]
|
||||
|
||||
Here's another example, where @racket[rgb-maker] takes a function and
|
||||
returns a new one that remembers and uses the original function.
|
||||
|
||||
@ss-def+int[
|
||||
(define (rgb-maker mk)
|
||||
(lambda (sz)
|
||||
(vc-append (colorize (mk sz) "red")
|
||||
(colorize (mk sz) "green")
|
||||
(colorize (mk sz) "blue"))))
|
||||
(series (rgb-maker circle))
|
||||
(series (rgb-maker square))
|
||||
]
|
||||
|
||||
Note how composing functions via @racket[rgb-maker] creates a
|
||||
different alignment of objects within the picture compared to using
|
||||
@racket[rgb-series].
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Lists}
|
||||
|
||||
Racket inherits much of its style from the language Lisp, whose name
|
||||
originally stood for ``LISt Processor,'' and lists remain an important
|
||||
part of Racket.
|
||||
|
||||
The @racket[list] function takes any number of arguments and returns
|
||||
a list containing the given values:
|
||||
|
||||
@ss-interaction[(list "red" "green" "blue")
|
||||
(list (circle 10) (square 10))]
|
||||
|
||||
As you can see, a list prints as a single quote and then pair of parentheses wrapped around
|
||||
the printed form of the list elements. There's room for confusion
|
||||
here, because parentheses are used for both expressions, such as
|
||||
@racket[(circle 10)], and printed results, such as
|
||||
@racketresult['("red" "green" "blue")]. The quote is the key difference,
|
||||
as @seclink[#:doc '(lib "scribblings/guide/guide.scrbl") "quoting-lists"]{discussed
|
||||
elsewhere}. To help emphasize the difference, in the documentation and in DrRacket,
|
||||
result parentheses are printed in blue, unlike expression parentheses.
|
||||
|
||||
If you have a list, then you'll eventually want to do something with
|
||||
each of the elements. The @racket[map] function takes a list and a
|
||||
function to apply to each element of the list; it returns a new list
|
||||
to combine the function's results:
|
||||
|
||||
@ss-def+int[
|
||||
(define (rainbow p)
|
||||
(map (lambda (color)
|
||||
(colorize p color))
|
||||
(list "red" "orange" "yellow" "green" "blue" "purple")))
|
||||
(rainbow (square 5))
|
||||
]
|
||||
|
||||
Another function that works with lists is @racket[apply]. Like
|
||||
@racket[map], it takes a function and a list, but a function given
|
||||
to @racket[apply] should take all of the arguments at once, instead of
|
||||
each one individually. The @racket[apply] function is especially
|
||||
useful with functions that take any number of arguments, such as
|
||||
@racket[vc-append]:
|
||||
|
||||
@ss-interaction[
|
||||
(apply vc-append (rainbow (square 5)))
|
||||
]
|
||||
|
||||
Note that @racket[(vc-append (rainbow (square 5)))] would not work,
|
||||
because @racket[vc-append] does not want a list as an argument; it
|
||||
wants a picture as an argument, and it is willing to accept any number
|
||||
of them. The @racket[apply] function bridges the gap between a
|
||||
function that wants many arguments and a list of those arguments as a
|
||||
single value.
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Modules}
|
||||
|
||||
Since your program in the definitions window starts with
|
||||
|
||||
@racketmod[slideshow]
|
||||
|
||||
all of the code that you put in the definitions window is inside a
|
||||
module. Furthermore, the module initially imports everything from the
|
||||
module designated by @racketmodname[slideshow], which exports
|
||||
picture-making functions as well as more commonly used functions
|
||||
such as @racket[list] and @racket[map].
|
||||
|
||||
To import additional libraries, use the @racket[require] form. For
|
||||
example, the library @racketmodname[pict/flash] provides a
|
||||
@racket[filled-flash] function:
|
||||
|
||||
@ss-def+int[
|
||||
(require pict/flash)
|
||||
(filled-flash 40 30)
|
||||
]
|
||||
|
||||
Modules are named and distributed in various ways:
|
||||
|
||||
@itemize[
|
||||
|
||||
@item{Some modules are packaged in the Racket distribution or
|
||||
otherwise installed into a hierarchy of
|
||||
@defterm{collections}. For example, the module name
|
||||
@racketmodname[pict/flash] means ``the module implemented
|
||||
in the file @filepath{flash.rkt} that is located in the
|
||||
@filepath{pict} collection.'' When a module name includes
|
||||
no slash, then it refers to a @filepath{main.rkt} file.}
|
||||
|
||||
@item{Some modules are distributed through the
|
||||
@link[url:planet]{@PLaneT} server, and they can be
|
||||
downloaded automatically on demand. For example, the first time
|
||||
that you evaluate the following fragment:
|
||||
|
||||
@mr-def+int[
|
||||
(require (planet schematics/random:1:0/random))
|
||||
(random-gaussian)
|
||||
]
|
||||
|
||||
DrRacket automatically downloads version 1.0 of the
|
||||
@filepath{random.plt} library by @filepath{schematics} and then
|
||||
imports the @filepath{random.rkt} module.}
|
||||
|
||||
@item{@margin-note{To save your definitions, use DrRacket's
|
||||
@seclink[#:indirect? #t
|
||||
#:doc '(lib "scribblings/drracket/drracket.scrbl")
|
||||
"menu:file"]{@onscreen{Save Definitions}}
|
||||
menu item.}
|
||||
Some modules live relative to other modules, without
|
||||
necessarily belonging to any particular collection or package.
|
||||
For example, in DrRacket, if you save your definitions so far in a
|
||||
file @filepath{quick.rkt} and add the line
|
||||
|
||||
@racketblock[(provide rainbow square)]
|
||||
|
||||
then you can open a new tab or window in DrRacket, type the new
|
||||
program @filepath{use.rkt} in the same directory as
|
||||
@filepath{quick.rkt}:
|
||||
|
||||
@racketmod[
|
||||
racket
|
||||
(require "quick.rkt")
|
||||
(rainbow (square 5))
|
||||
]
|
||||
|
||||
and when you run @filepath{use.rkt}, a rainbow list of squares
|
||||
is the output. Note that @filepath{use.rkt} is written using
|
||||
the initial import @racketmodname[racket], which does not
|
||||
supply any picture-making functions itself---but does provide
|
||||
@racket[require] and the function-calling syntax.}
|
||||
|
||||
]
|
||||
|
||||
Racketeers typically write new programs and libraries as modules that
|
||||
import each other through relative paths, and that use existing
|
||||
libraries from collections and @racket[planet]. When a program or
|
||||
library developed this way seems useful to others, it can be uploaded
|
||||
as a @PLaneT package or distributed in the more old-fashioned way as
|
||||
an installable collection archive (in either case without modifying
|
||||
the internal relative references among modules).
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Macros}
|
||||
|
||||
Here's another library to try:
|
||||
|
||||
@mr-def+int[
|
||||
(require slideshow/code)
|
||||
(code (circle 10))
|
||||
]
|
||||
|
||||
Instead of a circle, the result is a picture of the code that, if it
|
||||
were used as an expression, would produce a circle. In other words,
|
||||
@racket[code] is not a function, but instead a new syntactic form for
|
||||
creating pictures; the bit between the opening parenthesis with
|
||||
@racket[code] is not an expression, but instead manipulated by the
|
||||
@racket[code] syntactic form.
|
||||
|
||||
This helps explain what we meant in the previous section when we said
|
||||
that @racketmodname[racket] provides @racket[require] and the
|
||||
function-calling syntax. Libraries are not restricted to exporting
|
||||
values, such as functions; they can also define new syntactic
|
||||
forms. In this sense, Racket isn't exactly a language at all; it's
|
||||
more of an idea for how to structure a language so that you can extend
|
||||
it or create entirely new languages.
|
||||
|
||||
One way to introduce a new syntactic form is through
|
||||
@racket[define-syntax] with @racket[syntax-rules]:
|
||||
|
||||
@mr-def+int[
|
||||
(define-syntax pict+code
|
||||
(syntax-rules ()
|
||||
[(pict+code expr)
|
||||
(hc-append 10
|
||||
expr
|
||||
(code expr))]))
|
||||
(pict+code (circle 10))
|
||||
]
|
||||
|
||||
This kind of definition is a macro. The @racket[(pict+code expr)] part
|
||||
is a pattern for uses of the macro; instances of the pattern in a
|
||||
program are replaced by instances of the corresponding template, which
|
||||
is @racket[(hc-append 10 expr (code expr))]. In particular,
|
||||
@racket[(pict+code (circle 10))] matches the pattern with
|
||||
@racket[(circle 10)] as @racket[expr], so it is replaced with
|
||||
@racket[(hc-append 10 (circle 10) (code (circle 10)))].
|
||||
|
||||
Of course, this sort of syntactic extension cuts both ways: inventing
|
||||
a new language can make it easier to say what you want, but harder for
|
||||
others to understand. As it happens, the developers of Racket are
|
||||
constantly giving talks and writing papers that involve Racket code,
|
||||
and it's worthwhile for everyone who works on those products to know
|
||||
about @racket[code].
|
||||
|
||||
In fact, you might want to take a look at the @keep-file["quick.scrbl"]
|
||||
@link["quick.scrbl"]{source of this document}. You'll see that it
|
||||
starts with @racketfont{#lang}, but otherwise doesn't look a lot
|
||||
like Racket; nevertheless, we build this document by running its
|
||||
source as a Racket program. We have to use a lot more than
|
||||
@racket[syntax-rules] to extend Racket's syntax enough for writing
|
||||
documents, but Racket's syntactic extension can take you a long way.
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Objects}
|
||||
|
||||
An object system is another example of a sophisticated language
|
||||
extension that is worth learning and using for Racket users. Objects
|
||||
are sometimes better than functions, even when you have
|
||||
@racket[lambda], and objects work especially well for graphical user
|
||||
interfaces. The API for Racket's GUI and graphics system is expressed
|
||||
in terms of objects and classes.
|
||||
|
||||
The class system itself is implemented by the
|
||||
@racketmodname[racket/class] library, and the
|
||||
@racketmodname[racket/gui/base] library provides the GUI and drawing
|
||||
classes. By convention, the classes are given names that end with
|
||||
@racket[%]:
|
||||
|
||||
@mr-defs+int[
|
||||
[(require racket/class
|
||||
racket/gui/base)
|
||||
(define f (new frame% [label "My Art"]
|
||||
[width 300]
|
||||
[height 300]
|
||||
[alignment '(center center)]))]
|
||||
(send f show #t)
|
||||
]
|
||||
|
||||
@(mr-interaction-eval (send f show #f))
|
||||
|
||||
The @racket[new] form creates an instance of a class, where
|
||||
initialization arguments like @racket[label] and @racket[width] are
|
||||
provided by name. The @racket[send] form calls a method of the object,
|
||||
such as @racket[show], with arguments after the method name; the
|
||||
argument @racket[#t] in this case is the boolean constant ``true.''
|
||||
|
||||
Pictures generated with @racketmodname[slideshow] encapsulate a
|
||||
function that uses the graphics toolbox's drawing commands to render
|
||||
the picture to a drawing context, such as a canvas in a frame. The
|
||||
@racket[make-pict-drawer] function from @racketmodname[slideshow]
|
||||
exposes a picture's drawing function. We can use
|
||||
@racket[make-pict-drawer] in a canvas-painting callback to draw a
|
||||
picture into a canvas:
|
||||
|
||||
@(mr-interaction-eval (require pict/flash))
|
||||
|
||||
@mr-def+int[
|
||||
(define (add-drawing p)
|
||||
(let ([drawer (make-pict-drawer p)])
|
||||
(new canvas% [parent f]
|
||||
[style '(border)]
|
||||
[paint-callback (lambda (self dc)
|
||||
(drawer dc 0 0))])))
|
||||
(add-drawing (pict+code (circle 10)))
|
||||
(add-drawing (colorize (filled-flash 50 30) "yellow"))
|
||||
]
|
||||
|
||||
@centerline{
|
||||
@(mr-interaction-eval-show (scale
|
||||
(bitmap
|
||||
(build-path
|
||||
(collection-path "scribblings/quick")
|
||||
"art.png"))
|
||||
0.5))}
|
||||
|
||||
Each canvas stretches to fill an equal portion of the frame, because
|
||||
that's how a frame manages its children by default.
|
||||
|
||||
@; ----------------------------------------------------------------------
|
||||
@section{Where to Go From Here}
|
||||
|
||||
This introduction to Racket purposely avoids many of the
|
||||
traditional ways of introducing and distinguishing Lisp or Scheme:
|
||||
prefix arithmetic notation, symbols, quoting and quasiquoting lists,
|
||||
@racket[eval], first-class continuations, and the idea that all syntax
|
||||
is really just a @racket[lambda] in disguise. While those are all part
|
||||
of Racket, they are not the main ingredients of day-to-day programming
|
||||
in Racket.
|
||||
|
||||
Instead, Racket programmers typically program with functions,
|
||||
records, objects, exceptions, regular expressions, modules, and
|
||||
threads. That is, instead of a ``minimalist'' language---which is the
|
||||
way that Scheme is often described---Racket offers a rich language
|
||||
with an extensive set of libraries and tools.
|
||||
|
||||
If you are new to programming or if you have the patience to work
|
||||
through a textbook, we recommend reading
|
||||
@italic{@link["http://www.htdp.org/"]{How to Design Programs}}. If you
|
||||
have already read it, or if you want to see where the book will take
|
||||
you, then see @other-manual['(lib
|
||||
"web-server/scribblings/tutorial/continue.scrbl")].
|
||||
|
||||
For experienced programmers, to continue touring Racket from a
|
||||
systems-oriented perspective instead of pictures, your next stop is
|
||||
@other-manual['(lib "scribblings/more/more.scrbl")].
|
||||
|
||||
To instead start learning about the full Racket language and tools
|
||||
in depth, move on to @other-manual['(lib "guide.scrbl"
|
||||
"scribblings/guide")].
|
||||
Loading…
Reference in New Issue