So we have just 2 scheme dialects - Chez and Racket - which are distributed as windows EXE?

Conclusion:

GNU Guile seems to optimize incorrectly, as using -O0 in guild can sometimes result in faster programs than using the "highest" optimization -O3 .

Why? Likely (I'm just guessing) because the compiler picks a route which is supposed to be faster, but isn't. Specifically with the procedure:

(expt 2 (* 4096 4096))

This could be proven by disassembling, but that's beyond the point (I don't really have the patience after all of this)

How I got here:

I was just exploring GNU Guile's limits until I stumbled upon something by accident. GNU Guile doesn't seem to have a limit on number sizes, same way as Chez, which is great! But...

(expt 2 (* 4096 4096))

This procedure took roughly 4 minutes to process... which was a little strange since Guile uses GMP. How come it's so slow? Maybe the number is just really that large?

So I read a little and found the REPL function ,optimize. I prefixed my exponent function with this and ran it... Literally instantly it blasts out the result! I was pretty happy so I put this into a file:

(display (expt 2 (* 4096 4096)))

And ran guild compile -O3 test.scm. Maximum optimization! I execute guile test.scm and wait... Nothing... For a whole 4 minutes again. Why?

Okay, ,optimize must use some kind of special method, right? Looking into the source code of guile, specifically the module/system/repl/ files (took a few hours of piecing together the code and reading the Guile manual (I started using scheme like 7 days ago)), I discover that the procedure that ,optimize uses to optimize is called repl-optimize.

So I mess around with this in the REPL, trying all sorts of different things and getting all sorts of outputs, but all of this just ends up in failure. Still slow.

But I missed something: repl-optimize doesn't seem to use any optimization at all... So it's equivalent to -O0. It seems stupid, but I run guild and run it... Instant result.

Questions for more advanced people:

• Am I the first to discover this?
• Should I send a bug report/patch of some sort?

I've gotten to quite like using lisp and would like to know as many places as possible I can make use of it. I already use it for writing scripts in Gimp. I use Maxima CAS (I'm an Open University student doing Bsc Mathematics) but have not seen how I can use pure lisp with it. I've also started learning to use emacs and have heard lisp is used to write scripts/macros.

Any tips and pointers for further practice would be appreciated :)

So I'm just learning Scheme now. I learned Lisp many years ago, but now I want to know scheme specifically. Right now I'm learning about continuations. After trying to figure this out on my own I realized that half my problem (with being slow at understanding what's going on) is this weird method of calling call/cc to get the continuation. So, I came up with a simple function that I think does what one generally does when calling call/cc and instantly I understood what continuations are. But I wonder if my 'fix' to the code is legitimate. Here's the function I wrote:

(define /cc (lambda ()

(call/cc

(lambda (k)

k))))

So, it just reverses the odd syntaxy for call/cc to a function /cc which just returns a current continuation. Which I can save (define k (/cc)) and invoke later to jump back to this spot with restored context (stack and environment).

Is it wrong to do it this way? Do I miss out on anything if I choose to use this instead of call/cc directly? Any other things I should be aware of?

Thanks for any help.

The site's been dead for some time now. But the Github repo still shows activity.