gmane.lisp.scheme.plt.devel

[racket-dev] Nit in Windows build files

Paul Steckler — 2010-08-16T05:58:22

In last night's build, the Visual Studio solution file
src/worksp/racket/racket.sln contains the line:

  Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "libracket",
      "..\libracket\libracket.vcproj",  "{A6713577-7DFB-48F8-B8C1-7DB2D7C51F90}"

When you load that solution into VS2005, that project shows up as
`libmzsch', which is
confusing (and breaks some code I'm working on).

I think you just need to rename the project.

[racket-dev] Code review tool

Vincent St-Amour — 2010-08-15T02:07:55

Last week at PLT day, there was some discussion about code review, and
how to potentially integrate it with our workflow.

I found the following tool which may help:

http://code.google.com/p/gerrit/

If I understand correctly, commits that are pushed don't go directly
to the main repository; instead, they go to an intermediate repo,
where any authorized user can approve them and push them to the main
repo.

Vincent

[racket-dev] a pretty funny home page

Shriram Krishnamurthi — 2010-08-14T12:52:54

Go to

http://sites.google.com/site/viktorwinschel/

then click on "Languages".

[racket-dev] Possible P4P or Honu ideas

Everett — 2010-08-13T20:08:08

Does anyone think this idea would work for P4P or Honu?

#lang alt-syntax
#|

Sets up a new reader that directly transforms the input into normal
S-Exprs, making this fully compatible with existing Racket (#lang
altsyntax would provide all of racket) and with macros.

Lexer Tokens
  ( ) [ ] { } (| |) _( : ): id string number char keyword etc...

Grammar
  expr
    : id
    | constant

    //Application with expr in app position
    | '{' expr '}' '(' expr_lst ... ')' -> '(' expr expr_lst ... ')'
    
    //Normal application f(a ...)
    | id '(' expr ... ')' -> '(' id expr ... ')'
    
    //Infix application
    | '(|' expr_0 expr_1 expr_2 '|)' -> '(' expr_1 expr_0 expr_2 ')'

    //Normal prefix s-exprs
    | '[' expr ... ']' -> '(' expr ... ')'
    | '_(' expr ... ')' -> '(' expr ... ')'

    //Rules that use colon to replace parens
    | id {no_ws()}? ':' ( { checkIndentation() }? expr ) ... -> '('
expr ... ')'
    | ':' ( { checkIndentation() }? expr ) ... -> '(' expr ... ')'
    | id '(' expr_0 ... '):' ( { checkIndentation() }? expr_1 ) ... ->
'(' id expr_0 ... expr_1 ...')'
    ;


Indentation rule for ':', checked by "checkIndentation()", is:
- Remember the column of the colon and indentation of the line it is on.
- exprs on the same line are included
- if there are no exprs on the same line, then include lines of the same
indentation for which that indentation is greater than the indentation
on the colon's line.
- if there is something on the same line as the colon, then include
lines of the same indentation for which that indentation is greater than
the colon's column.

The "no_ws()" check checks column of colon vs end column of id to make
sure there's no WS between them.  This could be done by a lexer
returning ID and ID_COLON tokens instead.

Note that the "{ code-that-returns-boolean }?" notation is a "semantic
predicate" in ANTLR. Also "->" is a tree rewrite in ANTLR too.

Reasoning:
- Use Shriram's idea of ':' to indicate structure (like if, let, etc.)
- Use Shriram's idea of {} around expr in application position
- Keep LL(1)
- Use indentation to replace parens when using ':'
- Make this a direct and obvious conversion to S-Expr to maintain
library and macro compatability (not just for students!)
- Allow an infix notation, which is very helpful for math and
comparison.  I use "(|" "|)" to maintain LL(1) parsing without stealing
{} from Shriram's use or '<' '>' which eliminates those chars in
operators, etc.
- Have function calls look like normal math, like f(a)
- Using [] is akin to saying "tuple", which is how it's often used in
let, for, etc. to pair id and value. So we can just parse them as normal
s-exprs
- Provide a way to write normal s-exprs if desired.  Making everything
use [] could work, but I gave "_(" ")" as an alternative to allow
varying things.
- Code should be visually structured very much like Racket is now.

Below shows some examples.
|#

let: loop :[acc 1]
           [acc2 2]
     set!(a 1)
     set!(b (|acc2 + 1|))
     loop((|acc + a|) b)
     
{lambda: [a] a}(1)

{f}(a)
f(a)
[f a]
_(f a)

{g}(a b)
g(a b)
[g a b]
_(g a b)
(|a g b|)

if: (|a > 0|)
    a
    b

;if no tokens on the rest of the line, indent > line_indent vs. indent >
colon_column
cond:
 [true
  doit()]
 [false
  dontDoIt()]
 [else
  "Hello World"]

match: thing
       ["a" display("Thing A")]
       ["b" display("Thing B")]
       [else display("Unknown")]

match:
  thing
  ["a" display("Thing A")]
  ["b" display("Thing B")]
  [else display("Unknown")]

;Blake's idea.  Allow params both in parens and after colon for better
structure formatting.
match (thing):
  ["a" display("Thing A")]
  ["b" display("Thing B")]
  [else display("Unknown")]

if((|a > 0|)):
  a
  b

;Can be abused too, but you'd never do that, right?
match (thing 
       ["a" display("Thing A")]):
  ["b" display("Thing B")]
  [else display("Unknown")]

  
let: :[a 1]
      [b 2]
      [c 3]
    _(+ a b c)


let:   :[a 1][b 2][c 3]
     [+ a b c]

let:
  :[a 1][b 2]
   [c 3]
  +(a b c)
  
define-syntax-rule: 
  test-term-equal(lhs rhs)
  test-equal(term(lhs) term(rhs))

[define-syntax-rule [test-term-equal lhs rhs]
  [test-equal [term lhs] [term rhs]]]

begin:
  doA()
  doB()
  void()


;Use of infix for non-math operations works too, of course.
(| range(1 100) map + |)

;The following is a Redex grammar (a piece of a grammar I'm using)
define-language(lang):
  e: v
     < at >(e)
     id
     setop([pattern in e] e)
     if(e e e)
     let( [[id e]] e)
     op(e ...)
  k: ret
     < at >(k)
     setop(pattern e k)
     if(e e k)
     pop(eta k)
     let(id e k)
     op( [v ...] [e ...] k)
  v: number
     true false
     error
     string
     [addr address]
     [const-set v ...]
     [const-tuple v ...]


Thanks,
-Everett Morse

[racket-dev] GUI Refresh

Everett — 2010-08-12T23:12:08

Observation of DrRacket and PLT Redex leads me to believe that when
updating something displayed in the GUI each change is immediately
reflected (in a nice functional manner), even if a batch of changes is
being performed, thus wasting time drawing the GUI on intermediate
results.  The effect is a less usable GUI.

Example 1:
Have two tabs open in DrRacket.  Click the other one.  You can see the
scroll bar adjust first, showing the corresponding location in the
current file, then the contents adjust second showing the right file.

Example 2:
In PLT Redex traces graph, move the font-size slider.  The whole GUI
freezes up until it has redrawn, even though I wasn't done moving the
slider.  The result is that I have to move the slider one font size (or
few font sizes) at a time.

Possible solutions:
- For the slider: a timeout after user input stops before actually
changing the value.
- For the tabs: The ability to give a list of changes before updating
the GUI
- Functions to turn on/off updating and use them around a group of
changes or when dragging a slider.
- Some other kind of double-buffering feature at least, so it isn't as
slow and as visible.


Or am I wrong about the cause (and thus solutions) of these GUI
problems?


Thanks,
-Everett

[racket-dev] How to build Places

Kevin Tew — 2010-08-11T21:59:11

Places is ready for experimentation by a wider audience.

Build Instructions
========================
mkdir build_places
cd build_places
../src/configure --enable-places
make
make install

Basic place API documentation should build in your user docs directory.
collects/tests/racket/place-channel.rktl tests communication of simple 
datatypes.

[racket-dev] continuation weirdness

Danny Yoo — 2010-08-11T19:58:03

I came across some oddity under DrRacket involving continuations.  If
I have the following in my definitions window:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

#lang racket
(define (make-gen gen)
 (let ([cont (box #f)])
   (lambda ()
     (call/cc (lambda (caller)
                (if (unbox cont)
                    ((unbox cont) caller)
                    (gen (lambda (v)
                           (call/cc (lambda (gen-k)
                                      (begin
                                        (set-box! cont gen-k)
                                        (caller v))))))))))))
(define g1 (make-gen (lambda (return)
                      (begin
                        (return "a")
                        (return "b")
                        (return "c")))))
(g1)
(g1)
(g1)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

then when I call (g1) in the interactions window, I see the following:

;;;;;;;;;;;;;;;;;;;;;;;;;
#<continuation>
#<continuation>
;;;;;;;;;;;;;;;;;;;;;;;;;

where the print-values display of the continuation function appears to
be printing twice.  I guess I'm trying to understand what DrScheme is
doing, well enough that I can duplicate this behavior in WeScheme, but
I'm a bit baffled.

[racket-dev] new release policy

Matthias Felleisen — 2010-08-11T14:22:17

Matthew, Robby and I discussed a switch to a slightly slower 
release policy after PLT Day. Here is what we propose to 
switch to: 

  four timed releases per year, 
targeted for on  August 1, November 1, February 1, May 1
to be started 2 weeks before that (I'll spell that out, if 
needed)

If there are any objections, the time to state them is now.

[racket-dev] experiment of the unified require syntax ==> Re:haskell's 'hell of a lot of libraries', planet

YC — 2010-08-09T22:12:42

[racket-dev] results of dlopen (hence ffi) persistent acrossevaluations?

John Clements — 2010-08-06T15:08:09

[racket-dev] Need a little git help

Jens Axel Søgaard — 2010-08-05T16:42:58

Hi All,

I have implemented a few triangle functions for the 2htdp teachpack
and want to push the changes.

I get the following:

80:plt soegaard$ /usr/local/git/bin/git push origin master
To pltgit:plt
 ! [rejected]        master -> master (non-fast-forward)
error: failed to push some refs to 'pltgit:plt'
To prevent you from losing history, non-fast-forward updates were rejected
Merge the remote changes before pushing again.  See the 'Note about
fast-forwards' section of 'git push --help' for details.

It says I should merge, so I try this:

80:plt soegaard$ /usr/local/git/bin/git merge origin
error: Your local changes to 'collects/teachpack/triangle-xxx.png'
would be overwritten by merge.  Aborting.
Please, commit your changes or stash them before you can merge.

The file triangle-xxx.png is one that I added locally.

What shall I do to merge and/or push?

--
Jens Axel Søgaard
_________________________________________________
  For list-related administrative tasks:
  http://lists.racket-lang.org/listinfo/dev

[racket-dev] source distribution problems

Matthew Flatt — 2010-08-05T12:36:54

Both problems at

 http://lists.racket-lang.org/users/archive/2010-August/040939.html

look like simple omissions in the distribution spec. I've pushed a fix
(hopefully) to the spec.


We need to add "build on Linux from source distribution" to our
release-time checklist. Kevin, can we put that under your name?


I think we should also fix the 5.0.1 source bundles. Eli, would that be
reasonable?

[racket-dev] Tech links with custom text

Vincent St-Amour — 2010-08-03T18:34:40

While writing documentation, I came across cases where I would have
wanted to link to technical terms (using the "tech" function) without
having the technical term itself be the text of the link.

For example, I wanted to link to the definition of "inexact number",
but I wanted the text of the link to be "inexact" instead of "inexact
number".

Is there a way to do that?

Vincent

[racket-dev] x86_64 libs not available to 32-bit ffi, right?

John Clements — 2010-08-03T13:21:33

[racket-dev] LLVM

Paul Steckler — 2010-08-03T00:38:21

I may have missed a post on this topic, but has anyone built an LLVM back-end
for mzc?

[racket-dev] status of the new `racket/gui'

