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 ... ')

[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 ar

[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>
#

[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

[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 t

[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

[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.

[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)

[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
  reorganiz