Jérémy Farnaud | 26 Nov 19:37 2014

qt-light egg patch for MacPorts compatibility


I'm interested in developing with chicken on my mac and I was happy to find that MacPorts had packaged
chicken. I wanted to use Qt so I installed the dependencies and installed the qt-light egg.
Unfortunately, it didn't compile. So I made a patch so it did. Here is the patch to the
"chicken-compile-qt-extension.scm" file I made :

>       (and (file-execute-access? "/opt/local/bin/qmake") "/opt/local")
> (define macosx (eq? (software-version) 'macosx))
> (if macosx (define install_name_tool "/usr/bin/install_name_tool"))
<       (if mingw32 "dll" "so.1.0.0"))
>       (cond (mingw32 "dll")
>             (macosx "1.0.0.dylib")
>             (else "so.1.0.0")))
>     (if macosx (run (,install_name_tool -change "libchicken.dylib" ,(make-pathname libpath
"libchicken" "dylib") ,output)))

It made compilation work for me! It would be nice if the patch could be added to the official egg. Since I'm new
to scheme and chicken, I hope I did it the right thing. If it's not how you do egg compilation scripts, please
let me know so I dig more into it.

Matt Welland | 23 Nov 21:51 2014

Enhancement request for the trace egg

I have two enhancement/suggestions for the trace egg:

1. Adding the line highlighted below to trace.scm gives me information on were the call was made, something I find very useful.
2. With huge or hierarchal data structures trace output gets annoyingly long. A mechanism for triming the output would be helpful.

(define (traced-procedure-entry name args)
  (let ((port (trace-output-port)))
    (set! *trace-indent-level* (fx+ 1 *trace-indent-level*))
    (write (cons name args) port)
    (write ", Called from: " port)
    (write (conc (car (reverse (get-call-chain)))))
    (write-char #\newline port)
    (flush-output port) ) )

90% of the nations wealth is held by 2% of the people. Bummer to be in the majority...
Chicken-users mailing list
Chicken-users <at> nongnu.org
Oleg Kolosov | 22 Nov 17:01 2014

Visual Studio is here


Considering that Visual Studio 2013 is now essentially free
(http://www.visualstudio.com/products/visual-studio-community-vs) I’m taking the
opportunity to announce again that I’m working on a version of CHICKEN Scheme which can be compiled with
it (with the help of CMake).

There are few other changes not supported by the CHICKEN developers. Roughly, the current agenda is:

 - make the code more approachable to an occasional contributor
 - replace the scheduler and posix support code with libuv facilities
 - better cross-compilation support
 - source level debugging
 - more usable profiler

You are welcome to follow/fork me on github:



Regards, Oleg
Art System
chicken-users | 21 Nov 16:48 2014

ffi howto


I need some help getting started with ffi. 

I am attempting to bind libuv to scheme code.

My chicken scheme code at http://pastebin.com/bwja0yet fails with the
following error.

The following code fails with the following:

Error: bad argument count - received 152135942 but expected 2: 0

	Call history:

	uv.scm:33: uv-default-loop        
	uv.scm:33: uv-idle-init   
	uv.scm:34: uv-idle-start          
	uv.scm:36: uv-default-loop        
	uv.scm:36: uv-run               <--

I am attempting to port the following C code.


- Omar
Sanel Zukan | 18 Nov 05:19 2014

Lisp Devroom at FOSDEM 2015: Call for Participation

Dear Lispers,

I'm pleased to announce, for the first time, Lisp Devroom  <at>  FOSDEM,
the biggest FLOSS event in Europe, that will be held in Brussels on
January 31st to February 2nd, 2015.

This is a call to propose your talks for FOSDEM.

The topic of the devroom includes all Lisp-inspired dialects,
like Common Lisp, Scheme, Clojure, Emacs Lisp, newLISP, Racket,
GCC-Melt, LFE, Shen & more. Every talk is welcome: from real-world
examples, research projects, unusual ideas to small pet hacks.

FOSDEM is a hacker conference and we would be happy to see more
practical proposals, crazy ideas and open source projects
demonstrations than dry scientific papers (we will leave them for ILC
and ELS :-P).

Important dates

* Submission deadlines:     2014-12-14
* Acceptance notifications: 2014-12-28
* Lisp Devroom conference:  2015-01-31 (Saturday)

Submitting proposals

Please use https://penta.fosdem.org/submission/FOSDEM15 to submit your
proposals; you will have to create Pentabarf account unless you
already have one.

When submitting your talk in Pentabarf, make sure to select the
'Lisp devroom' as the 'Track'.

Submission details

Your submission should include the following information:

* The title and subtitle of your talk, descriptive as possible
* A short abstract of one paragraph
* A longer description of the talk, if you would like so
* Links to related online material, like pages, blogs, repositories
  and etc.

Devroom mailing list

Please join Lisp devroom mailing list; this will be official
communication channel for the devroom and all further announcements
will be sent there.

* desktops-devroom <at> lists.fosdem.org

* https://lists.fosdem.org/listinfo/desktops-devroom - mailing list
  and subscription form

Planned schedule

Two types of sessions are considered:

* lighting talk - 30 minues
* full presentation - 60 minues

with 5 minutes for the setup between each talk. More details will be
announced on devroom mailing list.

Questions & volunteers

Don't hesitate to mail me at 'sanelz [at] gmail [dot] com' in case you
have questions or would like to help with organization (put
'[Lisp-fosdem]' in subject). Also, feel free to use official devroom
mailing list for discussion.

Did I said that there will be video recordings? Yes, video volunteers
are welcome too :)

Please forward this announcement to the relevant lists.

'(Best Regards, Sanel)
Alaric Snell-Pym | 15 Nov 19:27 2014

Correct type declarations for (call-with-... <thunk>) procedures

Hello folks!

I've been trying to get into the habit of putting type declarations on
everything I write in Chicken, to get the benefits of the lovely
scrutinizer: type checks, specialisations, etc!

I've also found that it's nice as documentation - I went around
switching various bits of Ugarit to use typed records, and kept finding
that some fields of structures were actually (or boolean ...), because
I'd forgotten some things were optional. But now that's clear in the
record definitions.

I can certainly recommend using typed records and (: ...)-ing all your
global definitions! It's being a worthwhile experience.

Anyway, I have a question, as I can't figure out how to type one of my

It's a (call-with-... <thunk>) wrapper. Indeed, it's this:

(define (call-with-context-support global-rules thunk)
   (let ((top-level-context (parse-top-level-context global-rules)))
      (parameterize ((*context* top-level-context)) (thunk))))

So I typed it:

(: call-with-context-support (list (-> *) -> *))

However, I ran into trouble when I used it like so:

(define-values (dir-key dir-reused? files bytes)
    (vault-global-directory-rules vault)
    (lambda () (store-directory! vault fspath))))