Matthew Flatt — 2010-08-02T17:09:40

The `racket/gui' re-implementation is starting to come into focus.
DrRacket mostly works, although lots and lots of problems remain.

The code is still hosted here:

 http://github.com/mflatt/gr2

The GUI libraries do not work well enough that it's time to submit bug
reports, but DrRacket works well enough that you could try to run it as
a preview. If GRacket or DRacket fails to start up due to issues
finding/loading Gtk or related libraries, please let me know.

The drawing part of the toolbox is in good shape, and bug reports on
that part are welcome. Slideshow programs should run well; let me know
if you have an example that renders incorrectly.

See below for a list of changes to the drawing library compared to
v5.0.x, so far. We'll eventually add support for gradients.


Currently supported platforms:

 * Unix variants using Gtk (32 and 64 bits)
 * Windows (32 bits)
 * Mac OS X (32 and 64 bits; use --enable-mac64 to build the latter)

----------------------------------------

 * The drawing portion of the old GUI toolbox is now available as a
   separate layer: `racket/draw'. This layer can be used from plain
   Racket independent of the `racket/gui' library, although
   `racket/gui' re-exports `racket/draw'.

   The `racket/draw' library is built on top of the widely used Cairo
   drawing library and Pango text-rendering library.

 * A color bitmap can have an alpha channel, instead of just a mask
   bitmap. When drawing a bitmap, alpha channels are used more
   consistently and automatically than mask bitmaps. More
   significantly, drawing into a bitmap with an alpha channel
   preserves the drawn alphas; for example, drawing a line in the
   middle of an empty bitmap produces an image with non-zero alpha
   only at the drawn line.

   Create a bitmap with an alpha channel by supplying #t as the new
   `alpha?' argument to the `bitmap%' constructor, or by loading an
   image with a type like 'unknown/alpha insteda of 'unknown or
   'unknown/mask.

   A newly created `bitmap%' has an empty content (i.e., white with
   zero alpha), insteda of unspecified content.

   Images can be read into a `bitmap%' from from input ports, instead
   of requiring a file path.

 * A `dc<%>' supports additional drawing transformations: a rotation
   (via `set-rotation') and a general transformation matrix (via
   `set-initial-matrix'). Scaling factors can be negative, which
   corresponds to flipping the direction of drawing.

   A transformation matrix has the form `(vector xx xy yx yy x0 y0)',
   where a point (x1, y1) is transformed to a point (x2, y2) with x2 =
   xx*x1 + yx*y1 + x0 and y2 = xy*x1 + yy*y1 + y0, which is the usual
   convention.

   New methods `translate', `scale', `rotate', and `transform'
   simplify adding a further translation, scaling, rotation, or
   arbitrary matrix transformation on top of the current
   transformation. The new `get-translation' and `set-translation'
   methods help to capture and restore transformation settings.

   The old translation and scaling transformations apply after the
   initial matrix. The new rotation transformation applies after the
   other transformations. This layering is redundant, since all
   transformations can be expressed in a single matrix, but it is
   backward-compatibile. Methods like `get-translation',
   `set-translation', `scale', etc. help hide the reundancy.

   The alpha value of a `dc<%>' (as set by `set-alpha') is used for
   all drawing operations, including drawing a bitmap.

   The `draw-bitmap' and `draw-bitmap-section' methods now smooth
   bitmaps while scaling, so the `draw-bitmap-section-smooth' method
   of `bitmap-dc%' simply calls `draw-bitmap-section'.

 * A `region%' can be created as independent of any `dc<%>', in which
   cases it uses the drawing context's current transformation at the
   time that it is installed as a clipping region.

 * The old 'xor mode for pens and brushes is no longer available
   (since it is not supported by Cairo).

