Gambit-list Février 2009

gambit-list@iro.umontreal.ca

37 participants
66 discussions

Serialization of continuations
by Jeremie Lasalle Ratelle 12 Fév '09

12 Fév '09

I am trying to serialize continuations with the following code http://pastebin.com/m32acd9c2 It works correctly in gsi but when I compile with gsc I get this error : can't serialize #<return #4> Is it possible to serialize a continuation in compiled code?

2 2

man _gambit func_
by lowly coder 11 Fév '09

11 Fév '09

so in emacs, I have c-h k, c-h f; for perl i have perl doc; for c, I have man pages in gambit scheme, when I want to lookup a quick descrition of what a function does, or look up it's source code, what's the most convenient way? currently I'm doing a mix of: grep "func_name" gambit-c.txt and cd ~/gambit-build-dir grep "func_name" . -R | grep "scm:" but i feel there should be a more elegant solution

9 17

format & regex
by lowly coder 11 Fév '09

11 Fév '09

hey, so gambit is really awesome; especially the debugger; however I'm running into some trivial practical issues -- and curious how others are solving it 1) sed/awk/grep/perl if possible, i'd like to use gambit for these type of apps instead (being slower is fine; i just want everything in scheme for now) -- is there a good way to do regex matching in gambit? 2) fprintf/format pp and display are cool -- but sometimes, I really really want control over my output; how is this generally done in gambit? things like "print this number with 8 chars width, 3 digits after the decimal point" seems kind of hard to phrase thanks! keep up the good work

5 5

Re: [gambit-list] man _gambit func_
by Marc Feeley 10 Fév '09

10 Fév '09

On 10-Feb-09, at 1:46 PM, vasil wrote: > REPL is not an IDE. They are very different by definition. REPL is > standing just for "read-eval-print-loop", IDE - "integrated > development > environment" You are reading into those acronyms way too much! Basically an IDE is a tool to help you develop and debug your program. It allows you to interact with the system to edit code, debug code, etc. The IDE helps you out with autocompletion, cross referencing, build automation, etc. Gambit's REPL is such an IDE. It is textual rather than graphical but it has the same purpose: help you develop and design programs. And the "I" of IDE is completely appropriate... the REPL is integrated to the environment so it is always there when you encounter a problem, allowing the user to debug programs at any time, even if the program was considered to be bug free (a feature I call "live debugging" or "open heart debugging"). It also allows you to debug programs that run on environments, such as embedded systems, that don't have a screen or enough memory to run a full-featured IDE. Gambit's REPL is more sophisticated than you might think. It is not simply as you suggest: (define (repl) (pp (eval (read)) (repl)) There is a lot of logic to give access to the environment, backtrace, threads, error messages, etc. Moreover Gambit's line editing has features that are more sophisticated than what is available in rlwrap. For example symbol completion, input highlighting, and emacs keybindings for s-expressions. Perhaps you can live without these things, but I can't. I use the REPL all the time from the shell. A full-featured IDE is too heavyweight for most of my needs (I don't want to have to wait a long time for the IDE to start, just do debug a simple script or experiment with a short piece of code). Marc

2 1

output of define-syntax
by lowly coder 10 Fév '09

10 Fév '09