(store-directory! ...) returns four values, and as
call-with-context-support tail-calls the thunk, that works in practice.
But the type checker doesn't like it, and complains that an anonymous
lambda called tmp<some number> expects four arguments but is called with

So: What type should I give call-with-context-support to make it clear
that it returns whatever the thunk passed to it returns, multiple values
and all? I could figure out how to do it with forall if I knew how many
values to expect, but I want it to work for any number of arguments!




Alaric Snell-Pym

Chicken-users mailing list
Chicken-users <at> nongnu.org
David Van Horn | 7 Nov 17:41 2014

ICFP 2015: Call for Papers


 20th ACM SIGPLAN International Conference on Functional Programming

 ICFP 2015

 Vancouver, Canada, August 31 - September 2, 2015



Important Dates

   Submissions due:  Friday, February 27 2015, 23:59 UTC-11
   Author response:  Tuesday, April 21, 2015
                     through Thursday, 23 April, 2015
      Notification:  Friday, May 1, 2015
    Final copy due:  Friday, June 12, 2015


ICFP 2015 seeks original papers on the art and science of functional
programming.  Submissions are invited on all topics from principles to
practice, from foundations to features, and from abstraction to
application.  The scope includes all languages that encourage
functional programming, including both purely applicative and
imperative languages, as well as languages with objects, concurrency,
or parallelism.  Topics of interest include (but are not limited to):

* Language Design: concurrency, parallelism, and distribution; modules;
  components and composition; metaprogramming; type systems;
  interoperability; domain-specific languages; and relations to
  imperative, object-oriented, or logic programming.

* Implementation: abstract machines; virtual machines; interpretation;
  compilation; compile-time and run-time optimization; garbage
  collection and memory management; multi-threading; exploiting
  parallel hardware; interfaces to foreign functions, services,
  components, or low-level machine resources.

* Software-Development Techniques: algorithms and data structures;
  design patterns; specification; verification; validation; proof
  assistants; debugging; testing; tracing; profiling.

* Foundations: formal semantics; lambda calculus; rewriting; type
  theory; monads; continuations; control; state; effects; program
  verification; dependent types.

* Analysis and Transformation: control-flow; data-flow; abstract
  interpretation; partial evaluation; program calculation.