[racket-dev] Typed Racket and importing polymorphic code

Shriram Krishnamurthi — 2010-08-02T13:42:45

Here's a typed module:

(module A typed/racket (provide insert map) (define insert cons))

Here are two clients, which behave inconsistently:

. Type Checker: The type of insert cannot be converted to a contract in: insert

Let's instead save A to a file, and write these clients as:

-----

#lang racket
(require "typed-set-impl.rkt")

-----

F5 executes fine.  Running works:

'(5 7 9)

But if I now type at the REPL:


I get the same error:

Type Checker: The type of insert cannot be converted to a contract in: insert

I have two issues with this:

1. Why is this discovered only when I "touch" insert and not sooner?
Is there some kind of lazy contract creation happening at run-time?

1'. That seems unlikely given that if I instead add "insert" to the
above (#lang racket) source file and run Check Syntax, I get the same
error -- so it is indeed a static error.  (Well, maybe not "static",
there are probably three or four "times" at work here.)

2. Why does the same not happen with map?  I can use map freely; if I
put it in the #lang racket file and Check Syntax, it draws an arrow
from map to the required (typed) file.  Yet in the typed file:

- : (All (a b) (case-lambda (a (Listof a) -> (Listof a)) (a b -> (Pairof a b))))
#<procedure:cons>
- : (All (c a b ...) (case-lambda ((a -> c) (Pairof a (Listof a)) ->
(Pairof c (Listof c))) ((a b ... b -> c) (Listof a) (Listof b) ... b
-> (Listof c))))
#<procedure:map>

so map does not look any less polymorphic than insert....

So what on earth is going on?

[racket-dev] Typed Racket and eq?

Shriram Krishnamurthi — 2010-08-02T13:40:33

If I export map (w/out change to type) from typed/racket and eq? it
against the map from racket, the two are eq?.  This feels like a
violation of abstraction: typed map is a "different thing" from
untyped map.

Shriram

[racket-dev] Typed Racket and ADTs

Shriram Krishnamurthi — 2010-08-02T13:39:39

How do I define an ADT?  Eg, I want to provide this:

(provide insert check empty-set)

(define-type RealSet (Listof Real))

(: empty-set RealSet)
(define empty-set empty)

(: insert (Real RealSet -> RealSet))
(define insert cons)

(: check (Real RealSet -> Boolean))
(define (check e s)
  (if (member e s)
      true
      false))

I see that using the opaque form of require/typed I can import RealSet
as, say, type RS and truly hide its representation.  However, this:

1. doesn't have a counterpart for *untyped* code;

2. seems very ugly to do from a typed module: I seem to need to define
the new opaque type, then enumerate everything (that I want) exported
from the typed module.  Surely there's an easy way of saying

  import SetADT renaming RealSet to RS making it opaque

?  It seems natural, but I can't figure out how to say this.

Overall, the status of representation-hiding in Typed Racket seems
rather weird.  I find it odd that even programming entirely in Typed
Racket, representations leak by default.  Worse, If I'm writing a
module whose representations I expect to frequently change, and would
like user code to avoid inadvertently relying on them, there appears
to be nothing I can do (without providing a wrapper that simply
re-exports everything with the type made opaque -- and even then, it's
not clear how to hide access to the original).  Just as there's an
opaque require, why isn't there dually an opaque provide, so the
creator can decide to hide reps?  Even if opaque provide only worked
for other typed clients, that would be a big step up.

Shriram

[racket-dev] Typed Racket interaction

Shriram Krishnamurthi — 2010-08-02T13:37:41

Here is a sequence of steps to do something that seems extremely
simple.  I want to create a binary tree of T.

First, I have no idea what this documentation means:

(struct:n (t ...))
is the type of structures named n with field types t.

All of "struct", "n" and "t" are italicized, suggesting they're all
meta-variables.  But only "n" and "t" are explained in the document.
Perhaps "struct:" is meant literally?

After several tries, I figure out no, it doesn't.  Okay, now I know
the basic syntax.

The next few things I do fail miserably, until I get this far:

(define-struct: (T) Node ([v : T] [l : (BinTreeof t)] [r : (BinTreeof t)]))
(define-type (BinTreeof t)
  (U 'empty
     [Node t]))

Now we get a classic impenetrable error message:

  Type Checker: Structure type constructor Node applied to non-regular
  arguments (Error) in: (Node t)

Whatever that means.  I rename the two "t"'s in Node to "T"'s:

(define-struct: (T) Node ([v : T] [l : (BinTreeof t)] [r : (BinTreeof t)]))
(define-type (BinTreeof t)
  (U 'empty
     [Node t]))

Now everything is fine...?!?  TR uses cpp to inline aliases?

Shriram

[racket-dev] Release Announcement for v5.0.1 -- final version

Eli Barzilay — 2010-08-01T22:18:22

Final version, after some edits and reorganization.

----------------------------------------------------------------------
* Datalog is a lightweight deductive database system with Racket
  integration.  It is now available in the `datalog' collection and
  with `#lang datalog'.

* Racklog provides Prolog-style logic programming in Racket, adapted
  from Dorai Sitaram's Schelog package.  It is available in the
  `racklog' collection and now as `#lang racklog'.

* By default `make install' and `raco setup' compile collections in
  parallel on all available processors.  (Use `raco setup -j 1' to
  disable, if necessary.)

* Changes (as part of 5.0) in the `racket' language compared to the
  `scheme' language: constructor-style printing, a `struct'
  alternative to `define-struct' that fits more naturally with
  `match' and constructor-style printing, bytecode-dependency
  management via SHA-1 hashes instead of just timestamps (where the
  `openssl/sha1' library provides the SHA-1 hash function), a
  reorganization of `scheme/foreign' into `ffi/unsafe' and
  associated libraries, and new printing functions `eprintf' and
  `displayln'.  Also, a generator from `racket/generator' is
  required to have the form `(generator () body ...)', which
  supports a planned extension to let a generator accept arguments.

* Changes to the `racket' language (since 5.0): internal-definition
  positions allow mixing expressions with definitions, full
  continuations can escape past a continuation barrier, custodians
  can attempt to terminate subprocesses and subprocess groups (see
  `current-subprocess-custodian-mode', `subprocess-group-enabled'),
  the JIT supports additional unboxing flonum operations and unsafe
  variants, `ffi/unsafe' provides an asychronous-call mechanism to
  deal with foreign threads, a new "." modifier for format string
  directives (e.g., "~.s" and "~.a") limits the respective output to
  `(error-print-width)' characters.

* The core type system of Typed Racket has been substantially
  revised.  In particular, Typed Racket can now follow significantly
  more sophisticated reasoning about the relationships between
  predicates.  Additionally, Typed Racket now allows variable arity
  types in more places, allowing programmers to specify
  variable-arity lists.

* We are working on an optimizing version of Typed Racket that takes
  advantage of type information for certain classes of programs.
  This project is a work in progress.  For those interested, see the
  documentation for `#:optimized'.

* The `web-server/formlets' library adds a `formlet*' form that
  allows dynamic formlet construction, as opposed to `formlet' which
  requires syntactic Xexprs and static formlets.  Several new
  library formlets are added.

* The `syntax/parse' library has new support for matching literals
  at different phases using the `#:phase' argument for literals and
  literal sets.

* RackUnit now includes a GUI test runner as `rackunit/gui'.

* The Advanced Student Language now supports hash-table primitives,
  `define-datatype' for defining sets of related structs, and
  `match' for pattern matching.

* The `2htdp/image' library now includes `flip-vertical' and
  `flip-horizontal' operations that mirror images (vertically and
  horizontally).
----------------------------------------------------------------------