Session: --- ~/dynamic$ cat t2.scm (define-macro (assert-equal lhs rhs) (let ((g-lhs (gensym)) (g-rhs (gensym)) (e-lhs (gensym)) (e-rhs (gensym))) `(let ((,g-lhs ,lhs) (,g-rhs ,rhs) (,e-lhs ',lhs) (,e-rhs ',rhs)) (if (not (equal? ,g-lhs ,g-rhs)) (pp `(,,e-lhs = ,,g-lhs <> ,,g-rhs = ,,e-rhs)))))) (pp (lambda () (assert-equal (+ 1 2) (- 3 4))) (current-output-port)) ~/dynamic$ gsi t2.scm (lambda () (let ((#:g0 (+ 1 2)) (#:g1 (- 3 4)) (#:g2 '(+ 1 2)) (#:g3 '(- 3 4))) (if (not (equal? #:g0 #:g1)) (pp `(,#:g2 ,@`(,'= ,@`(,#:g0 ,@`(,'<> ,@`(,#:g1 ,@`(,'= ,@`(,#:g3 ,@'()))))))))))) ~/dynamic$ Question: --- Why do I have: (pp `(,#:g2 ,@`(,'= ,@`(,#:g0 ,@`(,'<> ,@`(,#:g1 ,@`(,'= ,@`(,#:g3 ,@'()))))))))))) ? It seems prettier as: `(,#:g2 '= ,#:g0 '<> ...) the ,@` seems extraneous

2 2

largest projects
by lowly coder 09 Fév '09

09 Fév '09

what are the largest projects in: * gambit scheme (termite / jazz?) * scheme * scheme or lisp (emacs?) i'm interested in seeing if there's a way to visualize large scheme source code bases efficiently thanks!

3 2

rewriting a macro
by lowly coder 07 Fév '09

07 Fév '09

in the following code: (define-macro (assert-equal lhs rhs) (let ((g-lhs (gensym)) (g-rhs (gensym))) `(let ((,g-lhs ,lhs) (,g-rhs ,rhs)) (if (not (equal? ,g-lhs ,g-rhs)) (raise (list ',lhs '= ,g-lhs '<> ,g-rhs '= ',rhs)))))) used like this: (assert-equal (+ 1 2) (- 3 4)) is there anyway to rewirte that last line: (raise (list ...)) somehow in the format of: (raise '(....))

2 1

Question about garbage collections
by Bradley Lucier 06 Fév '09

06 Fév '09

Marc: When I do the following: > (##gc-report-set! #t) > (define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000)))(define a (time (random-f64vector 10000000))) then the gc reports are > *** GC: 75 ms, 1.71G alloc, 382M heap, 76.4M live (20% 55696+80018000) > *** GC: 64 ms, 2.01G alloc, 382M heap, 76.4M live (20% 55696+80018000) > *** GC: 64 ms, 2.31G alloc, 382M heap, 76.4M live (20% 55696+80018000) > *** GC: 64 ms, 2.61G alloc, 382M heap, 76.4M live (20% 55696+80018000) > *** GC: 64 ms, 2.91G alloc, 382M heap, 76.4M live (20% 55696+80018000) but after the computations are over I get > (##gc) *** GC: 28 ms, 2.98G alloc, 153M heap, 76.4M live (50% 54064+80018000) > So during the computation the heap size is set to five times the live size, which I did not expect, and after the computation the heap size is set to only twice the live size, which I did expect. What behavior should I expect from the gc? Setting the heap to five times the live size seems pretty extreme. Brad

2 1

##namespace
by lowly coder 06 Fév '09

06 Fév '09

where, if anywhere, is the ##namespace function documented? $ cat gambit-c.txt | grep namespace `ill-formed-namespace' Ill-formed namespace `ill-formed-namespace-prefix' Ill-formed namespace prefix `namespace-prefix-must-be-string' Namespace prefix must be a string `ill-placed-**namespace' Ill-placed '##namespace'

2 1

Re: [gambit-list] dynamic scope
by Marc Feeley 04 Fév '09

04 Fév '09

On 31-Jan-09, at 11:44 PM, lowly coder wrote: > Great, the following works: > > cat test.scm > (define (foo x) (* x 2)) > > (define (g x) (foo x)) > > > (pp (g 2)) > (pp > (let ((old-func '())) > (dynamic-wind > (lambda () > (set! old-func foo) > (set! foo (lambda (x) (* x 3)))) > (lambda () (g 2)) > (lambda () (set! foo old-func))))) > > (pp (g 2)) > > 4 > 6 > 4 > > two questions: > 1) can anything go wrong with variable capture / aliasing? > [intuitively, I believe no, so long as I don't use 'old-func' in my > thunk > 2) is there a more elegant/idiomatic way to do this? In terms of elegance I prefer this (which eliminates all variable capture problems): (let ((thunk (lambda () (g 2))) (new-foo (lambda (x) (* x 3))) (old-foo foo)) (dynamic-wind (lambda () (set! foo new-foo)) thunk (lambda () (set! foo old-foo)))) But once again this will not work right if multiple threads are dynamically scoping foo simultaneously, but the parameterize based approach will work fine. Marc

3 4

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Gambit-list Février 2009