* Applications: symbolic computing; formal-methods tools; artificial
  intelligence; systems programming; distributed-systems and web
  programming; hardware design; databases; XML processing;
  scientific and numerical computing; graphical user interfaces;
  multimedia and 3D graphics programming; scripting; system
  administration; security.

* Education: teaching introductory programming; parallel programming;
  mathematical proof; algebra.

* Functional Pearls: elegant, instructive, and fun essays on
  functional programming.

* Experience Reports: short papers that provide evidence that
  functional programming really works or describe obstacles that have
  kept it from working.

If you are concerned about the appropriateness of some topic, do not
hesitate to contact the program chair.

Abbreviated instructions for authors

* By Friday, 27 February 2015, 23:59 UTC-11 (anywhere in the world),
  submit a full paper of at most 12 pages (6 pages for an Experience
  Report) in standard ACM conference format, including bibliography,
  figures, and appendices.

The deadlines will be strictly enforced and papers exceeding the page
limits will be summarily rejected.

* Authors have the option to attach supplementary material to a submission,
  on the understanding that reviewers may choose not to look at it.

* Each submission must adhere to SIGPLAN's republication policy, as
  explained on the web at


* Authors of resubmitted (but previously rejected) papers have the
  option to attach an annotated copy of the reviews of their previous
  submission(s), explaining how they have addressed these previous
  reviews in the present submission.  If a reviewer identifies
  him/herself as a reviewer of this previous submission and wishes to
  see how his/her comments have been addressed, the program chair will
  communicate to this reviewer the annotated copy of his/her previous
  review.  Otherwise, no reviewer will read the annotated copies of
  the previous reviews.

Overall, a submission will be evaluated according to its relevance,
correctness, significance, originality, and clarity.  It should
explain its contributions in both general and technical terms, clearly
identifying what has been accomplished, explaining why it is
significant, and comparing it with previous work.  The technical
content should be accessible to a broad audience.  Functional Pearls
and Experience Reports are separate categories of papers that need not
report original research results and must be marked as such at the
time of submission.  Detailed guidelines on both categories are on the
conference web site.

Proceedings will be published by ACM Press.  Authors of accepted
submissions will have a choice of one of three ways to manage their
publication rights.  These choices are described at


Presentations will be videotaped and released online if the presenter
consents.  The proceedings will be freely available for download from
the ACM Digital Library from one week before the start of the
conference until two weeks after the conference.

Formatting: Submissions must be in PDF format printable in black and
white on US Letter sized paper and interpretable by
Ghostscript. Papers must adhere to the standard ACM conference format:
two columns, nine-point font on a ten-point baseline, with columns
20pc (3.33in) wide and 54pc (9in) tall, with a column gutter of 2pc
(0.33in).  A suitable document template for LaTeX is available at


Submission: Submissions will be accepted on the web using a link
that will be posted at


Improved versions of a paper may be submitted at any point before
the submission deadline using the same web interface.

Author response: Authors will have a 72-hour period, starting at 0:00
UTC on Tuesday, 21 April 2015, to read reviews and respond to them.

ACM Author-Izer is a unique service that enables ACM authors to
generate and post links on either their home page or institutional
repository for visitors to download the definitive version of their
articles from the ACM Digital Library at no charge. Downloads through
Author-Izer links are captured in official ACM statistics, improving
the accuracy of usage and impact measurements. Consistently linking
the definitive version of ACM article should reduce user confusion
over article versioning. After your article has been published and
assigned to your ACM Author Profile page, please visit


to learn how to create your links for free downloads from the ACM DL.

Publication date: The official publication date of accepted papers
is the date the proceedings are made available in the ACM Digital
Library. This date may be up to two weeks prior to the first day
of the conference. The official publication date affects the deadline
for any patent filings related to published work.

General Chair:
  Kathleen Fisher        Tufts University (USA)

Program Chair:
  John Reppy            University of Chicago (USA)

Program Committee:
  Amal Ahmed                    Northeastern University (USA)
  Jean-Philippe Bernardy        Chalmers University of Technology (Sweden)
  Matthias Blume                Google (USA)
  William Byrd                  University of Utah (USA)
  Andy Gill                     University of Kansas (USA)
  Neal Glew                     Google (USA)
  Fritz Henglein                University of Copenhagen (Denmark)
  Gabriele Keller               University of New South Wales and
NICTA (Australia)
  Andrew Kennedy                Microsoft Research Cambridge (UK)
  Neelakantan Krishnaswami      Birmingham University (UK)
  Daan Leijen                   Microsoft Research Redmond (USA)
  Keiko Nakata                  Institute of Cybernetics at Tallinn
