Would it be possible to combine the structure constructor name with a means of providing default structure values on a per slot basis? I had always thought it would be nice if the auto-v argument to make-struct-type took an old-style lambda list (i.e., an improper list or, in the degenerate case, an atom) to allow specification of slot-specific automatic (default) values - with the cdr of an improper list (or the atom in the degenerate case) being used for the remaining elements. Then, define-struct could support a #:default field option for each slot. Just a thought. <div class="gmail_quote">On Fri, Apr 2, 2010 at 3:30 PM, Matthew Flatt <<a href="mailto:mflatt@cs.utah.edu">mflatt@cs.utah.edu</a>> wrote: <blockquote class="gmail_quote" style="border-left: 1px solid rgb(204, 204, 204); margin: 0pt 0pt 0pt 0.8ex; padding-left: 1ex;"> Version 4.2.5.5 in the SVN trunk includes experimental features to support the following proposed Racket features. You can try the proposals with `#lang racket' in MzScheme. Structure Constructor Names --------------------------- Proposal: The default constructor name bound by `define-struct' in Racket should be the same as the type name, instead of having a `make-' prefix. Example: > (define-struct a (x y)) > a #<procedure:a> > (a 1 2) #<a> To help support this potential feature, the `define-struct' form of `scheme/base' now accepts a `#:constructor-name' argument to give the constructor a name other than the one prefixed with `make-'. In particular, the constructor name can be the same as the type name: > (define-struct a (x y)) > make-a #<procedure:make-a> > (define-struct a (x y) #:constructor-name a) > a #<procedure:a> > (a 1 2) #<a> A natural (and generally backward-compatible) to change to `match' would be to treat structure-type names as pattern constructors, so that (match (a 1 2) [(a x y) x]) would produce 1. Semi-quasiquote Printing ------------------------ Proposal: Use quasiquote printing as Racket's default printing mode, but only for transparent values. Functional programmers long ago figured out that it's better to print a value in the same way as an expression that produces the value. Printing with `quasiquote', meanwhile, mostly preserves the Lisp tradition of printing values that represent expressions as the expressions that they represent. Some values, however, cannot be printed easily as expressions that produce the same value. For example, In DrScheme with quasiquote printing, (list 1 (let ([f (lambda (x) x)]) f)) prints as `(1 ,(lambda (a1) ...)) The printer cannot actually print a function, so it has to invent a `lambda' expression that approximates the value. The problem is worse with objects, classes, and other opaque types. Expressions with graphs print as a `shared' expression. Other implementations of functional languages punt on opaque values. Here's an example in OCaml, which prints functions as just `<fun>': # Some 10;; - : int option = Some 10 # sqrt;; - : float -> float = <fun> # [sqrt;sqrt];; - : (float -> float) list = [<fun>; <fun>] This seems like the right compromise for Racket. For example, (list 1 (let ([f (lambda (x) x)]) f)) could print as `(1 #<procedure:f>) (Note that there's no need for an unquote when printing a value as a non-expression. Non-S-expression forms are "self-unquoting".) Transparent (or prtially transparent) structures can print with constructors, while opaque structures can print as non-S-expressions: > (define-struct a (x y)) > (list 1 (a 2 3)) `(1 #<a>) > (define-struct a (x y) #:transparent) > (list 1 (a 2 3)) `(1 ,(a 2 3)) Instances of prefab structure types, meanwhile, should stick to quasiquoting: > (define-struct b (x y) #:prefab) > (list 1 (b (a 2 3) 'x)) `(1 #s(b ,(a 2 3) x)) Graphs can still use the compact #n= notation: > (read (open-input-string "#0=(1 . #0#)")) `#0=(1 . #0#) Unlike DrScheme's quasiquote printing, semi-quasiquote printing is easily implemented by parameterizing our existing printer(s). A new `print-as-quasiquote' parameter directs `print' and `pretty-print' to use semi-quasiquote style. (The parameter does not affect `write'.) Welcome to MzScheme v4.2.5.5 [3m], Copyright (c) 2004-2010 PLT Scheme Inc. > 'x x > (print-as-quasiquote #t) > 'x 'x > (list 1 2 3) `(1 2 3) > sqrt #<procedure:sqrt> > (list 1 sqrt) `(1 #<procedure:sqrt>) The `port-print-handler' and `prop:write' protocols have been changed (in a mostly backward-compatible way) to make semi-quasiquote printing extensible. Language-Specific Run-Time Configuration ---------------------------------------- Proposal: The main language of a program should determine a run-time configuration, including the style for printing values. Assuming the changes above, we'd want #lang scheme (define-struct a (x y) #:transparent) (list (make-a 1 2)) to produce (#(struct:a 1 2)) while #lang racket (define-struct a (x y) #:transparent) (list (a 1 2)) should produce `(,(a 1 2)) Along the same lines, we'd want #lang scheme (define-struct a (x y) #:transparent) (+ 'x (list (make-a 1 2))) to produce the error message +: expects type <number> as 1st argument, given: x; other arguments were: (#(struct:a 1 2)) while #lang racket (define-struct a (x y) #:transparent) (+ 'x (list (a 1 2))) should produce the error message +: expects type <number> as 1st argument, given: 'x; other arguments were: `(,(a 1 2)) The different `define-struct's are easily support through different bindings imported by `scheme' and `racket'. Similarly, for printing top-level results in a module, you might imagine that `scheme' and `racket' use different printing functions. The different error formats, however, are not so easily controlled through bindings. Setting `print-as-quasiquote' to #t is enough to get the Racket-style error format, but having `#lang racket' inject `(print-as-quasiquote #t)' in the module top-level would not work well when modules from different languages are mixed together. For example, if a program imports both ;; s.ss: #lang scheme (define (s-bad v) (error 's-bad "~e" v)) (provide s-bad) and ;; r.rkt #lang racket (define (r-bad v) (error 'r-bad "~e" v)) (provide r-bad) the way an error message is printed by `s-bad' and `r-bad' shouldn't depend on the order that the modules are instantiated. To accommodate run-time configuration of the environment, such as setting the way that values are printed, `mzscheme' now treats the main module of a program specially. It extracts information about the module's language --- specifically, whether the language declares a run-time configuration action. If so, `mzscheme' runs the language-configuration action before it instantiates the module. As a result, when you put either version of the code above in "ex.ss", then `mzscheme ex.ss' produces the right error message. Here's how it works in more detail for the case of `#lang racket': * The `racket' module reader has implemented in `racket/lang/reader' associates a 'module-language property with `module' form that it produces from "ex.ss". The 'module-language property essentially points back to `racket/lang/reader'. * The macro expander and bytecode compiler preserves the 'module-language information so that it's available through `module-compiled-language-info' (from the unevaluated bytecode) and/or `module->language-info' (from the evaluated module declaration). * When the `mzscheme' executable is given a module to run, it uses `module->language-info' to get the module's language information before `require'ing the module. The `module->language-info' loads "ex.ss" (from source or bytecode) and extracts language info from the declared module. The language info on the declaration of the module from "ex.ss" points back to the `get-info' export of `racket/lang/reader'. The `mzscheme' executable calls that function with the 'configure-runtime key. * The `get-info' function of `racket/lang/reader' recognizes the 'configure-runtime key and reports back the `configure' function provided by `racket/private/runtime'. [Why doesn't `get-info' just call `configure' directly? See below on creating executables.] * The `mzscheme' executable calls the `configure' function of `racket/private/runtime' calls it. The `configure' function simply sets the `print-as-quasiquote' parameter to #t. * Having finished running the language's configuration action, the `mzscheme' executable `require's the "ex.ss" module to instantiate it. (Although `module->language-info' has already loaded the module, `module->language-info' doesn't instantiate the module.) Instantiating the module runs the expressions in its body, triggering the `+' error. The error message uses the right style for printing values because the `print-as-quasiquote' parameter was set to #t by `configure'. If you run `mzc --exe ex ex.ss', the generated executable prints the right error message, too. That's because `mzc' extracts the main module's language information in the same way as `mzscheme'. Based on the result for 'confgure-runtime for the module's language, `mzc' embeds the `racket/private/runtime' module in the generated executable (and that's why `get-info' doesn't call `configure' itself). The generated executable includes a start-up action that calls `configure' before running the main module. DrScheme should similarly extract language information and call `configure' before running the module. It may be that a single side-affecting `configure' function isn't the right interface for DrScheme, and so experiments with DrScheme may lead to a different protocol for `mzscheme' and `mzc'. When `mzscheme' is run in interactive module, the initialization module's language is used to initialize the run-time configuration. The `racket', `racket/base' and `racket/init' modules are implemented in Racket, so mzscheme -I racket/init gives you a REPL like `racket' could give you (when it exists). _________________________________________________ For list-related administrative tasks: <a href="http://list.cs.brown.edu/mailman/listinfo/plt-dev" target="_blank">http://list.cs.brown.edu/mailman/listinfo/plt-dev</a> </blockquote></div>