gmane.comp.lang.racket.devel

error-message overhaul

Matthew Flatt — 2012-05-25T21:09:22

I've pushed a first cut at overhauling error messages from `racket/base'.

The old error message convention tried to keep everything on one line,
but that sometimes got long and contorted. The old format didn't work
at all for contract errors, for example, and so I've more or less
adopted the contract-error style everywhere.

The new error message convention encourages a short message on the
first line, and then more information in separate "<field>: <detail>"
lines. A multi-line <detail> starts out on its old line and is indented
by an extra space. Where the old format would inline a value or name in
the message, the new format puts the value or name in its own field or
line. A source locations is similarly moved to a field, instead of
prefixing the error message. Finally, instead of a separate " ===
context ===" section for a backtrace, it's added by the default
exception printer as a "context" field.

There's a new `raise-argument-error' function to replace existing uses
of `raise-type-error'. For example

Abort behavior different in DrRacket & Racket

Asumu Takikawa — 2012-05-23T21:42:25

Hi all,

In the Guide entry on control[1], there's a section detailing prompts
and abort. Here's an example from that section:

    (abort-current-continuation
     (default-continuation-prompt-tag)
     (lambda () v)))

If you run this in the command-line REPL, it'll produce 0 as the Guide
claims.  However, if you run it in DrRacket, it will not return.

It turns out that the abort handler for DrRacket is just:
  (lambda args (void))

while the abort handler for Racket is this:
  (lambda results (for-each (current-print) results))

Was this intentional or should both REPLs behave the same way for
aborts?

[1]: http://pre.racket-lang.org/docs/html/guide/prompt.html

Cheers,
Asumu
_________________________
  Racket Developers list:
  http://lists.racket-lang.org/dev

New https certificate

Eli Barzilay — 2012-05-22T17:46:04

Note that I installed a new certificate for the https domains.

(I've tried two new things now: it should be valid for two years, and
it should work for all *.racket-lang.org domains.)

did something happen to the git web server?

Danny Yoo — 2012-05-14T16:04:28

I could have sworn that:

    https://git.racket-lang.org/

took me to a nice HTML view of the git repository, but at the moment,
I see an empty page.
_________________________
  Racket Developers list:
  http://lists.racket-lang.org/dev

scribble/srcdoc

Matthew Flatt — 2012-05-12T07:47:11

If you use `scribble/srcdoc', please check that the latest version
still works on your code.

I've changed the implementation to use submodules. In the old
implementation, `require/doc' and `provide/doc' expanded to
syntax-quoted constants that the compiler would drop when creating
bytecode (so that there would be no documentation overhead for a
module), and so `include-extracted' would use `expand' on the module
source to find the information. Submodules solve the problem of having
extra information in a module that is not loaded with the module's
code, so the `expand' approach is not longer necessary.

Instead of `require/doc', you can use the new `for-doc' sub-form within
`require'. Instead of `provide/doc', just use `provide'; `proc-doc',
etc., are all `provide' sub-forms.

The new forms are different in many subtle ways. Mostly, the new
implementation should work in corners where the old implementation
wouldn't.

There is at least one pattern, however, that no longer works by
default. Suppose that modul

match syntax-parse

2012-05-11T13:45:49

Hi,

I have done two interseting things.

1. Ported syntax-parse over to guile.
2. Implemented racket's match completely with the help of syntax parse.

Comments about 1.

I found that the lack of possibility to define two syntax classes that 
referese to each other inferior to what 
can be done although I understand the choice of to do this and if you 
define one hugh syntax class and use
syntax class parameters you will be able to implement any feature still 
but at the drawback that one need
to define one hugh syntax class.

i propose instead to add syntax-class-set! and syntax-splicing-class-set! 
that has the following logic:
1. Compile all the meta data for the class as before
2. there has to be an already defined syntax class, the declaration, which 
has a logically identical set of meta data except for 
    the parser function
3. If there is no syntax class defined, error about it
4. If there the interfaces miss-matches print out what is different.
5. if everything is ok then set! the old named parse

