Tag: PLT

The OP asked how to set the background color in Slideshow as it is not obvious.
Matthew replied:

Locally, I’d superimpose a picture onto a color rectangle:

#lang slideshow
 (define (add-bg p color)
   (refocus (cc-superimpose
             (colorize
              (filled-rectangle (pict-width p)
                                (pict-height p))
              color)
             p)
            p))
 (add-bg (bt "Hello") "green")

To globally set the background, I’d use that in an assembler:

#lang slideshow
 (define (add-bg p color)
   (refocus (cc-superimpose
             (colorize
              (filled-rectangle (pict-width p)
                                (pict-height p))
              color)
             p)
            p))
 (current-slide-assembler
  (let ([orig (current-slide-assembler)])
    (lambda (title sep body)
      (ct-superimpose
       (inset (add-bg (inset full-page margin) "green")
              (- margin))
       (orig title sep body)))))
 (slide #:title "Example" (bt "Hello"))

(via plt)

The OP asked:

Is there a way to evaluate something in a given evaluator without having anything displayed in the output?
Ie. I want to feed a couple of basic function definitions into the evaluator instance that I obtain with (make-base-eval).

Matthew shared the solution: interaction-eval.
(via plt)

The scribble/eval library provides utilities for evaluating code at document-build time and incorporating the results in the document, especially to show example uses of defined procedures and syntax.

Here is an example where the OP was:

trying to figure out a way to insert some text in between Scheme definitions: that is, have some definitions (@schemeblock or equivalent), with their explanations (text mode), and then an interaction, like @interaction, except that it should be aware of the preceeding definitions.

Here is the solution:

#lang scribble/manual
@(require scribble/eval)
@(define ex-eval (make-base-eval))
First, we define @scheme[x]:
@interaction[
#:eval ex-eval
(define x 1)
]
Next, we use it:
@interaction[
#:eval ex-eval
x
]
@(close-eval ex-eval)

(via plt)

You can use ‘code:hilite’ to highlight expressions in Scribble generated documentation like this:

@schemeblock[
  (+ 1 (code:hilite +inf.0))
 ]

It doesn’t work for multi-line expressions yet, however.
(via plt)

A frequent question on the PLT Scheme discussion list is how to implement new languages on top of PLT Scheme.
In the next release documentation explaining how to do so is included, and there is a preview here.
(via plt)

Here is it; thanks to Jay.
(via plt)

Here is how to get the current line number programmatically in PLT Scheme (via Jay):

#lang scheme
(define-syntax (current-line-number stx)
  (quasisyntax/loc stx
    '#,(syntax-line stx)))
(printf "~a: ~a~n" (current-line-number) 6)
(printf "~a: ~a~n" (current-line-number) 8)

(via plt)

There is a good list of Scheme related lectures here.

The first release of my OpenCL binding is available.
http://planet.plt-scheme.org/display.ss?owner=jaymccarthy&package=opencl.plt

— Jay
(via PLT)

bzlib/thread provides additional concurrency constructs by building on top of PLT Scheme’s concurrency primitives to help simplify programming in message passing style that Erlang has helped popularized.

(via PLT)