<?xml version="1.0" encoding="UTF-8"?>
<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns="http://purl.org/rss/1.0/" xmlns:taxo="http://purl.org/rss/1.0/modules/taxonomy/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:syn="http://purl.org/rss/1.0/modules/syndication/" xmlns:admin="http://webns.net/mvcb/">
  <channel about="http://blog.gmane.org/gmane.lisp.scheme.plt">
    <title>gmane.lisp.scheme.plt</title>
    <link>http://blog.gmane.org/gmane.lisp.scheme.plt</link>
    <description/>
    <syn:updatePeriod>hourly</syn:updatePeriod>
    <syn:updateFrequency>1</syn:updateFrequency>
    <syn:updateBase>1901-01-01T00:00+00:00</syn:updateBase>
    <items>
      <rdf:Seq>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27872"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27870"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27865"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27858"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27856"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27845"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27844"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27843"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27834"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27814"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27812"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27811"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27810"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27809"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27808"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27807"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27794"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27793"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27786"/>
        <rdf:li rdf:resource="http://comments.gmane.org/gmane.lisp.scheme.plt/27783"/>
      </rdf:Seq>
    </items>
    <image rdf:resource="http://gmane.org/img/gmane-25t.png"/>
    <textinput rdf:resource=""/>
  </channel>
  <image rdf:about="http://gmane.org/img/gmane-25t.png">
    <title>Gmane</title>
    <url>http://gmane.org/img/gmane-25t.png</url>
    <link>http://gmane.org</link>
  </image>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27872">
    <title>regexp-match a full line</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27872</link>
    <description>_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
</description>
    <dc:creator>Eli Nistal</dc:creator>
    <dc:date>2008-10-07T00:29:38</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27870">
    <title>upgrading installed planet packages</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27870</link>
    <description>
Hi,

I track PLT using svn, re-building it from source every now and then,
which is a rather painless procedure. I usually choose the in-place
build/install, linking the binaries to somewhere in my PATH. But
everytime the version number of PLT changes, all my downloaded planet
packages (living in ~/.plt) are forgotten, because they live in
version-specific folders. Is there away of automating their
re-installation after an upgrade?

I've got the feeling that this is a FAQ, in which case i apologise and
will be happy with a link to the relevant discussion or document.

Thanks a lot!
jao

_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>Jose A. Ortega Ruiz</dc:creator>
    <dc:date>2008-10-06T21:10:50</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27865">
    <title>ARM support</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27865</link>
    <description>I have been using DrScheme to build some game prototypes. I recently
preordered a Pandora game console - http://www.openpandora.org to be
able to develop games on it. The openpandora is basically an open
console and has an ARM cpu and runs linux. I wanted to know if
DrScheme has a maintained arm port ?

Also - just as an aside have people tried getting DrScheme (or any
other scheme) to work on the iPhone (also an ARM device).
_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>Deep</dc:creator>
    <dc:date>2008-10-06T19:37:45</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27858">
    <title>Need information for create en executable withDrScheme (with windows)</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27858</link>
    <description>_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
</description>
    <dc:creator>Gilles PHAN</dc:creator>
    <dc:date>2008-10-06T16:05:57</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27856">
    <title>Need information for create en executable with DrScheme (with windows)</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27856</link>
    <description>_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
</description>
    <dc:creator>Gilles PHAN</dc:creator>
    <dc:date>2008-10-06T15:32:55</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27845">
    <title>Combining two definition into one only</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27845</link>
    <description>I am a scheme newbie, could anyone tell me how can i combine this
following 2 definition into one?
-----------------------------------------------------------------------------------------------------------------------------
(define insert-number
(lambda (new-element sorted)
(cond ((null? sorted) (list new-element))
((&lt;= new-element (car sorted)) (cons new-element sorted))
(else (cons (car sorted) (insert-number new-element (cdr sorted)))))))