Very quick poll re `string-trim'

Eli Barzilay — 2012-05-11T11:53:26

Should (string-trim str sep) remove any number of `sep' matches or
just one?  (This makes no difference for the default `sep' since it's
#px"\\s+".)  Possible options below, feel free to mail me off-list to
reduce noise.

1. Yes.
   * Advantage: makes life with string separator a bit easier.  For
     example, remove only newlines with (string-trim str "\n")
   * Disadvantage: can be confusing with strings or regexps like "xy".
     For example:
       (string-trim ", , foo, bar, " #rx", *") => "foo, bar"

2. No.  Flipped dis/advantages.

3. Yes for string separators, no for (p)regexp separators.  Tries to
   get both advantages, but at the cost of non-uniform behavior.

I'm leaning towards #2 since (a) it's less surprising in the regexp
and >=2 string cases, and (b) it'll make similar to other functions
like `string-split' where an implicit repetition is a bad idea (eg,
when you split with "," you'd usually want that to mean #rx"," not
#rx",+").  OTOH, I hate to loose the possibly useful case of
1-character

Reading and writing binary data

Tobias Hammer — 2012-05-11T08:52:15

Hi,

after reading this thread on make-sized-byte-string to convert an arbitrary
cpointer very efficiently into a byte string
(http://www.mail-archive.com/users-GvBox1K3Ixw1Q5oZIJT9Xw< at >public.gmane.org/msg11958.html)
i came up with the idea to use it for writing structured binary data to a
file:

(define-cstruct _S ([a _int]))
(define s (make-S 3210))

(with-output-to-file "test.bin" #:mode 'binary #:exists 'replace
   (lambda ()
     (display (make-sized-byte-string s (ctype-sizeof _S)))))

Like this you can write large chunks of binary data very fast.
Where i am struggling is how to read it in again. My current approach
reads it in as a byte string and copies every byte into the c-struct.
Not very efficient and not very elegant:

(define bs (with-input-from-file "test.bin" #:mode 'binary
              (lambda () (port->bytes))))
(define ptr (malloc _S))
(for ([i (bytes-length bs)])
   (ptr-set! ptr _byte i (bytes-ref bs i)))
(define new-s (ptr-ref ptr _S))

(printf "~a\n" (S-a new-s))

It would be really us

race setup tests gives wrong error message,best way to fix?

John Clements — 2012-05-10T16:59:03

Apologies in advance if this is a known or fixed issue. 

Running 

raco setup tests

gives the following error message:

raco setup: given collection path: "tests" is not in canonical form (e.g., wrong case on a case-insensitive filesystem)

 === context ===
/Users/clements/plt/collects/setup/setup-unit.rkt:493:9
/Users/clements/plt/collects/setup/setup-go.rkt: [running body]
/Users/clements/plt/collects/setup/main.rkt: [running body]
/Users/clements/plt/collects/raco/main.rkt: [running body]

This seemed crazy, so I grepped for the error message, and sure enough, I got this :

 (define top-level-plt-collects
    (if no-specific-collections?
      all-collections
      (check-against-all
       (apply
        append
        (map
         (lambda (c)
           (define elems (append-map (lambda (s) 
                                       (map string->path
                                            (regexp-split #rx"/" s)))
                                     c))
           (define ccs
             (collect

Generics and data structures

Asumu Takikawa — 2012-05-09T22:13:55

Hi all,

Racket currently provides several generic extensible data structure APIs
such as dictionaries, sequences, streams, and so on. Unfortunately, each
data structure currently has its own extension API, but no consistent
convention exists: some APIs use lists of methods, some use vectors,
etc.  Furthermore, these APIs are usually rather low-level (e.g.,
dependent on ordering in the method table).

Vincent and I have been working on a unified user-friendly extension
interface based on unstable/generics by Eli and Jay (which we have moved
to collects/generics). We have a prototype that implements our proposed
interface for prop:dict and prop:ordered-dict with complete backwards
compatibility with their respective extension APIs. That is, we have
modified racket/dict and data/ordered-dict to use generics.

The code is on github here:
  https://github.com/takikawa/racket/tree/generics

We would like to get feedback on what we have so far and if nobody has
any objections, we would like to push what we current

Submodules and internal #langs

Danny Yoo — 2012-05-09T17:54:36

With the submodule support, the following is a legal program:

   #lang racket
   #lang racket

Is this intentional?
_________________________
  Racket Developers list:
  http://lists.racket-lang.org/dev

A few suggestions on indentation and DrRacketgraphical syntax

Laurent — 2012-05-09T08:18:11

Hi,

Reading the style guide for Racket, I came up with a few debatable
suggestions.
( http://www.ccs.neu.edu/home/matthias/Style/style/Textual_Matters.html )

Apologies if this has already been longly debated.

* Indentation: adding new indentations constructs to DrRacket

From the guide: "Caveat 1: Until language specifications come with fixed
indentation rules, we need to use the default settings of DrRacket’s
indentation for this rule to make sense."

Maybe a special submodule like drracket-indentation with declarations like:
(module+ drracket-indentation
  (like-lambda my-lambda my-function ....)
  (like-begin my-begin ....)
  )
could be useful for user-specific indentation.

As a submodule, Racket can read&load it only at appropriate moments.
When indenting the file, DrRacket could first load the drracket-indentation
module of the file to know how to indent it.

One could then create a whole language with its own indentation rules.
It would also be easier to add good indentations for for/fold and oth

Set Equality with Cyclic Structure is not as Expected

Daniel King — 2012-05-07T22:33:02

Hi,

The following code snippet is a bit confusing to me. Sets with cyclic structure
are not equal? even though they meet my intuitive definition of equal. I'm
curious exactly where my intuition goes wrong.

I imagine the reason why Racket can conclude that the lists are equal is because
the ordering of the list provides a necessary level of disambiguation. With a
set, Racket cannot be certain which element should match between the two
data, and this means potentially following cycles forever? I'm not entirely
clear on my reasoning, but I think this must be related to the root cause.

Note in the following snippet the let* forms differ only in the data constructor
used: `set' in the first form and `list' in the second form.

racket< at >> (let* ((a-box (box #f))
                (b-box (box #f))
                (a (set 1 a-box))
                (b (set 1 b-box)))
           (set-box! a-box a)
           (set-box! b-box b)
           (displayln a)
           (displayln b)
           (equal? a b))
#0=#<set: 1 #&#0#>

make-evaluator fails for honu

Jon Rafkind — 2012-05-07T17:46:02

I'm trying to evaluate honu programs inside a sandbox but I get an error from `make-evaluator'. Other languages work (racket/base, typed/racket), its only 'honu that fails so I must have set up something incorrectly. Any idea what it could be?

current-directory: `exists' access denied for /home/jon/tmp/

 === context ===
/home/jon/bin/plt/collects/setup/private/main-collects.rkt:19:4: find-main-collects
/home/jon/bin/plt/collects/racket/private/promise.rkt:103:10
/home/jon/bin/plt/collects/racket/private/more-scheme.rkt:268:2: call-with-exception-handler
...


#lang at-exp racket/base

(require racket/sandbox)

(define (test input)
  (define honu-eval (make-evaluator 'honu))
  (honu-eval input))

(define input string-append)

(test < at >input{1})

_________________________
  Racket Developers list:
  http://lists.racket-lang.org/dev

Doc fix for make-argb?

John Clements — 2012-05-04T20:21:25

The docs for make-argb read:

Constructs a new argb value. The vector has four entries for each pixel, an alpha, red, green, and blue value. The int specifies the width of the image; the height is the size of the vector, divided by 4, divided by the width.

This documentation doesn't specify whether the mapping from vector to coordinate is in row-major or column-major order. t propose adding a sentence to clarify:

Constructs a new argb value. The vector has four entries for each pixel, an alpha, red, green, and blue value. The int specifies the width of the image; the height is the size of the vector, divided by 4, divided by the width. The values for pixel (x,y) are taken starting at position (y*width+x)*4 in the vector.

Maybe you can do better?

John

_________________________
  Racket Developers list:
  http://lists.racket-lang.org/dev

Most used identifiers and their length

Laurent — 2012-05-04T17:07:44

Here is a quick test on the collects dir (program attached if you want to
improve it).
A number of files are not parsed because of various glitches (#reader lines
in particular).

Below is the dict of the first 500 identifiers with the number of
occurrences, sorted by this number times the string-length of the
identifier.

Actually, it doesn't look that bad IMO.

Laurent, who should have worked instead...

'((define . 47453)
  (quote . 48703)
  (lambda . 22377)
  (send . 21027)
  (syntax . 13956)
  (let . 21909)
  (... . 18877)
  (list . 13315)
  (unquote . 6398)
  (x . 43546)
  (define/public . 3189)
  (quasiquote . 3689)
  (loop . 8958)
  (if . 17508)
  (set! . 8569)
  (make-object . 3104)
  (unless . 5432)
  (require . 4582)
  (stx . 10494)
  (else . 7808)
  (name . 7663)
  (and . 10187)
  (cons . 7529)
  (raise-syntax-error . 1631)
  (values . 4865)
  (cond . 7077)
  (define-syntax . 2149)
  (when . 6942)
  (car . 8956)
  (provide . 3745)
  (syntax->list . 2124)
  (syntax-case . 2257)
  (let-values . 246

current-*-port

Eli Barzilay — 2012-05-03T19:48:17

With the trend of having shorter names, I'll try suggesting it again.
Looking at some random slides (the ones from Matthew's talk), one
thing that is -- still -- very strikingly inconvenient is code like

  (parameterize ([current-error-port (current-output-port)])
    ...)

IMO, anyone who is not coming from some kind of Scheme background
would view this as ridiculously long.  If they're renamed to the usual
names, things look much better:

  (parameterize ([stderr (stdout)])
    ...)

Another point in favor: looking through my mailbox, it was very clear
that when people are talking about `current-error-port' etc, they
already use `stderr' etc in emails.  Another point for doing that in
this case but not in others: it is particularly bad in that it's three
words, and it's something that is much more common to deal with.

They could be provided as the old names too, for compatibility.


[Disclosure: I remembered suggesting it once, and finally found it --
I did this about 4 years ago.  The discussion didn't

implicit begin for define-syntax-rule

Marijn — 2012-05-03T09:39:10

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

Hi,

would it make sense for define-syntax-rule to have an implicit begin
such that it could accept multiple forms for the template?

Marijn
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2.0.19 (GNU/Linux)
Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org/

iEYEARECAAYFAk+iUj4ACgkQp/VmCx0OL2zrmACfQ18nV7BoxV2wm4SrPyCSD0rY
z54An3Kd24mFWFVuCxQ95J1Z6I5EuEJy
=fmgP
-----END PGP SIGNATURE-----
_________________________
  Racket Developers list:
  http://lists.racket-lang.org/dev

current-load-extension: expects argument of type ; given #"([^:]):(.)"

Nick Sivo — 2012-05-01T23:15:22

Hi Everyone,

I'm trying to add support for per-thread allocation accounting to aid
in some performance debugging.  I've already instrumented the GC and
can retrieve the statistics via hacks I added to current-memory-use.

I'm running into trouble reverting current-memory-use and instead
adding a primitive: (thread-memory-allocations thread [allocated #f])

In src/thread.c
===========
static Scheme_Object *thread_memory_allocations(int argc,
Scheme_Object *args[]);
GLOBAL_PRIM_W_ARITY("thread-memory-allocations" ,
thread_memory_allocations   , 1, 2, env);
static Scheme_Object *thread_memory_allocations(int argc, Scheme_Object *args[])
{
  Scheme_Thread *thread = NULL;
  intptr_t retval = 0;

  if (!SCHEME_THREADP(args[0]))
    scheme_wrong_type("thread-memory-allocations", "thread", 0, argc, args);

  thread = (Scheme_Thread*) args[0];
  if(argc == 1 || SCHEME_FALSEP(args[1])) {
    retval = thread->total_memory_requested;
  } else {
    retval = thread->total_memory_allocated;
  }

  return scheme_make_inte

Getting Started & install instructions

Asumu Takikawa — 2012-05-01T19:01:32

Hi all,

I've long thought that the Getting Started page in the documentation is
too sparse, so I discussed with Ryan and added some more content to it.
The intent is to try to answer some frequent questions that beginners
ask (e.g., "do I want the `racket` or the `drracket` executable?").

Ideally, I'd like to link to platform-specific installation instructions
for Racket, but I couldn't find any on the Racket home page. Do we have
a page that we can link to for this purpose?

Cheers,
Asumu
_________________________
  Racket Developers list:
  http://lists.racket-lang.org/dev

Tiny tweak to docs

Eric Hanchrow — 2012-04-30T16:16:37

diff --git a/collects/scribblings/reference/sets.scrbl
b/collects/scribblings/reference/sets.scrbl
index d9ea0c6..44cc41d 100644
--- a/collects/scribblings/reference/sets.scrbl
+++ b/collects/scribblings/reference/sets.scrbl
< at >< at > -27,8 +27,8 < at >< at > unpredictable when keys are mutated.
 < at >defproc[(seteq [v any/c] ...) set?]
 )]{

-Creates a set that uses < at >racket[equal?], < at >racket[eq?], or
-< at >racket[eqv?], respectively, to compare elements.  The given
+Creates a set that uses < at >racket[equal?], < at >racket[eqv?], or
+< at >racket[eq?], respectively, to compare elements.  The given
 < at >racket[v]s are added to the set. The elements are added in the order
 that they appear as < at >racket[v]s, so in the first two cases, an earlier
 element that is < at >racket[equal?] or < at >racket[eqv?] but not < at >racket[eq?]
_________________________
  Racket Developers list:
  http://lists.racket-lang.org/dev