http://blog.gmane.org/gmane.comp.lang.racket.devel hourly 1 1901-01-01T00:00+00:00 http://gmane.org/img/gmane-25t.png http://gmane.org http://comments.gmane.org/gmane.comp.lang.racket.devel/6052 <pre>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 "&lt;field&gt;: &lt;detail&gt;" lines. A multi-line &lt;detail&gt; 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 (raise-type-error 'eat "integer" n) should change to (raise-argument-error 'eat "integer?" n) A new `raise-arguments-error' (plural) function supports simple error messages that have any number of fields, where each field's value is `print'ed into the message: (raise-arguments-error 'eat "fish is smaller than its given meal" "fish size" 12 "given meal size" 13) There's more room for error-formatting support, and I have some ideas --- but also I have plenty still to do for just with the the simple ones. The old error-message functions remain and format messages as before (although, notably, `raise-syntax-error' uses the new conventions). Conversion to the new format mostly requires changing all existing call sites. You may wonder whether exception records should provide field and detail information directly, instead of only encoded in the error-message string. As appealing as that sounds, retrofitting existing code to use a new little DSL for error content looks to me like far too much work. I have some ideas on how to get much of the benefit indirectly, though (so that DrRacket can show images when they appear in an error, for example, instead of printing "#&lt;image&gt;"). For now, if you convert error messages to `raise-argument-error' and `raise-arguments-error', then you're certainly future-proof for that step. Even if you build messages by hand, I expect that format strings will work transparently. More soon... Some examples: ---------------------------------------- +: contract violation expected: number? given: 'a argument position: 2nd other arguments: 1 context: /Users/mflatt/proj/plt/collects/racket/private/misc.rkt:87:7 application: wrong number of arguments procedure: add1 expected number of arguments: 1 given number of arguments: 0 context: /Users/mflatt/proj/plt/collects/racket/private/misc.rkt:87:7 lambda: bad syntax in: (lambda x) source: readline-input::16 context: /Users/mflatt/proj/plt/collects/racket/private/misc.rkt:87:7 read: illegal use of "." source: readline-input::27 context: /Users/mflatt/proj/plt/collects/readline/pread.rkt:230:0: read-cmdline-syntax /Users/mflatt/proj/plt/collects/racket/private/misc.rkt:87:7 collection-path: collection not found collection: "nonesuch" in collection directories: /Users/mflatt/Library/Racket/5.3.0.9/collects /Users/mflatt/proj/plt/collects context: /Users/mflatt/proj/plt/collects/racket/private/pre-base.rkt:111:53: fail /Users/mflatt/proj/plt/collects/racket/private/misc.rkt:87:7 ---------------------------------------- For comparison, here are the same examples with the old message style: ---------------------------------------- +: expects type &lt;number&gt; as 2nd argument, given: 'a; other arguments were: 1 === context === /Applications/Racket v5.2.1/collects/racket/private/misc.rkt:87:7 add1: expects 1 argument, given 0 === context === /Applications/Racket v5.2.1/collects/racket/private/misc.rkt:87:7 readline-input::16: lambda: bad syntax in: (lambda x) === context === /Applications/Racket v5.2.1/collects/racket/private/misc.rkt:87:7 readline-input::27: read: illegal use of "." === context === /Applications/Racket v5.2.1/collects/readline/pread.rkt:230:0: read-cmdline-syntax /Applications/Racket v5.2.1/collects/racket/private/misc.rkt:87:7 collection-path: collection not found: "nonesuch" in any of: (#&lt;path:/Users/mflatt/Library/Racket/5.2.1/collects&gt; #&lt;path:/Applications/Racket v5.2.1/collects&gt;) === context === /Applications/Racket v5.2.1/collects/racket/private/pre-base.rkt:111:53: fail /Applications/Racket v5.2.1/collects/racket/private/misc.rkt:87:7 ---------------------------------------- _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> Matthew Flatt 2012-05-25T21:09:22 http://comments.gmane.org/gmane.comp.lang.racket.devel/6048 <pre>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 </pre> Asumu Takikawa 2012-05-23T21:42:25 http://comments.gmane.org/gmane.comp.lang.racket.devel/6047 <pre>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.) </pre> Eli Barzilay 2012-05-22T17:46:04 http://comments.gmane.org/gmane.comp.lang.racket.devel/6036 <pre>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 </pre> Danny Yoo 2012-05-14T16:04:28 http://comments.gmane.org/gmane.comp.lang.racket.devel/6035 <pre>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 modules `a' and `b' refer to each other in documentation. That is, `a' contains `(require (for-doc (for-label a)))' and `b' contains `(require (for-doc (for-label b)))'. With the old implementation, `for-doc' requires (via `require/doc') were effectively copied to the module that uses `include-extracted'; with the new implementation, `for-doc' requires turn into `require's within a submodule, so that cycle would not be allowed. To get delayed `require's more like the old implementation, use the `generate-delayed-documents' declaration (which is still not implemented with expand', but instead with relatively simple macro juggling). _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> Matthew Flatt 2012-05-12T07:47:11 http://comments.gmane.org/gmane.comp.lang.racket.devel/6027 <pre>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 parser to the new parser With this logic one can have mutually recursively defined syntax classes in different files a boon if I have a say. Also I have this working in a test case (the match parser) So theory looks kind of nice what's the problems! 2. I must say that syntax-parse rocks and I would suggest that we implement the racket matcher completely with syntax parse. To see how it can look like consider looking at the file at, http://gitorious.org/guile-syntax-parse/guile-syntax-parse/blobs/master/compat/racket/match.scm Please look at this tomorrow CET I have a new version ready soon with interesting addons. The benefit: is much more hackable codebase then the current match code-base, it's smaller for one thing. The drawback: one must change syntax-parse to not use match code. I would say that this is not that hugh investment though. And that one introduces buggs. Then a final question: Should we consider implementing syntax-parse with the help of syntax-parse? Have fun! /Stefan _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> stefan.israelsson-VNh8X+XCloDQT0dZR+AlfA< at >public.gmane.org 2012-05-11T13:45:49 http://comments.gmane.org/gmane.comp.lang.racket.devel/6023 <pre>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", *") =&gt; "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 &gt;=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 strings. </pre> Eli Barzilay 2012-05-11T11:53:26 http://comments.gmane.org/gmane.comp.lang.racket.devel/6020 <pre>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&lt; at &gt;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-&gt;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 useful to convert a byte string directly into a cpointer. Like this it could be easily casted into every ctype. The above sample could then be written as: (define bs (with-input-from-file "test.bin" #:mode 'binary (lambda () (port-&gt;bytes)))) (define new-s (ptr-ref (bytes-pointer f-bs) _S)) Would this functionality be a useful addition or is there a better way to achieve the same? Tobias </pre> Tobias Hammer 2012-05-11T08:52:15 http://comments.gmane.org/gmane.comp.lang.racket.devel/6016 <pre>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-&gt;path (regexp-split #rx"/" s))) c)) (define ccs (collection-&gt;ccs elems)) (when (null? ccs) ;; let `collection-path' complain about the name, if that's the problem: (apply collection-path elems) ;; otherwise, it must be an issue with different ways to ;; spell the name (error name-sym (error name-sym "given collection path: \"~a\" is not in canonical form (e.g., wrong case on a case-insensitive filesystem)" (string-join c "/")))) ccs) x-specific-collections))))) … Note that the error message I saw is a fall-through case, when the given names don't appear in the hash table. I'm guessing that "tests" is explicitly excluded from this table some where (though it doesn't seem to be in this file). I see a couple of possible fixes. 1) Add a new table representing collections that aren't normally compiled but can be explicitly chosen, 2) provide a better error message by special-casing it here, 3) go back to automatically compiling "tests" :) John _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> John Clements 2012-05-10T16:59:03 http://comments.gmane.org/gmane.comp.lang.racket.devel/6009 <pre>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 currently have to master. Ideally, we would provide similar interfaces for the other generic APIs in the tree, such as streams and sequences. However, the existing APIs rely on different representations for method tables from the one used by unstable/generics, specifically a vector of methods. This makes backwards compatibility complicated and we're not sure how to proceed. Some specific examples: * `prop:sequence`: Instead of a vector of methods, this struct property takes a procedure which takes a struct instance and produces a sequence (not a vector of methods). * `prop:equal+hash-code` uses a list of methods instead of a vector. * `prop:dict/contract` is given both a method vector and a vector of sub-contracts that are used to assemble the method contracts. The generics library currently uses a single vector. To apply our proposal to these cases, we could change these struct properties to use the generics library's preferred representation. However, this would break backwards compatibility with code that currently uses these struct properties, which makes this a non-starter. Does anyone have any suggestions on how to proceed without breaking backwards compatibility? Streams present a slightly different issue. `prop:stream` already represents its methods with a vector. However, it is used heavily in the implementation of racket/base, so we cannot re-write it to use generics (which depends on racket/base). Assuming we can't restructure racket/private/for to break the circular dependency, another solution would be to allow the generics library to create a generic interface attached to an existing struct property[1], given the struct property accessor. That would require exposing the struct property accessor from the internals of racket/base. Would that be an acceptable solution? [1]: currently, the generics library needs to be the one defining the struct property. Any thoughts or suggestions? Cheers, Asumu &amp; Vincent _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> Asumu Takikawa 2012-05-09T22:13:55 http://comments.gmane.org/gmane.comp.lang.racket.devel/6004 <pre>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 </pre> Danny Yoo 2012-05-09T17:54:36 http://comments.gmane.org/gmane.comp.lang.racket.devel/6001 <pre>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&amp;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 others. * Graphical syntax "When we figure out how to save such files in an editor-compatible way, we may relax this constraint." Maybe the graphical job should be done by DrRacket only, and the file itself should remain textual. For example, special forms can be turned into graphics by DrRacket when reading the file: You write: (image "balloon.jpg") and DrRacket turns this into the image (if the option is turned on somewhere in the preferences). Of course, the s-exp should still be editable, for example with a contextual menu that proposes "Back to s-exp" or "Turn me into graphical form". Or even surround it with a form like (drracket-show-image (image "balloon.jpg") 48 48) for better rendering (that form obviously expands into (image "balloon.jpg") for Racket). Same for code folding, 2 options: - either surround s-exps with a (drracket-fold ....) form to inform DrRacket to fold the s-exp, and Racket to just do what's inside the form, (but that "pollutes" the file for external editors, though an `unfold-file' function should not be too difficult to do) - or do not save folding into the file (loading a file displays it unfolded, then it can be folded as desired). This might be problematic with DrSync though, unless the file is not reverted if it has not changed. But I agree all this would require some work, certainly. Laurent _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> Laurent 2012-05-09T08:18:11 http://comments.gmane.org/gmane.comp.lang.racket.devel/5992 <pre>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&lt; at &gt;&gt; (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=#&lt;set: 1 #&amp;#0#&gt; #0=#&lt;set: 1 #&amp;#0#&gt; #f racket&lt; at &gt;&gt; (let* ((a-box (box #f)) (b-box (box #f)) (a (list 1 a-box)) (b (list 1 b-box))) (set-box! a-box a) (set-box! b-box b) (displayln a) (displayln b) (equal? a b)) #0=(1 #&amp;#0#) #0=(1 #&amp;#0#) #t P.S. For future reference, is this more of users&lt; at &gt; material or dev&lt; at &gt; material? -- Dan King College of Computer and Information Science Northeastern University _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> Daniel King 2012-05-07T22:33:02 http://comments.gmane.org/gmane.comp.lang.racket.devel/5990 <pre>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 &lt; at &gt;input{1}) _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> Jon Rafkind 2012-05-07T17:46:02 http://comments.gmane.org/gmane.comp.lang.racket.devel/5974 <pre>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 </pre> John Clements 2012-05-04T20:21:25 http://comments.gmane.org/gmane.comp.lang.racket.devel/5965 <pre>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-&gt;list . 2124) (syntax-case . 2257) (let-values . 2462) (define/override . 1517) (unsyntax . 2757) (o . 20379) (format . 3377) (define-values . 1553) (define-struct . 1548) (null? . 3961) (cdr . 6557) (quasisyntax . 1752) (string-append . 1456) (raise-type-error . 1176) (begin . 3621) (-&gt; . 8915) (define/private . 1261) (with-syntax . 1603) (parameterize . 1416) (check-equal? . 1408) (identifier? . 1527) (string-constant . 1115) (syntax-e . 2082) (error . 3274) (not . 5409) (parent . 2662) (map . 5280) (vector-ref . 1575) (let* . 3791) (start . 2987) (string? . 2120) (unquote-splicing . 906) (eq? . 4740) (null . 3550) (void . 3513) (apply . 2727) (exact-nonnegative-integer? . 516) (append . 2182) (length . 2104) (test-case . 1401) (define-syntax-rule . 688) (for-each . 1463) (equal? . 1857) (test . 2775) (define-enum . 1003) (make-parameter . 787) (quote-syntax . 918) (in-list . 1562) (with-handlers . 811) (v . 10374) (expr . 2584) (vector . 1707) (pair? . 2024) (label . 1997) (body . 2485) (args . 2481) (id . 4899) (list-ref . 1218) (build-path . 972) (or . 4801) (p . 9589) (string-&gt;symbol . 675) (+ . 9441) (i . 9390) (generate-temporaries . 465) (datum-&gt;syntax . 715) (printf . 1527) (s . 9138) (dc . 4555) (a . 8852) (string-length . 675) (syntax/loc . 873) (symbol-&gt;string . 621) (symbol? . 1228) (expression . 859) (c . 8442) (unsyntax-splicing . 496) (color . 1665) (define-for-syntax . 478) (provide/contract . 499) (listof . 1326) (reverse . 1136) (style . 1571) (new . 2618) (port . 1953) (hash-ref . 974) (module . 1292) (syntax-rules . 644) (number? . 1104) (match . 1543) (real? . 1539) (zero? . 1538) (rest . 1922) (cadr . 1919) (for-syntax . 764) (pos . 2534) (regexp-match . 633) (height . 1255) (snip . 1880) (super-new . 834) (val . 2493) (case-lambda . 679) (result . 1240) (y . 7388) (struct . 1230) (racket/base . 657) (path . 1778) (term . 1776) (current-error-port . 393) (l . 7049) (e . 7021) (n . 6991) (quasisyntax/loc . 464) (solid . 1391) (boolean? . 868) (hash-set! . 768) (pattern . 977) (for/list . 847) (inexact-&gt;exact . 480) (procedure? . 672) (f . 6699) (stretchable-height . 370) (free-identifier=? . 388) (λ . 6592) (b . 6524) (str . 2172) (width . 1293) (line . 1613) (filename . 805) (def/public . 643) (add1 . 1607) (syntax-&gt;datum . 486) (or/c . 1568) (display . 875) (vector-length . 471) (tex-def-prim . 509) (all-from-out . 493) (_ . 5915) (unbox . 1180) (text . 1472) (current-output-port . 307) (number . 968) (test-expression . 387) (vector-set! . 526) (type . 1432) (number-&gt;string . 409) (t . 5713) (value . 1141) (current-continuation-marks . 219) (procedure-arity-includes? . 227) (empty . 1122) (last-position . 427) (racket/class . 462) (- . 5534) (string-&gt;number . 395) (case . 1364) (_pointer . 670) (len . 1782) (path-&gt;string . 442) (syntax-property . 353) (inherit . 753) (eof-object? . 478) (begin-edit-sequence . 274) (class . 1038) (Integer . 737) (prefix . 857) (end . 1703) (stretchable-width . 298) (proc . 1266) (callback . 630) (side-condition . 354) (default-color . 380) (expected . 615) (in-range . 615) (any/c . 980) (match-define . 407) (memq . 1220) (current-directory . 287) (arithmetic-shift . 304) (string=? . 602) (obj . 1603) (rectangle . 533) (end-edit-sequence . 282) (=&gt; . 2393) (out . 1588) (file-exists? . 394) (in-hole . 672) (mzscheme . 587) (this . 1172) (: . 4680) (set-box! . 582) (current-namespace . 272) (base . 1153) (sub1 . 1149) (andmap . 765) (syntax? . 654) (bytes-length . 381) (* . 4561) (test-suite . 454) (key . 1513) (char-&gt;integer . 349) (file . 1122) (preferences:get . 297) (var . 1484) (check . 890) (r . 4447) (horizontal-panel% . 261) (call-with-values . 277) (w . 4406) (make-bindings . 338) (set-brush . 485) (string . 718) (= . 4303) (stepper-syntax-property . 187) (expect . 716) (syntax-parse . 357) (exact-&gt;inexact . 305) (exact-integer? . 304) (dynamic-require . 283) (all-defined-out . 282) (positive? . 470) (list? . 836) (bytes-ref . 463) (count . 833) (for . 1387) (bytes-&gt;string/utf-8 . 217) (board . 823) (substring . 457) (h . 4096) (filter . 682) (rational? . 450) (first . 803) (insert . 669) (is-a? . 802) (define-syntax-class . 211) (frame . 801) (make-test-mtch . 285) (arg . 1329) (struct-out . 395) (default . 564) (d . 3932) (size . 979) (syntax-local-value . 217) (-filter . 553) (path-string? . 322) (mode . 960) (bindings . 479) (rename-out . 382) (raise-mismatch-error . 191) (define-metafunction . 201) (system-type . 346) (_void . 755) (define/augment . 269) (define-syntaxes . 251) (content . 537) (defmagick* . 375) (string-&gt;bytes/utf-8 . 197) (racket/contract . 249) (Number . 622) (datum-&gt;syntax-object . 186) (right . 742) (editor . 617) (_fun . 925) (check-true . 368) (check-expect . 306) (integer? . 458) (super . 731) (exn-message . 332) (define-signature . 228) (with-continuation-mark . 165) (#%plain-app . 328) (define-runtime-path . 189) (event . 712) (table . 710) (current-eventspace . 197) (find-or-create-brush . 176) (close-output-port . 207) (make-element . 292) (vector-&gt;list . 292) (emit . 875) (in . 1744) (who . 1162) (m . 3481) (set-pen . 497) (bitwise-and . 314) (preferences:set-default . 150) (left . 862) (box . 1149) (draw-rectangle . 244) (get-editor . 340) (rename . 565) (racket/match . 282) (exact-positive-integer? . 147) (make-bind . 375) (instantiate . 306) (test-empty . 336) (make-vector . 305) (canvas . 559) (make-hash . 369) (exp . 1099) (string-ref . 329) (viewport . 409) (dynamic-wind . 271) (settings . 406) (next . 812) (init-field . 323) (ormap . 641) (test-equal? . 290) (make-bytes . 319) (open-input-string . 186) (transparent . 287) (msg . 1051) (fprintf . 448) (index . 625) (_double* . 390) (names . 622) (prefix-in . 343) (max . 1029) (regexp-match-positions . 140) (current-input-port . 171) (directory-exists? . 180) (exn:fail? . 340) (item . 764) (_int . 762) (is-a?/c . 435) (get-value . 338) (make-hasheq . 276) (char=? . 506) (hash-table-put! . 202) (regexp-match? . 233) (env . 1001) (find-or-create-pen . 166) (Listof . 496) (check-arg . 330) (any . 986) (drracket:language-configuration:language-settings-language . 51) (vertical-panel% . 196) (scheme/base . 267) (exn . 963) (button% . 412) (clause . 480) (fields . 476) (interactions-text . 167) (racket/runtime-path . 149) (message . 403) (form . 705) (thunk . 564) (letrec . 469) (caddr . 561) (get-width . 310) (false . 558) (color% . 465) (get-text-extent . 185) (offset . 462) (identifier . 277) (list* . 553) (racket/list . 251) (semaphore-post . 197) (newline . 394) (ctc . 918) (k . 2754) (hilite . 458) (pred . 687) (style-delta% . 229) (#%module-begin . 195) (for/fold . 341) (x-min . 541) (current-custodian . 159) (_GtkWidget . 270) (get-height . 270) (show . 674) (blank . 539) (stx-car . 385) (mzlib/class . 245) (get-top-level-window . 134) (src . 891) (lst . 888) (center . 444) (define-gtk . 266) (x-max . 529) (bytes-append . 220) (code . 659) (make-posn . 292) (Univ . 657) (title . 525) (depth . 525) (col . 871) (String . 435) (get-client-size . 174) (only-in . 372) (current-inexact-milliseconds . 93) (tex-def-math-prim . 153) (_MagickWand . 236) (bytes? . 431) (def/override . 215) (vars . 642) (start-pos . 285) (begin0 . 426) (preferences:set . 170) (regexp-replace* . 170) (current-command-line-arguments . 85) (queue-callback . 182) (dir . 845) (red . 844) (field . 506) (lang . 631) (regexp-replace . 180) (bitmap% . 359) (definitions-text . 157) (the-color-database . 139) (recur . 500) (with-output-to-file . 131) (file-position . 191) (clauses . 354) (info . 619) (data . 616) (let*-values . 224) (member . 410) (saved-env . 273) (state . 491) (import . 409) (hash-table-get . 175) (blame . 490) (make-semaphore . 175) (value-of . 305) (quotient . 302) (cases . 477) (syntax-position . 159) (vector? . 340) (tag . 793) (/ . 2369) (get-selection . 182) (input . 473) (change-style . 197) (define-type-alias . 139) (-String . 337) (current-load-relative-directory . 76) (close-input-port . 147) (floor . 470) (before-after . 195) (dy . 1166) (Circle . 388) (num . 774) (contract-projection . 122) (status . 386) (get-start-position . 128) (bitwise-ior . 209) (delta . 459) (negative? . 255) (get-actual-char . 152) (bottom . 379) (method . 377) (split-path . 226) (flush-output . 188) (&lt;= . 1124) (source . 374) (match-lambda . 187) (super-instantiate . 132) (draw-line . 249) (dx . 1113) (expval-extractor-error . 101) (racket/contract/base . 111) (list-&gt;vector . 185) (defproc . 317) (define: . 317) (teach-syntax-error . 123) (collection-path . 147) (head . 551) (orig-stx . 275) (export . 364)) _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> Laurent 2012-05-04T17:07:44 http://comments.gmane.org/gmane.comp.lang.racket.devel/5950 <pre>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 go beyond "use M-/ in emacs", which is still very inconvenient.] </pre> Eli Barzilay 2012-05-03T19:48:17 http://comments.gmane.org/gmane.comp.lang.racket.devel/5948 <pre>-----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 </pre> Marijn 2012-05-03T09:39:10 http://comments.gmane.org/gmane.comp.lang.racket.devel/5945 <pre>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-&gt;total_memory_requested; } else { retval = thread-&gt;total_memory_allocated; } return scheme_make_integer_value(retval); } In src/schinc.h =========== #define EXPECTED_PRIM_COUNT 1043 When I build I get: ... &lt;snip&gt; ... cd gc2; make all mkdir xsrc make xsrc/precomp.h env XFORM_PRECOMP=yes ../racketcgc -cqu ../../../racket/gc2/xform.rkt --setup . --cpp "gcc -E -I./.. -I../../../racket/gc2/../include -I/usr/local/lib/libffi-3.0.9/include -pthread -DMZ_NO_ICONV" --keep-lines -o xsrc/precomp.h ../../../racket/gc2/precomp.c current-load-extension: expects argument of type &lt;procedure (arity 2)&gt;; given #"([^:]*):(.*)" *** Signal 11 I've scanned through xform.rkt but I'm not able to track down the origin of that error. Any ideas? Thanks, Nick A full patch (based on tag v5.2.1) is attached if that helps. diff --git a/src/racket/gc2/newgc.c b/src/racket/gc2/newgc.c index 7370cde..816cf16 100644 --- a/src/racket/gc2/newgc.c +++ b/src/racket/gc2/newgc.c &lt; at &gt;&lt; at &gt; -968,6 +975,14 &lt; at &gt;&lt; at &gt; static void *allocate_big(const size_t request_size_bytes, int type) else addr = malloc_pages(gc, realpagesize, APAGE_SIZE, MMU_ZEROED, MMU_BIG_MED, MMU_PROTECTABLE, &amp;bpage-&gt;mmu_src_block); + { + Scheme_Thread *thread = scheme_get_current_thread(); + if(thread) { + thread-&gt;total_memory_requested += request_size_bytes; + thread-&gt;total_memory_allocated += realpagesize; + } + } + bpage-&gt;addr = addr; bpage-&gt;size = allocate_size; bpage-&gt;size_class = 2; &lt; at &gt;&lt; at &gt; -1100,15 +1115,24 &lt; at &gt;&lt; at &gt; static void *allocate_medium(const size_t request_size_bytes, const int type) { NewGC *gc = GC_get_GC(); + Scheme_Thread *thread = scheme_get_current_thread(); void *objptr; gc_if_needed_account_alloc_size(gc, sz); + if(thread) { + thread-&gt;total_memory_requested += request_size_bytes; + } + objptr = medium_page_realloc_dead_slot(gc, sz, pos, type); if (!objptr) { mpage *page; objhead *info; + if(thread) { + thread-&gt;total_memory_allocated += sz; + } + page = create_new_medium_page(gc, sz, pos); info = (objhead *)PTR(NUM(page-&gt;addr) + MED_NEXT_SEARCH_SLOT(page)); &lt; at &gt;&lt; at &gt; -1303,6 +1327,14 &lt; at &gt;&lt; at &gt; inline static void *allocate(const size_t request_size, const int type) newptr = allocate_slowpath(gc, allocate_size, newptr); } + { + Scheme_Thread *thread = scheme_get_current_thread(); + if(thread) { + thread-&gt;total_memory_requested += request_size; + thread-&gt;total_memory_allocated += allocate_size; + } + } + /* actual Allocation */ { objhead *info = (objhead *)PTR(GC_gen0_alloc_page_ptr); &lt; at &gt;&lt; at &gt; -1350,6 +1382,14 &lt; at &gt;&lt; at &gt; inline static void *fast_malloc_one_small_tagged(size_t request_size, int dirty) info-&gt;size = BYTES_MULTIPLE_OF_WORD_TO_WORDS(allocate_size); /* ALIGN_BYTES_SIZE bumbed us up to the next word boundary */ { + Scheme_Thread *thread = scheme_get_current_thread(); + if(thread) { + thread-&gt;total_memory_requested += request_size; + thread-&gt;total_memory_allocated += allocate_size; + } + } + + { void * objptr = OBJHEAD_TO_OBJPTR(info); ASSERT_VALID_OBJPTR(objptr); return objptr; diff --git a/src/racket/include/scheme.h b/src/racket/include/scheme.h index e90062c..c57bccc 100644 --- a/src/racket/include/scheme.h +++ b/src/racket/include/scheme.h &lt; at &gt;&lt; at &gt; -1130,6 +1130,8 &lt; at &gt;&lt; at &gt; typedef struct Scheme_Thread { intptr_t accum_process_msec; intptr_t current_start_process_msec; + intptr_t total_memory_allocated; + intptr_t total_memory_requested; struct Scheme_Thread_Custodian_Hop *mr_hop; Scheme_Custodian_Reference *mref; diff --git a/src/racket/src/schminc.h b/src/racket/src/schminc.h index 4d377b1..1ed428b 100644 --- a/src/racket/src/schminc.h +++ b/src/racket/src/schminc.h &lt; at &gt;&lt; at &gt; -13,7 +13,7 &lt; at &gt;&lt; at &gt; #define USE_COMPILED_STARTUP 1 -#define EXPECTED_PRIM_COUNT 1042 +#define EXPECTED_PRIM_COUNT 1043 #define EXPECTED_UNSAFE_COUNT 78 #define EXPECTED_FLFXNUM_COUNT 68 #define EXPECTED_FUTURES_COUNT 11 diff --git a/src/racket/src/thread.c b/src/racket/src/thread.c index 78a919c..ca74dab 100644 --- a/src/racket/src/thread.c +++ b/src/racket/src/thread.c &lt; at &gt;&lt; at &gt; -321,6 +321,7 &lt; at &gt;&lt; at &gt; static Scheme_Object *union_tracking_val(int argc, Scheme_Object *args[]); static Scheme_Object *collect_garbage(int argc, Scheme_Object *args[]); static Scheme_Object *current_memory_use(int argc, Scheme_Object *args[]); +static Scheme_Object *thread_memory_allocations(int argc, Scheme_Object *args[]); static Scheme_Object *sch_thread(int argc, Scheme_Object *args[]); static Scheme_Object *sch_thread_nokill(int argc, Scheme_Object *args[]); &lt; at &gt;&lt; at &gt; -558,8 +559,9 &lt; at &gt;&lt; at &gt; void scheme_init_thread(Scheme_Env *env) scheme_add_evt_through_sema(scheme_will_executor_type, will_executor_sema, NULL); - GLOBAL_PRIM_W_ARITY("collect-garbage" , collect_garbage , 0, 0, env); - GLOBAL_PRIM_W_ARITY("current-memory-use" , current_memory_use , 0, 1, env); + GLOBAL_PRIM_W_ARITY("collect-garbage" , collect_garbage , 0, 0, env); + GLOBAL_PRIM_W_ARITY("current-memory-use" , current_memory_use , 0, 1, env); + GLOBAL_PRIM_W_ARITY("thread-memory-allocations" , thread_memory_allocations , 1, 2, env); GLOBAL_PRIM_W_ARITY("custodian-require-memory" , custodian_require_mem, 3, 3, env); GLOBAL_PRIM_W_ARITY("custodian-limit-memory" , custodian_limit_mem , 2, 3, env); &lt; at &gt;&lt; at &gt; -698,6 +700,24 &lt; at &gt;&lt; at &gt; static Scheme_Object *current_memory_use(int argc, Scheme_Object *args[]) return scheme_make_integer_value(retval); } +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-&gt;total_memory_requested; + } else { + retval = thread-&gt;total_memory_allocated; + } + + return scheme_make_integer_value(retval); +} + /*========================================================================*/ /* custodians */ &lt; at &gt;&lt; at &gt; -2219,7 +2239,8 &lt; at &gt;&lt; at &gt; static Scheme_Thread *make_thread(Scheme_Config *config, process-&gt;mref = NULL; process-&gt;extra_mrefs = NULL; - + process-&gt;total_memory_allocated = 0; + process-&gt;total_memory_requested = 0; /* A thread points to a lot of stuff, so it's bad to put a finalization on it, which is what registering with a custodian does. Instead, we _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> Nick Sivo 2012-05-01T23:15:22 http://comments.gmane.org/gmane.comp.lang.racket.devel/5941 <pre>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 </pre> Asumu Takikawa 2012-05-01T19:01:32 http://comments.gmane.org/gmane.comp.lang.racket.devel/5939 <pre>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 &lt; at &gt;&lt; at &gt; -27,8 +27,8 &lt; at &gt;&lt; at &gt; unpredictable when keys are mutated. &lt; at &gt;defproc[(seteq [v any/c] ...) set?] )]{ -Creates a set that uses &lt; at &gt;racket[equal?], &lt; at &gt;racket[eq?], or -&lt; at &gt;racket[eqv?], respectively, to compare elements. The given +Creates a set that uses &lt; at &gt;racket[equal?], &lt; at &gt;racket[eqv?], or +&lt; at &gt;racket[eq?], respectively, to compare elements. The given &lt; at &gt;racket[v]s are added to the set. The elements are added in the order that they appear as &lt; at &gt;racket[v]s, so in the first two cases, an earlier element that is &lt; at &gt;racket[equal?] or &lt; at &gt;racket[eqv?] but not &lt; at &gt;racket[eq?] _________________________ Racket Developers list: http://lists.racket-lang.org/dev </pre> Eric Hanchrow 2012-04-30T16:16:37 Search the mailing list at Gmane query http://search.gmane.org/?group=$group=gmane.comp.lang.racket.devel