University of Technology (Estonia)
  Mike Rainey                   INRIA Rocquencourt (France)
  Andreas Rossberg              Google (Germany)
  Manuel Serrano                INRIA Sophia Antipolis (France)
  Simon Thompson                University of Kent (UK)
  David Van Horn                University of Maryland (USA)
  Stephanie Weirich             University of Pennsylvania (USA)
Sungjin Chun | 7 Nov 02:17 2014

[Q] How can I convert this lisp(SBCL) macro to chicken scheme?


I've rather impressed on Clojure's easy to use hash and vector/array, I've written
and used these macros in my lisp code. Now I want to convert them for chicken.

  (lambda (stream char)
    (declare (ignore char))
    (let ((*readtable* (copy-readtable *readtable* nil)))
      (set-macro-character #\} (get-macro-character #\)))
      (set-macro-character #\, (lambda (stream char)
                                 (declare (ignore stream char))
      (set-macro-character #\~ (get-macro-character #\,))
      (let ((contents (read-delimited-list #\} stream t))
            (ht (gensym)))
        `(let ((,ht (make-hash-table :test #'equal :synchronized t)))
           , <at> (loop for (k v) on contents by #'cddr
                collect `(setf (gethash ,k ,ht) ,v))

  (lambda (stream char)
    (declare (ignore char))
    (let ((*readtable* (copy-readtable *readtable* nil)))
      (set-macro-character #\] (get-macro-character #\)))
      (set-macro-character #\, (lambda (stream char)
                                 (declare (ignore stream char))
      (set-macro-character #\~ (get-macro-character #\,))
      (let ((contents (read-delimited-list #\] stream t)))
        `(vector , <at> contents)))))

How can I convert this macros to chicken, where can I find introductory docs on macro
of chicken scheme?

Thank you in advance.

Chicken-users mailing list
Chicken-users <at> nongnu.org
Kristian Lein-Mathisen | 2 Nov 14:43 2014

crypt egg: won't compile for Android

Hi all,

Android, I believe, like OpenBSD, has no libcrypt.so but still has support for the crypt function. The crypt.setyp has already support for removing the -lcrypt flag during compilation and injecting "android" into that seems to do the trick:

diff --git a/crypt.setup b/crypt.setup
index eeaf1d5..9dac09a 100644
--- a/crypt.setup
+++ b/crypt.setup
<at> <at> -28,2 +28,3 <at> <at> EOF
                 (openbsd #f)
+                (android #f)
                 (else #t)))))

Could someone fix this upstream if this patch is acceptable?
Thank you!
Chicken-users mailing list
Chicken-users <at> nongnu.org
Mathieu | 1 Nov 20:38 2014

Linking object files without additional source

Hi chicken schemers,

I want to use csc to link a bunch of .o together:

csc -c \
▸ sources/foreign-interfaces/fastcgi.o \
▸ sources/foreign-interfaces/sqlite.o \
▸ -o foreign-interfaces.o

But this command does not produce any output
unless a specify at least one .scm file.

How could I get foreign-interfaces.o as a result
of only linking fastcgi.o and sqlite.o?

Thanks for your help,
Chicken-users mailing list
Chicken-users <at> nongnu.org
Arthur Maciel | 1 Nov 19:51 2014

Re: Wiki design

Dear friends, after some rework of the wiki design I ended up with some modifications to allow better readability. I hope you all like them.

Mario has already applied them. Bug reports and suggestions to fix them are welcomed!

Best wishes,

2014-09-20 10:57 GMT-03:00 Arthur Maciel <arthurmaciel <at> gmail.com>:
Hello, folks!

Any news about the wiki design?

Best wishes,

2014-08-30 9:35 GMT-03:00 Yaroslav Tsarko <eriktsarko <at> googlemail.com>:


On 30.08.2014 4:08, Arthur Maciel wrote:
Matt and Yaroslav, thanks for your opinions! (more below)Yaroslav, I also don't like the current background, but I still prefer it comparing to the colors you've suggested. Probably we will also need some (color) theory to inspire any change. Otherwise we will fall into a complex territory called taste :)

What do you think?

As we say in Russia: "There is no friend in questions of color and taste" ("Every man to his taste" is the closest English idiom) :) I agree with you that current bg color is somewhat too heavy to look at so we could choose something different. I suggest you play with it and show some different colors you would like - may be we shall choose one of them.

As to the font size - I suppose it is okay now. I suspect that shall we let it unspecified and browser will substitute one that is more close to user or system settings.

Yaroslav Tsarko

Chicken-users mailing list
Chicken-users <at> nongnu.org