gmane.comp.lang.racket.user

Method + URL based dispatch

Jordan Schatz — 2012-05-26T22:16:17

I would like to dispatch requests based on a combination of URL and HTTP
method. For example a GET request to /path-to-resource would be dispatched to
one function, and a POST request to /path-to-resource would be dispatched to
another function. The built in dispatch
http://docs.racket-lang.org/web-server/dispatch.html?q=url%20dispatch doesn't
appear to supports this style of use. 

Is there anything built in that supports this style of usage?

Thanks,
Jordan
____________________
  Racket Users list:
  http://lists.racket-lang.org/users

Modifying how "interaction" renders results

Jens Axel Søgaard — 2012-05-26T20:27:48

While documenting a matrix library, I have used the nice feature
that picts returned by the evaluation are inserted into the resulting
documentation:

< at >interaction[#:eval matrix-eval
                    (current-print
                     (let ([print (current-print)])
                       (λ (v) (print (if (matrix? v) (matrix->pict v) v)))))
                    (matrix 2 2  1 2 3 4)]

The 2x2 matrix is converted to a pict by matrix->pict and thus
I get a nice matrix image in the documentation.

Now I am experimenting with MathJax.
Using Prabhakar Ragde code from RacketCon I can write

    < at >$[(tex-matrix (matrix 2 3 1 2 3 4 5 6))]

and get a nice inline matrix displayed.

Then I thought, I could use the trick as before to get nice matrices
in the output:

< at >interaction[#:eval matrix-eval
                    (current-print
                     (let ([print (current-print)])
                       (λ (v) (print (if (matrix? v) (tex-matrix (matrix v))))))
                    (matrix 2 2  1 2 3 4)]

But tex-m

Problem with hline in

Jens Axel Søgaard — 2012-05-26T14:03:43

Hi All,

Experimenting with  slideshow/pict  I noticed that the lines
produced by hline doesn't begin and end the same way.

    > (require slideshow/pict)
    > (scale (hline 30 1) 15)
    <line>

The start of the line is rectangular where as the end is rounded.
See attached image.

Should I change the pen type to get a line that is rounded in both ends?
If so, how?

--
Jens Axel Søgaard
____________________
  Racket Users list:
  http://lists.racket-lang.org/users

Issue with "cannot instantiate `racket/gui/base' a second time in the same process"

Kieron Hardy — 2012-05-26T07:17:44

Hi all,

In debugging my second display monitor issue I'm trying to make a little
test utility from the Racket source.

I've copied a snippet (pasted below) from
<somepath>\collects\mred\private\wx\win32\frame.rkt into a new file in the
same directory as frame.rkt.

Although it will compile (with raco make) and execute from the command line
(using racket), DrRacket refuses to compile or execute, failing with the
error message:
"cannot instantiate `racket/gui/base' a second time in the same process"

I've tried changing the order of the files in the require with no success.

Can anyone tell me if I'm doing something wrong or if I have a problem with
my configuration?

Cheers,

Kieron.

****

#lang racket/base

(require
         ffi/unsafe
         "utils.rkt"
         "types.rkt"
         )

(define-user32 EnumDisplayMonitors (_wfun _HDC
                        _pointer
                      (_wfun #:atomic? #t _pointer _HDC _RECT-pointer
_pointer -> _BOOL)
                      _pointer -> _BOOL))
__________

Looping with look-behind and look-forward

Harry Spier — 2012-05-26T04:56:18

I can use for/fold to loop through a sequence while having the current
element and  the previous element of the sequence still available by
doing something like this.

(for/fold ([previous-element-in-sequence '()][list-being-created '()])
  ( [current-element-in-sequence sequence])
  (do some stuff)
  ....
  (values current-element-in-sequence
          (cons something list-being-created)))

But what I want is to be able to loop through a sequence while having
the prior, the current and the next element available.

I'm sequencing through a representation of lines of a black and white
page of text showing where the black pixels are and from that
producing a graph showing the connectivity of the black pixel strips
on each line to the ones on the lines above and below it.

Using for/fold I'm able to code the graph of connectedness of the
black strips on each line to the prior line in a very straightforward
way, but I'd like to graph in both directions both to the prior line
and to the next line at the same time

Why are some Racket functions such a 'member' designed aspartially boolean?

Don Green — 2012-05-25T16:29:40

Why are some Racket functions such a 'member' not designed as booleans?
I would expect 'member' to be a boolean.
I am inclined to write my own version of 'member' that is boolean.
Before I do, I am wondering if the bright person who designed the Racket
function: 'member', did so for some very good reason that is not obvious to
me.
I notice that there are a number of other Racket functions like this, where
they return #t or the value of the argument passed to the function, not #t
or #f.
I am just looking for the concept so that I might be convinced that I
should use the racket function as it is, rather than writing a boolean
version.
Thanks
____________________
  Racket Users list:
  http://lists.racket-lang.org/users

complex sort or how to sort lines

Don Green — 2012-05-25T16:16:31

Given the output of Racket's read-words/line function, which produces a
list of lists. Each word is in a list, each group of words on a line is in
a list, all within a list.

Any ideas on how to sort on the car (first element) of each list that
corresponds to a line?

In other words, I want to sort lines based on the first word on a line.  I
want to keep the lines intact.
Thanks.
____________________
  Racket Users list:
  http://lists.racket-lang.org/users

Serializable struts and the quoted module path

Michael Wilber — 2012-05-25T00:14:20

Hey there!

So I'm trying to use racket/serialize according to
http://docs.racket-lang.org/reference/serialization.html?q=serialize#(def._((lib._racket/private/serialize..rkt)._deserialize))

According to the third bullet point, custom serializable structure types
include a "quoted module path" pointing to a module that provides the
serialized structure's serialization info. It seems to be a full
absolute filesystem path in my tests.

Problem is, I want to send serializable structs across the network to a
machine where the module path is different.

Is there a sane way to, uh, strip off the absolute parts in that path? I
could just mess around with the serialized info myself, but... oy,
that just feels nasty.

(If anyone's curious, my ultimate goal is to send serializable lambdas
to other machines. Just like Distributed Places, but not as conceptually
confusing and constraining.)
http://blog.racket-lang.org/2009/06/serializable-closures-in-plt-scheme.html

Thanks in advance.
____________________
  Racket Us

Second display monitor issue

Kieron Hardy — 2012-05-25T00:08:07

Hi all,

On one of my client's laptops (Windows 7), the attached code detects the
second display monitor (get-display-count returns 2), but prints exactly
the same values for the location and size of the two displays. i.e. The
top-left coordinate and size values returned ((0,0)  and 1024 x 768)  are
the same for both monitors. This effectively maps the second monitor
underneath(?) the main monitor, making it inaccessible to Racket.

In this particular case the second monitor is a TV connected through the
laptop's s-video port. Windows itself sees the two displays and is
configured to extend the desktop over both of them and 'Identify monitors'
works as expected. At least one other program can see and use the TV
without problems.

Racket has no problems seeing and using a second display monitor on this
same laptop when that second monitor is a video converter box connected
through the laptop's VGA port. Also Racket has no problems seeing and using
a TV as a second display monitor when connected to my (Vista)

Bindings for libgsl (GNU Scientific Library)

Jens Axel Søgaard — 2012-05-24T19:21:50

Hi All.

I am attempting to get Noels bindings for libgsl working on my machine
(OS X 64 bit).
    https://github.com/noelwelsh/mzgsl

My problem is that it crashes DrRacket and I can't pinpoint where it happens.

I downloaded gsl using port with

    sudo port install gsl

This downloaded and installed version 1.15.

Now racket is able to find and load the libraries.
I can now allocated a gsl_vector with
    (gsl_vector-malloc n).

Allas calling gslvector-fill! aka gsl_vector_set_all will crash Racket.

The vector structure is defined as:

(define-cstruct _gsl_vector
  ([size   _size_t]
   [stride _size_t]
   [data   _pointer]
   [block  _pointer]
   [owner  _int]))

And the actual allocation functions as:

(define (gsl_vector-malloc n)
  (define ptr (malloc _double n 'raw))
  (define v (make-gsl_vector n 1 ptr #f 0))
  (register-finalizer v (lambda (_) (free ptr)))
  v)

Does this look right?

The actual source file is here:
https://github.com/noelwelsh/mzgsl/blob/master/low-level/gsl-vector.ss


The error

use of `raco setup -l ...`

Danny Heap — 2012-05-23T21:04:54

I want to restrict to setting up just the collection I'm developing.
I've created a development link `raco planet link dsheap vis-eval 1 0
<path-to-package-dir>`, and now I'd like to generate documentation (or
at least see just the errors generated when I do), so I try

    raco setup -l dsheap/vis-eval:1:0

...but this generates an error, as does

   raco setup -l <path-to-package-dir>

module browser

Neil Van Dyke — 2012-05-23T18:13:09

In the Module Browser, has anyone tried annotating the graph edges with 
imported symbols that are actually referenced by the importing module?  
Maybe further annotate those symbols with phases?

Neil V.

____________________
  Racket Users list:
  http://lists.racket-lang.org/users

Conde Ordering

rod — 2012-05-23T12:44:04

Hi, I'm following "The Reasoned Schemer" and implementing the answers in
Racket, but for one answer Racket seems to be returning the results in the
wrong order.  It's number 52, commented out here:

https://github.com/rodnaph/the-reasoned-schemer/blob/master/01-playthings.rkt#L215

The answer the book gives is:

(tea #t) (cup #t) (#f #t)

but the answer Racket gives is

(#f #t) (cup #t) (tea #t)

Can anyone spot what I've done wrong, or possibly explain the different
behaviours?

Thanks,

rod.
____________________
  Racket Users list:
  http://lists.racket-lang.org/users

Functional Data Structures for Typed Racket?

Simon Haines — 2012-05-23T01:48:42

I'm pretty keen to try out some of the new data
structures<http://www.ccs.neu.edu/scheme/pubs/sfp10-kth.pdf>for typed
Racket, but they haven't landed yet--either in 5.2.1, or in the
repo last I checked. Is there any notion of when I might be able to get my
hands on them?

Can't figure out how to use module after raco planetfileinject

Shawn Smith — 2012-05-22T18:28:12

Hi,

I created a planet archive locally with raco planet create, then I
installed it into my local cache with raco planet fileinject.

All I've written in Dr Racket so far is:

(require (planet "something.rkt" ("shawnps" "something-racket.plt" 1 1)))

and it runs fine.

I can see it in the module browser (View -> Show Module Browser), and when
I double click on it, it opens the correct file.

But I get "unbound identifier" whenever I try to use any of its functions
or structs.

Any help is appreciated.

Shawn
____________________
  Racket Users list:
  http://lists.racket-lang.org/users

TypedRacket and SubModules

Ray Racine — 2012-05-22T17:13:23

Currently Typed/Racket does not recognized submodules.

  Type Checker: cannot typecheck unknown form : (module util
typed/racket/base ...

Will they be supported in the near future.

Thanks,

Ray
____________________
  Racket Users list:
  http://lists.racket-lang.org/users

Macro stepper expansion

Harry Spier — 2012-05-22T03:13:48

I've entered the following example from the Racket Guide into DrRacket

#lang racket
(define-syntax-rule (swap X Y)
  (let ([tmp X])
    (set! X Y)
    (set! Y tmp)))

(let ([tmp 5] [other 6])
  (swap tmp other)
  (list tmp other))

It gives me the correct result:

But  when I stepped through it with the macro expander I got:

 [Macro transformation]

(module anonymous-module racket
  (#%module-begin
   (define-syntax-rule
    (swap X Y)
    (let ([tmp X]) (set! X Y) (set! Y tmp)))
   (let ([tmp 5] [other 6])
     (let ([tmp tmp]) (set! tmp other) (set! other tmp))
     (list tmp other))))

I was expecting to see something like the Racket Guide description in
section 16.1 I.e:
"Racket doesn’t produce the naive expansion for the above use of swap.
Instead, it produces
(let ([tmp 5]
      [other 6])
  (let ([tmp_1 tmp])
    (set! tmp other)
    (set! other tmp_1))
  (list tmp other))            "

While I do get the correct result, why does the macro expander show me
(let ([tmp tmp]  ..... instead of (let ([

Audio input

Jordan Johnson — 2012-05-21T23:59:39

Hi all,

A couple of my students are toying with the idea of generating pseudorandom numbers from ambient sources, and want to try using audio as a source.

They are doing it on Linux and not concerned about portability, and they just need to be able to grab some input on demand, so my initial off-the-cuff suggestion (advertised to them as such) was to open /dev/dsp for reading, read the number of bytes they want, and close it.  I don't know enough about Linux audio (or audio hacking in general) to know this is a workable way to get it done in Racket, so if any of you have done enough audio I/O work to confirm or refute this idea, or offer a better way, please let me know.

Thanks!

Best,
Jordan
____________________
  Racket Users list:
  http://lists.racket-lang.org/users

Is there a technical or social reason that parser-tools/lexer doesn't have an "else"?

Danny Yoo — 2012-05-21T23:54:34

I've been frustrated with trying to compose lexers together.  The
situation is that I'd like to define a lexer that knows how to give up
gracefully, and to give another lexer a go at processing a port.

Ideally, I'd like to say something like this:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define lexer-1
  (lexer ...
           [else (lexer-2 ip)]))

(define lexer-2
  (lexer ...
           [else (error 'i-dunno)]))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

As far as I can tell from reading the documentation, I can't make this
work nicely.  That is, I do not want lexer-1 to consume a character
when taking an alternative.

So putting:

;;;;;;
(define lexer-1
  (lexer ...
           [any-char (lexer-2 ip)]))
;;;;;;

despite what the documentation says about how this helps me handle the
error condition, is not a solution that sits right with me.  It
creates a non-composable situation with any other lexers I'd like to
work with.

To make it compose, I need to somehow get that character ba

Lazy Racket?

Michael Rice — 2012-05-21T20:02:31

Can I get Racket's graphics capability with lazy Scheme?

Michael
____________________
  Racket Users list:
  http://lists.racket-lang.org/users

help with scribble/manual

Danny Heap — 2012-05-21T19:36:41

I am trying to include a small manual page with my (also small)
PLaneT module.  Scribble doesn't see the bindings for the functions
introduced in my module, judging by the warnings generated by 'raco
setup...' --- errors which are also generated when the module is
required from the PLanet repository.  I was also unable to use
< at >examples[], presumably for the same reason.

I suppose I could work around the alarming error messages by omitting
the documentation, but that seems counter-productive.  Any
suggestions?

I attach my info.rkt, main.rkt, manual.scrbl files, and the errors
generated when the module is required.  I made a development link to
the directory containing those files, ran 'raco setup', created a
repository with 'racket planet create...', and then uploaded the
repository.