(define insertion-sort-numbers
(lambda (numbers)
(let helper ((unsorted numbers) ; The remaining unsorted values
(sorted '())) ; The sorted values
(if (null? unsorted)
sorted
(helper (cdr unsorted) (insert-number (car unsorted) sorted))))))
_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>SamuelXiao</dc:creator>
    <dc:date>2008-10-05T14:56:13</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27844">
    <title>PLT Scheme v4.1.1</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27844</link>
    <description>PLT Scheme version 4.1.1 is now available from

  http://plt-scheme.org/

This is mostly a bug-fix release.

Notable changes:

* web-server: New servlet development tutorial; quick launching of
  servlets from DrScheme via the `web-server/insta' language; new
  form abstraction through formlets.

* misc: mzc can "decompile" bytecode files; `#lang' lines wired to
  the top of DrScheme's definition window; improved searching in
  DrScheme; some foreign interface extensions.

[Note that mirror sites can take a while to catch up with the new
downloads.]

Feedback Welcome,
</description>
    <dc:creator>Eli Barzilay</dc:creator>
    <dc:date>2008-10-05T20:14:16</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27843">
    <title>tools and practises to derice FFI types from C typedeclarations?</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27843</link>
    <description>I'm hoping this isn't the wrong place to be asking this kind of
question, if so please redirect me to the right place.

I'm trying to access the 'lstat' function within libgc
In order to perform some straightforward file attribute tests for a script
which hinges on the 'fold-files' function from file.ss.

In order to do so I must interface to a stat function and a 'stat' 
structure
declared in include files for that function call. &lt;sys/stat.h&gt;.

The foreign interface manual explains well enough how to interact
with c structures once you know the primitive types they use.

However typical library functions, rather than declare structures
using primitive types, tend to use intermediate sub-types, and how
these sub-types boil down to  primitives is partly dependent on compile
time switch conditions.  So in short, what primitives they boil down to
is installation dependent.

It's easy enough to trace things these back to primitives on a given
system, (the C preprocessor cpp helps a lot), but that only really
supplies that information on a given installation.

It really should be computed wherever a PLT scheme script is
installed.  At this stage I'm starting to feel like I'm reinventing the
wheel. Again!.   And this time only to accomplish a script.

Someone else has already had to cope with this issue and
written some useful tools for generating compatible
scheme code from C structure declarations.
If I had been responsible for any part of PLT scheme, I know
I would have done something along those lines.  Surely someone
else has?

For perspective, here is the output of the cpp preprocessor's
version of the stat structure on my system.

struct stat
  {
    __dev_t st_dev;
    unsigned short int __pad1;
    __ino_t st_ino;
    __mode_t st_mode;
    __nlink_t st_nlink;
    __uid_t st_uid;
    __gid_t st_gid;
    __dev_t st_rdev;
    unsigned short int __pad2;
    __off_t st_size;
    __blksize_t st_blksize;
    __blkcnt_t st_blocks;
    struct timespec st_atim;
    struct timespec st_mtim;
    struct timespec st_ctim;
    unsigned long int __unused4;
    unsigned long int __unused5;
  };

In the interest of brevity, I clipped the upper part of the preprocessor
output where for instance these translations can be gleaned:

__dev_t      to 'unsigned long long int'
__ino_t       to 'unsigned long int'
__mode_t   to 'unsigned int'

Is there an existing PLT recommended practise for dealing with these 
sorts of
installation issues?

Are there existing recommended tools for deriving necessary scheme interface
data from stand library include files?

If not are there existing workaround tools and practices being used until
recommended ones emerge?








_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>Ernie Smith</dc:creator>
    <dc:date>2008-10-05T20:03:11</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27834">
    <title>When does eqv? differ from eq? , from equal?</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27834</link>
    <description>_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
</description>
    <dc:creator>Woodhouse Gregory</dc:creator>
    <dc:date>2008-10-05T17:40:15</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27814">
    <title>apply vs dot notation syntax</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27814</link>
    <description>Hi all,

Probably it was discussed ages ago but could not find any links
regarding the following question.
Why scheme has 'apply' primitive instead of simple dot
notation ? i.e. we can use

(f arg1 arg2 . rest-of-args-list)

instead of standard:

(apply f arg1 arg2 rest-of-args-list)

The former looks similar to the 'define' syntax
and has advantage to be processed by a compiler
in some special way. For example, optimizer can remove
some unused arguments. Doing the same optimization with
standard approach looks unnatural from the compiler design
perspective : compiler [lower layer] should know about function 
primitives [higher level].

Thanks.

--
Bohdan

_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>kbohdan-JGs/UdohzUI&lt; at &gt;public.gmane.org</dc:creator>
    <dc:date>2008-10-05T10:35:02</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27812">
    <title>copy-paste from scribble html docs to drscheme</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27812</link>
    <description>Hi,

I sometimes copy paste code from the docs into DrScheme;

a really frustrating thing happens - every line in the docs is
replaces by 10 lines in DrScheme. (see example below)

I've attached a picture of the table structure used.

Would it be a problem If I looked into other ways of getting the same
layout without tables?

Cheers,

Stephen

--
Example source html for on-load-file (five lines)
&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;&lt;table class="prototype"
cellspacing="0"&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="schemeparen"&gt;(&lt;/span&gt;&lt;span class="schemesymbol"&gt;&lt;a
href="../reference/ivaraccess.html#%28form._%28%28lib._scheme/private/class-internal..ss%29._send%29%29"
class="schemesyntaxlink"&gt;send&lt;/a&gt;&lt;/span&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;span
class="schemevariable"&gt;an-editor&lt;/span&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;a
name="(meth._(((lib._mred/main..ss)._editor~3c~25~3e)._on-load-file))"&gt;&lt;/a&gt;&lt;span
class="schemesymbol"&gt;&lt;a
href="editor___.html#%28meth._%28%28%28lib._mred/main..ss%29._editor%7E3c%7E25%7E3e%29._on-load-file%29%29"
class="schemevaluelink"&gt;on-load-file&lt;/a&gt;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="schemevariable"&gt;filename&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="schemevariable"&gt;format&lt;/span&gt;&lt;span
class="schemeparen"&gt;)&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;→&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="schemesymbol"&gt;&lt;a
href="../reference/void.html#%28def._%28%28quote._%7E23%7E25kernel%29._void%7E3f%29%29"
class="schemevaluelink"&gt;void?&lt;/a&gt;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&amp;nbsp;&lt;/span&gt;&lt;span
class="schemevariable"&gt;filename&lt;/span&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;:&lt;span class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;span
class="schemesymbol"&gt;&lt;a
href="../reference/Manipulating_Paths.html#%28def._%28%28quote._%7E23%7E25kernel%29._path%7E3f%29%29"
class="schemevaluelink"&gt;path?&lt;/a&gt;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;table
class="argcontract" cellspacing="0"&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="schemevariable"&gt;format&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;:&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;td&gt;&lt;table class="schemeblock"
cellspacing="0"&gt;&lt;tbody&gt;&lt;tr&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="schemeparen"&gt;(&lt;/span&gt;&lt;span class="schemesymbol"&gt;&lt;a
href="../reference/Data-structure_Contracts.html#%28def._%28%28lib._scheme/private/contract..ss%29._one-of/c%29%29"
class="schemevaluelink"&gt;one-of/c&lt;/a&gt;&lt;/span&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;span class="schemevalue"&gt;'&lt;/span&gt;&lt;span
class="schemevalue"&gt;guess&lt;/span&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;span class="schemevalue"&gt;'&lt;/span&gt;&lt;span
class="schemevalue"&gt;same&lt;/span&gt;&lt;span class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;span
class="schemevalue"&gt;'&lt;/span&gt;&lt;span class="schemevalue"&gt;copy&lt;/span&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;span class="schemevalue"&gt;'&lt;/span&gt;&lt;span
class="schemevalue"&gt;standard&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;/tr&gt;&lt;tr&gt;&lt;td&gt;&lt;p&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&lt;/span&gt;&lt;span
class="schemevalue"&gt;'&lt;/span&gt;&lt;span class="schemevalue"&gt;text&lt;/span&gt;&lt;span
class="hspace"&gt;&amp;nbsp;&lt;/span&gt;&lt;span class="schemevalue"&gt;'&lt;/span&gt;&lt;span
class="schemevalue"&gt;text-force-cr&lt;/span&gt;&lt;span
class="schemeparen"&gt;)&lt;/span&gt;&lt;/p&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;


--
example of pasting editor-snip because  I can't remember all the attributes :-)
--
(new editor-snip%


 [


[editor editor]










[with-border? with-border?]










[left-margin left-margin]










[top-margin top-margin]










[right-margin right-margin]










[bottom-margin bottom-margin]










[left-inset left-inset]










[top-inset top-inset]










[right-inset right-inset]










[bottom-inset bottom-inset]










[min-width min-width]










[max-width max-width]










[min-height min-height]










[max-height max-height]])

---
_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
</description>
    <dc:creator>Stephen De Gabrielle</dc:creator>
    <dc:date>2008-10-05T08:07:04</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27811">
    <title>I really think this is such a great group!</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27811</link>
    <description>I like it!
_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>Geneve</dc:creator>
    <dc:date>2008-10-04T17:19:52</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27810">
    <title>Scheme Programming Question (Boolean Connectives)</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27810</link>
    <description>This is another problem that I am having trouble with.
I really need your help.


Question Details:
Exercise 7. The built-in predicate string&lt;? accepts two strings and
returns true if its arguments are given in lexicographic order, i.e.,
"alphabetical order," where our alphabet includes numeric and special
characters as well as alphbetic characters. That is, (string&lt;? s1 s2)
evaluates to true if s1 is a proper prefix of s2 or if there is a
character c1 in s1 and c2 in s2 where (char&lt;? c1 c2) and the (possibly
empty) prefix of s1 up to (but not including) c1 is equal to the
prefix of s2 up to (but not including) c2.



 Define a procedure string&lt;?. Use an internally-defined help procedure
and the built-in procedures char&lt;?, char=?, and string-&gt;list in your
solution, but do not use the built-in string&lt;? or other string
comparison predicates. Experiment with test cases of your own using
the built-in string&lt;? procedure before loading your own definition.




#f


#t


#t


#f


#f


#t


#f


#t



Hint: Use a local help procedure that expects two lists of characters.
Remember that the two lists may have different lengths, and think
carefully about termination conditions in different cases. If neither
list is empty, the help procedure compares the first characters of the
two lists, and loops only if the two characters are equal. Using and
and or should simplify your code.
_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>Geneve</dc:creator>
    <dc:date>2008-10-04T17:13:17</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27809">
    <title>Scheme Programming Question (Making an error message)</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27809</link>
    <description>Can anyone do this? This is my homework, and I am really having
trouble with it.
Can any smart scientist do this?




Question Details:
Exercise 13. For Assignment 4, you defined the procedure reverse-list.
A call to your version of reverse-list probably resulted in the
following sort of error when passed an invalid argument.



-------------------------------

(define combine-lists

  (lambda (a b)

    (if (null? a) b (combine-lists (cdr a) (cons (car a) b)))))



(define reverse-list

  (lambda (ls)

    (combine-lists ls '())))

---------------------------------






Error in cdr: 3 is not a pair.




Error in cdr: c is not a pair.



Define reverse-list using an internally defined help procedure. Have
the help procedure signal an error if the incoming argument is not a
pair or empty list. Your solution should make only one pass through
the list. In particular, you should not use list?, proper-list?, or
the equivalent to first check if the list is proper, since this would
count as an additional pass through the list. (Of course, you may use
the built-in pair? predicate.) (Naturally, you may not use the built-
in reverse procedure since the point of the exercise is to implement
that procedure.)



Identify the error as coming from reverse-list, not from the helper,
and show the original input to reverse-list in the error message, even
if the error occurs some iterations into the loop.






Error in reverse-list: 3 is not a proper list.




Error in reverse-list: (a . b) is not a proper list.




Error in reverse-list: (a b . c) is not a proper list.


(does this work? it should)



Hint: The text of this exercise tells exactly how to detect the error.
_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>Geneve</dc:creator>
    <dc:date>2008-10-04T17:11:43</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27808">
    <title>capturing composite mouse events in mred</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27808</link>
    <description>Hi,

I'm trying to capture a click on an empty pasteboard, but mouse events
only seem to exist in their most basic form. ('mouse-down 'enter 'exit
etc.)

[I can't be the first person to want to do this?]

Have I missed something in the documentation, is there a library, or
should I roll my own?

Stephen
_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>Stephen De Gabrielle</dc:creator>
    <dc:date>2008-10-04T22:19:21</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27807">
    <title>Code for catching exceptions in embedding applications</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27807</link>
    <description>Hi,

While trying to migrate an application to PLT 4.1, I stuck with 
exception handling.

Code below (basically it has been extracted from PLT documentation) 
crashes with
#f::0: compile: bad syntax; function application is not allowed, because 
no #%app syntax transformer is bound in: (lambda (thunk) (with-handlers 
((void (lambda(exn) (cons #f exn)))) (cons #t (thunk))))

Seg fault (internal error) at 4

Do I need to `require' some module for this to work?

#define MZ_PRECISE_GC 1
#include &lt;scheme.h&gt;
/* #include "base.c" */

static Scheme_Env *environment = NULL;

     static int
scheme_main(void *data)
{
     char *e =
"(lambda (thunk) "
"(with-handlers ([void (lambda (exn) (cons #f exn))]) "
"(cons #t (thunk))))";

     Scheme_Env *env = NULL;
     Scheme_Object *exn_catching_apply = NULL;
     Scheme_Object *sym = NULL;

     MZ_GC_DECL_REG(3);
     MZ_GC_VAR_IN_REG(0, env);
     MZ_GC_VAR_IN_REG(1, exn_catching_apply);
     MZ_GC_VAR_IN_REG(2, sym);
     MZ_GC_REG();

     MZ_REGISTER_STATIC(environment);

     environment = scheme_basic_env();
/*    declare_modules(environment);
     sym = scheme_intern_symbol("scheme/base");
     scheme_namespace_require(sym);
*/

     env = (Scheme_Env *)scheme_make_namespace(0, NULL);
     exn_catching_apply = scheme_eval_string(e, env);

     MZ_GC_UNREG();

     return 1;
}

int main()
{
     return scheme_main_stack_setup(1, scheme_main, NULL);
}
_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>Sergey Khorev</dc:creator>
    <dc:date>2008-10-04T15:02:42</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27794">
    <title>Win32 FFI: Handling structures.</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27794</link>
    <description>_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
</description>
    <dc:creator>Elena Garrulo</dc:creator>
    <dc:date>2008-10-03T12:28:44</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27793">
    <title>Objects, classes and match</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27793</link>
    <description>Hi all,

Is there any way to use match on an object? I can't see anything in  
the docs (although I may be missing something obvious). Something like:

     (match (new my-class%)
       [(struct my-class% (a b c))
       ...])

I don't mind setting up a custom match-expander. I suppose I could  
convert the object to a vector and match on that. That doesn't seem  
like a particularly efficient solution, though.

Cheers,

</description>
    <dc:creator>Dave Gurnell</dc:creator>
    <dc:date>2008-10-03T12:12:01</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27786">
    <title>Where to find out that library objects like "chmod" are available in the underlying implementation?</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27786</link>
    <description>I picked this out of the thread:


Easy indeed. I tried it. It works.

Now here are my questions:

1- Where would I have needed to look to find out that "chmod" is available
   like that when the lib argument is #f?

2- What other underlying system calls are available?

   The one that would suit me right now would be 'stat'.
   I'm attempting to write a script that traverses the file
   system on a specific device.  

   (fold-files ..) almost does the trick but...

   I need to prune cross-device directory transitions.  
   That would be easy enough by monitoring transitions in 
   device number using "stat".

   I also need to ignore all the special files one tends
   to find on unix systems, i.e. filter for 'regular files'
   not named pipes, special device files etc..
   
   The frustrating thought I've been having is that in order to implement
   (fold-files ...) the underlying software is likely using "stat". 
   
   I'm hoping this post has two effects.  
   1- A nice quick easy answer like Eli Barzilay came up with for "chmod".
   2- This inspires someone on the PLT team to come up with an improved 
      (fold-files ..) that makes the desire for "stat" ffi calls at this level 
      go away.

   BTW I'm still on 372

TIA



_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>Ernie Smith</dc:creator>
    <dc:date>2008-10-02T21:43:35</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27783">
    <title>Problem with require statements using PLT4.x</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27783</link>
    <description>_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
</description>
    <dc:creator>Joshua Ewulo</dc:creator>
    <dc:date>2008-10-02T16:55:15</dc:date>
  </item>
  <item rdf:about="http://comments.gmane.org/gmane.lisp.scheme.plt/27782">
    <title>HtDP 17.7.1-4 - Diff between name-of-function andfunction-name</title>
    <link>http://comments.gmane.org/gmane.lisp.scheme.plt/27782</link>
    <description>Hi All --

Two questions about exercises 17.4.*.

The terms of these exercises suggests a significant difference between
a function-name and name-of-function.

Is a function-name a symbol and a name-of-function a variable, where

A function-definition(fd) is a structure
(make-fd f-name p-name f-body) where
f-name is a symbol, p-name is a symbol and f-body is a scheme-
expression, and;

A name-of-function(fn) is the variable in the sentence
(define fn fd)
where define is a keyword, fn is a variable and fd is function-
definition, and;

A function-application (fa) is a structure, where
(make-fa fn arg)
where fn is a name-of-function and arg is a scheme-expression?

If this is the case, then I have a follow-up question for exercise
17.7.4:  what is the meaning of Step 2, which instructs "evaluate-with-
defs" to "look up the definition of P is defs?"

Example:,
(define(f x) (+ 3 x) is translated to name-of-function
(define f (make-fd 'f 'x (make-add 3 'x))), and;

(define (h u) (f (* 2 u))) is translated to name-of-function
(define h(make-fd 'h 'u(make-fa f (make-mul 2 'u))))

;;evaluate-with-defs: scheme-expression list-of-defs &gt; error or number
;;consumes a scheme-expression and a list-of-function-definitions:
returns an error if the ;;original scheme-expression is not numeric,
or if a function found as an arg for a function-;;application is not
listed in the list-of-defs; otherwise, returns a number

Examples:
1. (not(evaluate-with-defs 3 (list h))), since f is embedded in h, and
f is not present in list-of-defs
2. (evaluate-with-defs 3 (list f h)) returns 12
3. (not(evaluate-with-defs (f 3) (list h)))
4. (evaluate-with-defs (f 3) (list f h))) returns 18

My initial solution to this problem is this:
(define(evaluate-with-defs sx lofP)
 (cond
  [(empty? lofP)(evaluate-expression sx)]
  [else (evaluate-with-defs(evaluate-with-one-def sx (first lofP))
(rest lofP)))]))

The second condition would begin by applying f to 3, returning 6, and
then recurring.  Next, it would apply h to 6.  While doing so, it
would find that h is defined as a function-application of f to (* 2
u). At that point, it would "look-up" f in lofP to find its'
definition.  However, f has already been tossed after the first
recursive call, so it would presumably return an error, which is not
correct.

Is the solution to add a second parameter to evaluate-with-defs: "lofP-
index" which would serve as a look-up index for all function-
definitions listed in the original "lofP?"  If this is the case, then
all the previous functions would have to be retrofitted to carry this
index parameter.  That doesn't seem right.

Further, what is the point of "looking-up" the function-definition f
in lofP when the function-definition is present in the name-of-
function attribute of the function-application?  The only way this
would make sense to me is if the name-of-function attribute  was meant
to be a symbol, and not a variable. If that's the case, then my
approach to solving this and the previous exercise is wrong.

For completeness, here are the rest of my data-definitions and my
version of the solution to 17.7.3:

Thanks,
Dave Yrueta

Data Defs:
An "add" is a structure
(make-add left right)
where left and right are both Scheme-Expressions

An "mul" is a structure
(make-mul left right)
where left and right are both Scheme-Expressions

A Scheme-Expression (SX) is either
1. a number
2. a symbol
3. an add structure
4. a mul structure
5. a function-application (fa)

;;17.7.3
;;evaluate-with-one-def: sx P &gt; error or Scheme Expression
;;consumes a Scheme Expression and a Function-Definition, and returns
either an 'error ;;or the evaluated Scheme Expression
(define(evaluate-with-one-def sx P)
  (cond
    [(numeric? sx)
     (cond
       [(number? sx)(evaluate-expression(subs(fd-p-name P)sx(fd-f-body
P)))]
       [else(evaluate-with-one-def (evaluate-expression sx)P)])]
    [else 'error]))

;;subst:symbol number scheme-expression &gt; scheme-expression
;;consumes a symbol, number and scheme-expression, substitutes all
instances of the ;;symbol appearing in the scheme-expression with the
number, and then returns a ;;structurally equivalent expression.
(define(subs sym num sx)
  (cond
    [(mul? sx)(make-mul (subs sym num (mul-left sx))(subs sym num (mul-
right sx)))]
    [(add? sx)(make-add (subs sym num (add-left sx))(subs sym num (add-
right sx)))]
    [(fa? sx) (evaluate-with-one-def(subs sym num (fa-arg sx))(fa-fn
sx))]
    [(number? sx)sx]
    [(symbol=? sym sx)num]
    [else sx]))

(define(numeric? sx)
  (cond
    [(number? sx)true]
    [(struct? sx)(test-struc sx)]
    [else false]))

(define(test-struc sx)
  (cond
    [(mul? sx)(and(numeric? (mul-left sx))(numeric? (mul-right sx)))]
    [else (and(numeric? (add-left sx))(numeric? (add-right sx)))]))

(define(evaluate-expression nx)
  (cond
    [(boolean=? (numeric? nx)false)'error]
    [else (process-nx nx)]))

(define(process-nx nx)
  (cond
    [(number? nx)nx]
    [(mul? nx)(*(evaluate-expression (mul-left nx))(evaluate-
expression (mul-right nx)))]
    [else (+(evaluate-expression (add-left nx))(evaluate-expression
(add-right nx)))]))




_________________________________________________
  For list-related administrative tasks:
  http://list.cs.brown.edu/mailman/listinfo/plt-scheme

</description>
    <dc:creator>dave yrueta</dc:creator>
    <dc:date>2008-10-02T16:23:12</dc:date>
  </item>
  <textinput about="http://search.gmane.org/?group=$group=gmane.lisp.scheme.plt">
    <title>Search Engine</title>
    <description>Search the mailing list at Gmane</description>
    <name>query</name>
    <link>http://search.gmane.org/?group=$group=gmane.lisp.scheme.plt</link>
  </textinput>
</rdf:RDF>
