clisp-list — general help and discussion

Re: [clisp-list] FP using CL

[Jean L. <bu...@gn...>]

* Kaz Kylheku <ka...@ky...> [2021-05-06 19:11]:
> > It is easy to find examples of Common Lisp as functional language,
> > rather hard to find procedural examples.
> 
> Where are you looking? It's hard to find examples of Common Lisp as
> a procedural language in a book or tutorial that is ideologically
> geared toward functional.
> 
> If you look in real code, it's not hard to find procedural coding.
> 
> Just now, I headed to github and tried to think of some known CL project.
> 
> For some reason, the word *cl-who* popped into my head, probably
> because my mind drifted toward authors and I was thinking "who" do
> I look for?
> 
> And so, I searched for cl-who and immediately landed on this:
> 
> https://github.com/edicl/cl-who/blob/master/who.lisp
> 
> Whoa! Look, it's full of setf, loop, incf, nreverse ...

IMHO I was expecting more style without `defun'.

I do understand and get the point that in your examples while there
are many functions defined they don't just return the value but also
change various states, including they could be changing global
state. And that belongs to imperative programming style.

Though in Lisp it would be rare to find a program without `defun'
definitions.




Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/
https://rms-support-letter.github.io/

[clisp-list] Fwd: FP using CL

[Pascal B. <pj...@in...>]

-------- Message transféré --------
Subject: Re: [clisp-list] FP using CL
To: Duke Normandin <duk...@gm...>
References: <202...@gm...>
From: Pascal Bourguignon <pj...@in...>
Message-ID: <917...@in...>
Date: Sun, 2 May 2021 02:03:18 +0200
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:78.0) 
Gecko/20100101 Thunderbird/78.10.0
MIME-Version: 1.0
In-Reply-To: <202...@gm...>
Content-Type: text/plain; charset=utf-8; format=flowed
Content-Language: fr
Content-Transfer-Encoding: 8bit

Le 01/05/2021 à 20:00, Duke Normandin a écrit :
> Noob here!
> 
> All of my previous non-pro, hobbyist hacking experience has been imperative.
> I want to give FP a shot using CL.
> Problem: I don't seem to grok how to start the process of creating a CL program using **just** functions.
> 
> I mean, I can flowchart an imperative-styled program w/o too much difficulty.
> Need to grok how to do same in FP-style with CL.
> 
> I can learn the CL/Scheme/et al syntax, but it's the "Thinking in FP" that's killing me. :)
> 
> Any leads to relevant online resource(s)? TIA ...

I would advise to start with Bachus's fundational paper.

https://dl.acm.org/doi/pdf/10.1145/359576.359579
https://www.youtube.com/watch?v=FxcT4vK01-w
https://www.youtube.com/watch?v=OxuPZXXiwKk


Now, you don't have to use *just* functions, but indeed the idea is to 
build functions from other functions using function operators (such as 
the function composition operator for example), instead of definiting 
the functions detailing each operation element by element.

A function takes elements from a source set, and return elements in an 
image set.  The usual programming will give an expression of the image 
element "in function of" the element of the source set.


Let's define an affine function a:

a : ℤ → ℤ
     x ↦ 2x+1

or in lisp:

     (defun a (x)
       (+ (* 2 x) 1))


But if we define the function 2* (or double):

2* : ℤ → ℤ
      x ↦ 2x

and the function 1+ (or successor):

1+ : ℤ → ℤ
      x ↦ x+1

Then instead of defining a giving an expression element by element:

a : ℤ → ℤ
     x ↦ 2x+1

we can write a functional expression:

a = 1+ ∘ 2*

Using the composition operation between two functions f∘g(x) = f(g(x))

So:  a(x) = 1+ ∘ 2* (x) = 1+(2*(x)) = 1+(2*x) = 1+2*x = 2*x+1

Note that Common Lisp already has a function 1+ (and 1- for x-1).
We only need to define double and compose:

     (defun compose (f g) (lambda (x) (funcall f (funcall g x))))

     (defun times (n) (lambda (x) (* x n)))

     (defmacro define (fname fexpression)
        `(progn
           (declaim (ftype (function (t) t) ,fname))
           (setf (symbol-function ',fname) ,fexpression)))

     (define double (times 2))
     (define a (compose (function 1+) (function double)))

     (mapcar (function a) (iota 10))
     --> (1 3 5 7 9 11 13 15 17 19)

Note how I used mapcar, and not a procedural dotimes, so I get the
results for all the elements of the input set (iota 10) at once,
instead of computing and getting the result element by element:

     (dotimes (i 10)
       (print (a i)))

     1
     3
     5
     7
     9
     11
     13
     15
     17
     19

Now the question is to collect a library of functional operators that
will help us writing such functional expressions easily and
expressively.  And not all functions in the CL library are conductive
to easy building functional expressions from them.  So we may also
have to rewrite some library functions.


So here is another example; we could write:

     (defun minus (n) (lambda (x) (- x n)))
     (defun partial (f x)
       (lambda (y) (funcall f x y)))

     (mapcar
      (compose (partial (function reduce) (function +))
               (lambda (x)
                 (mapcar (lambda (f) (funcall f x))
                         (list (function identity)
                               (compose (minus 10) (function a))))))
      (iota 10))
     --> (-9 -6 -3 0 3 6 9 12 15 18)

     (list (function identity)
           (compose (minus 10) (function a)))

     --> (#<Compiled-function identity #x30000012D5FF>
         #<ccl:compiled-lexical-closure (:internal compose) #x30200275E99F>)

builds a list of 2 functions, identity = x ↦ x
and a-10 = x ↦ (2*x)+1-10 = 2*x-9


           (lambda (x)
             (mapcar (lambda (f) (funcall f x))
                     (list (function identity)
                           (compose (minus 10) (function a)))))


is a function that takes an argument and applies it to each function
of the list, returning a list of results:

          ((lambda (x)
             (mapcar (lambda (f) (funcall f x))
                     (list (function identity)
                           (compose (minus 10) (function a)))))
           5)
         --> (5 1)

partial is a function that takes a function and an argument, and
returns a function that takes a second argument and call the first
function with the two arguments.  It's a partial application of the
function.

So:  (funcall (partial f x) y)  == (funcall f x y)

Therefore:     (partial (function reduce) (function +))
returns a function that sums a list of numbers:

     (funcall (partial (function reduce) (function +)) (list 1 2 3 100))
     --> 106

So we can use it to compose it with the previous lambda which returns
a list of 2 numbers:

     (funcall (compose (partial (function reduce) (function +))
                       (lambda (x)
                         (mapcar (lambda (f) (funcall f x))
                                 (list (function identity)
                                       (compose (minus 10) (function a))))))
              5)
     --> 6

and use the composition in a map of the set of integers from 0 to 9:

     (mapcar
      (compose (partial (function reduce) (function +))
               (lambda (x)
                 (mapcar (lambda (f) (funcall f x))
                         (list (function identity)
                               (compose (minus 10) (function a))))))
      (iota 10))
     --> (-9 -6 -3 0 3 6 9 12 15 18)


-- 
__Pascal Bourguignon__

-- 
__Pascal Bourguignon__

Re: [clisp-list] FP using CL

[Kaz K. <ka...@ky...>]

On 2021-05-05 23:28, Jean Louis wrote:
> * Kaz Kylheku <ka...@ky...> [2021-05-03 22:41]:
>> On 2021-05-01 11:00, Duke Normandin wrote:
>> > Noob here!
>> >
>> > All of my previous non-pro, hobbyist hacking experience has been
>> > imperative.
>> > I want to give FP a shot using CL.
>> > Problem: I don't seem to grok how to start the process of creating a
>> > CL program using **just** functions.
>> 
>> The good news is that pretty much "nobody" does that. Common Lisp is a
>> multi-paradigm language.
> 
> It is easy to find examples of Common Lisp as functional language,
> rather hard to find procedural examples.

Where are you looking? It's hard to find examples of Common Lisp as
a procedural language in a book or tutorial that is ideologically
geared toward functional.

If you look in real code, it's not hard to find procedural coding.

Just now, I headed to github and tried to think of some known CL 
project.

For some reason, the word *cl-who* popped into my head, probably
because my mind drifted toward authors and I was thinking "who" do
I look for?

And so, I searched for cl-who and immediately landed on this:

https://github.com/edicl/cl-who/blob/master/who.lisp

Whoa! Look, it's full of setf, loop, incf, nreverse ...

Next, I just recalled a the existence of a Common Lisp program that
was part of someone's Ph. D. thesis about solving certain
geometric shape arrangement puzzles, namely tangrams. Aha,
here it is:

https://github.com/lambdamikel/Common-Lisp-Tangram-Solver

That's academic stuff doing some lofty algorithms, including
some approaches that must be novel if they fetched a Ph. D.

Academia is obsessed with functional nowadays. Still, can we
find imperative coding in it?

Let this be the first file I select for inspection:

https://github.com/lambdamikel/Common-Lisp-Tangram-Solver/blob/main/src/main/covering3.lisp

I see loops there. Loops are not inherently non-functional though;
sometimes their variable stepping is not relevant. I.e. they
basically emulate the math sigma notation, which isn't procedural.

More importantly, I see this in the file:

       (let ((ox (decode-ccw (orientation x)))
             (oy (decode-ccw (orientation y))))

         (when (eq ox :clockwise)
           (orientate-counterclockwise x))

         (when (eq oy :counterclockwise)
           (orientate-clockwise y))

         ...)

This is a let form with multiple body arguments, which means
they are being evaluated for an effect. The value of the first
(when ...) form is not being returned; it is ignored. Which
means that (oreintate-counterclockwise x) has an effect on the
object denoted by x.

It looks like the orientations of objects x and y are being
decoded, and then these objects are tweaked with an opposite
orientation, probably in order to normalize them in order to
reduce the number of cases later, or something.

See? You can do Ph. D. level work in computational geometry,
accompanied by imperative code written in Lisp.

I feel I could sit here all day, and easily land into one
Common Lisp source after another that is full of effectful
programming.

Cheers ...

Re: [clisp-list] FP using CL

[Jean L. <bu...@gn...>]

* Kaz Kylheku <ka...@ky...> [2021-05-03 22:41]:
> On 2021-05-01 11:00, Duke Normandin wrote:
> > Noob here!
> > 
> > All of my previous non-pro, hobbyist hacking experience has been
> > imperative.
> > I want to give FP a shot using CL.
> > Problem: I don't seem to grok how to start the process of creating a
> > CL program using **just** functions.
> 
> The good news is that pretty much "nobody" does that. Common Lisp is a
> multi-paradigm language.

It is easy to find examples of Common Lisp as functional language,
rather hard to find procedural examples.

When importing sets of data that require one time, single use
programs, I may write it in imperative style. After that, program may
be put in trash. Those are usually smaller programs that handle single
file in a weird non-standard format. Not even one function has to be
defined for such program to import the data.

IMHO imperative or procedural programming is also great to start
learning Common Lisp.

> > I can learn the CL/Scheme/et al syntax, but it's the "Thinking in FP"
> > that's killing me. :)

Good book is: http://www.gigamonkeys.com/book/

If I remember well I had same process to figure it out, but then
somewhere I read I should be making small functions, just enough to
fit on screen that do simpler things. And I do that so. Rarely a
function is larger than few lines. I do it, and I forget about it.

Recommended reading:
http://www.norvig.com/

To think in functional style, one should define functions that return
some values, that may be used in other functions, higher functions,
that end up in highest function calling the program.

If your functions are small enough and made to be reusable, after
building many functions you may find yourself writing less code for
marvelous results.

Let us say you wish to add, update, delete, copy entries in the
address book. 

1) Maybe you would first start with listing of all fields in the
   database, like first name, last name, city, country. That would be
   one function.

   (defun list-fields ()
     (let ((list "GIVE ME ALL FIELDS FROM DATABASE"))
        list))

    It returns the list. You would need to have function to display
    the list returned.

2) Other function would be maybe to edit value. Editing single value
   of any field. You would submit field to function and be able to
   edit it. Like (edit "Last name") could work to edit John Johnston's
   last name. As if function is generic, you will be able to edit any
   field with it.

   (defun edit-field (field)
     (let ((edited-value (edit-with-editor field)))
       (update-value database field value)))

3) Third one would be to update the value in the database. It would be
   sending the edited value into the database. Editing field would
   involve this function:

   (defun update-field (field value)
     (let ((database-command (format nil "PLEASE UPDATE FIELD ~A WITH VALUE ~A" field value)))
       (send-to-database database-command)))

   One can see tnnnhat `send-to-database' need to be another function.

4) Fourth could assign key bindings or menu.

5) Fifth one could list all entries on the screen.

6) Sixth could now call the listing of entries and call for key bindings.

User would then be faced with the screen, would be able to press key,
and by keys invoke all other functions.



Jean

Take action in Free Software Foundation campaigns:
https://www.fsf.org/campaigns

Sign an open letter in support of Richard M. Stallman
https://stallmansupport.org/
https://rms-support-letter.github.io/

Re: [clisp-list] FP using CL

[Duke N. <duk...@gm...>]

On Mon, 03 May 2021 12:27:22 -0700
Kaz Kylheku <ka...@ky...> wrote:

> On 2021-05-01 11:00, Duke Normandin wrote:
> > Noob here!
> >
> > All of my previous non-pro, hobbyist hacking experience has
> > been imperative.
> > I want to give FP a shot using CL.
> > Problem: I don't seem to grok how to start the process of
> > creating a CL program using **just** functions.
>
> The good news is that pretty much "nobody" does that. Common Lisp
> is a multi-paradigm language.
>
> A useful program has effects, like input and output.
>
> In Common Lisp, effects are worked into a program without any
> functional ceremony using regular imperative programming.

[snipped the good stuff]

WOW!  I'm overwhelmed by your reply! Thank you! I now need to lay
the text books aside and study your post! :-) Much obliged!

I must say that I don't have an overwhelming urge/impulse to do FP.
I just thought that because "functions" are so prevalent in
Lisp/Scheme, it was the prefered paradigm to be targeted by coders.
I'd just as soon get cozy with imperative Clisp e.g. and save FP
for later.

Anyway, thanks again!
--
Duke

Re: [clisp-list] FP using CL

[Kaz K. <ka...@ky...>]

On 2021-05-01 11:00, Duke Normandin wrote:
> Noob here!
> 
> All of my previous non-pro, hobbyist hacking experience has been 
> imperative.
> I want to give FP a shot using CL.
> Problem: I don't seem to grok how to start the process of creating a
> CL program using **just** functions.

The good news is that pretty much "nobody" does that. Common Lisp is a
multi-paradigm language.

A useful program has effects, like input and output.

In Common Lisp, effects are worked into a program without any functional
ceremony using regular imperative programming.

> I mean, I can flowchart an imperative-styled program w/o too much 
> difficulty.
> Need to grok how to do same in FP-style with CL.

In just about any imperative program, you can find sub-calculations
which can be worked in a functional style.

For instance, if you take two character strings and catenate them
together to produce a new string, without changing the original objects,
that's functional. You may have done that in already in imperative
programming. Inquiring about some property of an object without changing
its state is also functional.

In some Lisp programs, or program modules, that sort of calculation is
emphasized a great deal.

If you've done any Unix shell scripting, a lot of it is functional,
except for the part that we clobber a file at the end of the pipe:

    sed 's/a/b/' < this | grep that | sort > that

The evaluation of an arithmetic formula is functional. Where it becomes
imperative is when we stick the result into a variable or array or
whatever.

> I can learn the CL/Scheme/et al syntax, but it's the "Thinking in FP"
> that's killing me. :)

The following is not everything there is to "thinking in FP", but a big
part.

What is a computation? It's a transformation from some input to an
output according to some well-defined calculation steps.  A complex
transformation is made of simpler transformations.

Under FP, we break down the calculation into a sequence of data
transformations, much like what the mathematical description of the
process would be. We represent these transformations as functions, and
then chain them together.

Also, it is useful to keep in mind that the binding of a new variable
isn't mutation/assignment; it is also functional. The obvious example is
that functions have named parameters, and when they are called, those
parameters bind to argument values, and become newly instantiated
variables. If that weren't functional, functional programming would not
be possible (or would all have to be "point free": more on that point
later).

We can bind variables using *let* (which was originally a syntactic
sugar for lambda). Thus something like this is quite functional:

    (let ((x '(1 2 3))
          (y '(4 5 6)))
      (append x y))

which produces (1 2 3 4 5 6).

This principle helps in the writing of pure functions, because it allows
us to give meaningful names to subexpressions, and also to refer to
repeated terms by convenient names.

In contrast, the following is not functional, since we are mutating
variables:

    (let (x y z)
      (setq x '(1 2 3))
      (setq y '(4 5 6))
      (setq z (append x y)))

However, that brings me to a point: local variables (at least ones which
are not captured by an escaping closure) do not live past their
enclosing scope.

We can define a function that provides a calculation as a pure
transformation of its inputs. Yet, inside that function we can mutate
storage locations in order to implement that calculation.

You will find that Lisp functions in the wild often take such liberties.

One of the main engineering motivations behind using functional
programming is that mutations cause bugs that are hard to track down.
However local mutations which are confined to a small scope are easy to
reason about, and even formally verify.

If the specification of a function is functional, and by tests of its
external behavior, it appears functional (doesn't mutate anything that
the caller could possibly care about), then the function is in fact
function and can be used in functional programs.

This fact helps you: you can start using functional approaches in your
code without beating yourself up to make the internals of every function
being meticulously functional, and avoiding iteration in favor of
recursion and all that jazz.

It's a lot more important to specify (if possible) a functional API or
building block than for internals to be pure.

Here is a pure function for reversing a list, which
is internally impure:

    (defun reverse-list (input)
      (let (stack) ;; uninitialized lexicals are nil in CL!
        (dolist (i input stack)
           (push i stack))))

This walks the input list, pushing every element onto the local stack.
When dolist is finished the stack expression in (i input stack)
specifies the return value. I.e. loop i over the input, and when done,
return stack.

These pushes are imperative. The (push i stack) form has the same
meaning as (setq stack (cons i stack)): using the functional expression
(cons i stack) create a stack which has one more item than the previous
stack.  Then using setq, store the new stack into the stack variable.

The dolist macro itself may or may not be functional.  ANSI Common Lisp
says:

   It is implementation-dependent whether dolist establishes
   a new binding of var on each iteration or whether it
   establishes a binding for var once at the beginning and
   then assigns it on any subsequent iterations.

We have to assume that whenever we use dolist, it is just stepping the
same variable; i.e. that it is quite likely an imperative construct.

Anyway, when the function has terminated and produced a value, the
caller cannot tell that there existed a stack variable and a variable
called i which was stepped over a list. Those variables are gone. All it
knows is that the list which it passed into reverse-list has not been
modified, and that now also has a new list which is the reverse of that
list.

I mentioned "point-free" and promised to have more on it later. This is
something you may come across when you read about functional
programming. Point-free style means achieving a transformation without
mentioning any intermediate variables, including function arguments.
"Point" comes from a terminology which refers to the arguments of a
function as points. E.g. a binary function is "two point" and so on.

I gave a shell pipeline example earlier; and that happens to be point
free at least throughout the interior of the pipeline. The pipeline
connects a file called "this" to an output file called "that" and those
are named points. The pipeline itself is point-free: each pipeline stage
implicitly takes input from the previous stage.

Nested function invocations are point-free in the sense that variables
are not mentioned: For instance

    (* 2 (cos (sin x)))

is point free, except for the mention of *x*.

The shell pipeline style represents an alternative version of point-free
application, which is generally called "concatinative". The names of the
operations are written side by side and are understood to be implicitly
chained together.

Some functional languages emphasize concatinative point-free
programming. In Lisp, it can be simulated with macros.

(There are concatinative languages that are not strictly functional,
like Forth, which uses a stack for passing and returning values rather
than named parameters. The stack can be misused, causing underflows, or
stray values.)

Concatinative point-free code can make a functional program look
"scary". Expressions in the program just look like sentences of strange
words.

Also, unlike Lisp, some functional languages feature implicit partial
evaluation. A function call might be written like f x y, which is
ambiguous: it can be regarded as f being applied to arguments x y,
or as (f x) y: f partially applied to x to yield a function of one 
parameter,
which is then applied to y. These languages are statically typed,
therefore an expression like map f 3 s might be resolved as follows.
map is a two-point function which requires a function as its
first argument. Suppose f is a two-point function which takes two
integers and returns an integer. The only way a correct argument can
be formed for map is if f 3 is treated as a partial application.
That denotes an integer -> integer function, and s becomes the second
argument to map: the sequence to map over.  When reading this kind
of code, you have to be aware of the types and arities of the functions,
and possibly at the same time of unfamiliar infix operators that have
unfamiliar associativity and precedence.

In Lisp, partial application is simulated using explicit lambdas, for
which syntactic sugar can be developed using macros.

Thus you will not come across Lisp code that is concatinative or that
uses partial evaluation, except if it's doing that by means of macros,
which announce themselves by their explicit calls.

Re: [clisp-list] FP using CL

[Nemo N. <cy...@gm...>]

Greetings, Duke.

On 2021-05-01 14:00, Duke Normandin wrote:
> Noob here!
>
> All of my previous non-pro, hobbyist hacking experience has been imperative.
> I want to give FP a shot using CL.
> Problem: I don't seem to grok how to start the process of creating a CL program using **just** functions.
>
> I mean, I can flowchart an imperative-styled program w/o too much difficulty.
> Need to grok how to do same in FP-style with CL.
>
> I can learn the CL/Scheme/et al syntax, but it's the "Thinking in FP" that's killing me. :)
>
> Any leads to relevant online resource(s)? TIA ...
As far as the Scheme dialect goes, the MIT text SICP is available along 
with other material at 
https://mitpress.mit.edu/sites/default/files/sicp/index.html .  (The 
original course is archived here 
https://dspace.mit.edu/bitstream/handle/1721.1/35852/6-001Fall-2002/OcwWeb/Electrical-Engineering-and-Computer-Science/6-001Structure-and-Interpretation-of-Computer-ProgramsFall2002/CourseHome/index.htm 
.)

The next-generation MIT text HTDP is also available at 
http://htdp.org/2020-8-1/Book/index.html

Of CL, I am ignorant.

Best of luck.
N.

[clisp-list] FP using CL

[Duke N. <duk...@gm...>]

Noob here!

All of my previous non-pro, hobbyist hacking experience has been imperative.
I want to give FP a shot using CL.
Problem: I don't seem to grok how to start the process of creating a CL program using **just** functions.

I mean, I can flowchart an imperative-styled program w/o too much difficulty.
Need to grok how to do same in FP-style with CL.

I can learn the CL/Scheme/et al syntax, but it's the "Thinking in FP" that's killing me. :)

Any leads to relevant online resource(s)? TIA ...

--
Duke

[clisp-list] POSIX Regexp question

[Dan S. <dan...@ie...>]

Hello All,
When executing (type-of (regexp:regexp-compile "%d")) FOREIGN-POINTER is
returned.
Is there a way to get the type of the pointer, so I can confirm that a
compiled regexp is pointed to, rather than something else?
Thank you,
Dan Stanger

Re: [clisp-list] POSIX Regexp question

[<Joe...@t-...>]

Hi,

>(defstruct compiled-regexp value)
Pascal Bourguignon's response to Dan Stanger was quite exhaustive, yet I'd add another suggestion:

If you go the defstruct or defclass route, you could add a call to FFI:VALIDP to assess
whether the FFI pointer is still valid. If not, you could recompile the regexp (after you
add the source slot to the defstruct) – and replace the stale pointer.

FFI:VALIDP allows you to detect (or mark) stale pointers, such as all those emanating from a prior image.
https://clisp.sourceforge.io/impnotes/dffi.html

The benefit is that the freshly recompiled regexp would work after you save an image
and restart from that image – in case you like to work with your own images, e.g. in the
context of a fast start from a web server.
However, there will still be multiple regexp compilation times, one after each process start.

If the Lisp-only solution (e.g. CL-PPCRE) is ok with you, its benefit is that Lisp objects
(including closures) live on when restored from an image (that's the whole idea),
so the regex would be compiled once only.

As a result, even if CL-PPCRE were slower (I don't know) than the POSIX regexp module, using
it might still end up faster when using images, due to lack of recompilation. You'll have to check.

Regards,
	Jörg Höhle

Re: [clisp-list] POSIX Regexp question

[Pascal B. <pj...@in...>]

Le 23/04/2021 à 21:55, Dan Stanger a écrit :
> Hello All,
> When executing (type-of (regexp:regexp-compile "%d")) FOREIGN-POINTER is
> returned.
> Is there a way to get the type of the pointer, so I can confirm that a
> compiled regexp is pointed to, rather than something else?


No, there's no way.  regexp is a module using the C libregex library, 
and this library uses a C pointer.  There's no type tag, and no type 
really associated with the pointer at run-time. It's just an address. 
You have to know what is pointed to, when you want to dereference the 
pointer (or what function you can pass it to, when it's an opaque pointer).

Now, you have two choice:

1- don't use C libraries, don't use FFI.  Instead, use lisp libraries, 
implemented in lisp.  For example, use cl-ppcre instead of regexp.  One 
bonus advantage is that it makes your code portable to other CL 
implementations (regexp is a clisp specific module, even if the API 
could be implemented in other CL implementations).


     cl-user> (cl-ppcre:create-scanner "%d")
     #<ccl:compiled-lexical-closure (:internal 
cl-ppcre::create-scanner-aux) #x3020044E8B2F>
     nil
     cl-user> (cl-ppcre:scan (cl-ppcre:create-scanner "%d") "Hello %d 
World!")
     6
     8
     #()
     #()
     cl-user>

But note how even a lisp library returning a lisp object, may not use a 
specific type.  In this case, instead of returning an object of some 
compiled-regexp type, it returns a compiled lexical closure, which is a 
function like any other function.  You'd still have to know its 
signature and how to call it to be able to use it directly, or to know 
to what other library function you can pass it to, considering it an 
opaque type.


2- the other alternative is to wrap those foreign values into lisp 
objects.  This is something you will also want to do if you want to use 
CLOS and dispatch to methods.

(defstruct compiled-regexp value)
(make-compiled-regexp :value (regexp:regexp-compile "%d"))
--> #S(COMPILED-REGEXP :VALUE #<FOREIGN-POINTER #x00000001021040E0>)
(type-of *)
--> COMPILED-REGEXP

You just have to remember to unwrap the data when you use it:

     (defstruct compiled-regexp value)
     (make-compiled-regexp :value (regexp:regexp-compile "%d"))
     --> #S(COMPILED-REGEXP :VALUE #<FOREIGN-POINTER #x00000001021040E0>)
     (type-of *)
     --> COMPILED-REGEXP
     (let ((re (make-compiled-regexp :value (regexp:regexp-compile "%d"))))
        (regexp:regexp-exec (compiled-regexp-value re) "Hello %d World"))
     --> #S(REGEXP:MATCH :START 6 :END 8)

And of course, you can implement a wrapped API to make that automatic:

     (defpackage "MY-REGEXP"
       (:use "CL")
       (:export "COMPILED-REGEXP" "REGEXP-COMPILE" "MATCH"))
     (in-package "MY-REGEXP")

     (defstruct compiled-regexp value)

     (defun regexp-compile (re-string)
       (make-compiled-regexp :value (regexp:regexp-compile re-string)))

     (defgeneric match (re string))

     (defmethod match ((re string) string)
       (regexp:match re string))

     (defmethod match ((re compiled-regexp) string)
       (regexp:regexp-exec (compiled-regexp-value re) string))

     (regexp-compile "%d")
     --> #S(COMPILED-REGEXP :VALUE #<FOREIGN-POINTER #x0000000100E04160>)
     (match (regexp-compile "%d") "Hello %d World")
     --> #S(REGEXP:MATCH :START 6 :END 8)
     (match "%d" "Hello %d World")
     --> #S(REGEXP:MATCH :START 6 :END 8)

You could even make it more featureful:

     (defclass compiled-regexp ()
       ((source :initarg :source :reader compiled-regexp-source)
        (value  :initarg :value  :reader compiled-regexp-value)))

     (defmethod print-object ((self compiled-regexp) stream)
       (print-unreadable-object (self stream :type t :identity t)
         (format stream "/~A/" (compiled-regexp-source self)))
       self)

     (defun regexp-compile (re-string)
       (make-instance 'compiled-regexp
                      :source re-string
                      :value (regexp:regexp-compile re-string)))

     (regexp-compile "%d")
     --> #<COMPILED-REGEXP /%d/ #x0000000000121158>



-- 
__Pascal Bourguignon__

[clisp-list] POSIX Regexp question

[Dan S. <dan...@gm...>]

Hello All,
When executing (type-of (regexp:regexp-compile "%d")) FOREIGN-POINTER is
returned.
Is there a way to get the type of the pointer, so I can confirm that a
compiled regexp is pointed to, rather than something else?
Thank you,
Dan Stanger

[clisp-list] [Reminder CfP] ELS 2021, 14th European Lisp Symposium, May 3-4

[Didier V. <di...@lr...>]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                     14th European Lisp Symposium

                           Call for Papers

                         May 3 - May 4, 2021
                         Online / Everywhere

             http://www.european-lisp-symposium.org/2021

                   Sponsored by EPITA and RavenPack
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


Invited Speakers
~~~~~~~~~~~~~~~~
Nada Amin - Harvard SEAS
others tba


Important Dates
~~~~~~~~~~~~~~~
- Submission deadline: March 7, 2021
- Author notification: April 6, 2021
- Final papers due:    April 19, 2021
- Symposium:           May 3 - May 4, 2021


Scope
~~~~~

The European Lisp Symposium is a premier forum for the discussion and
dissemination of all aspects of design, implementation and application
of any of the Lisp dialects, including Common Lisp, Scheme, Emacs
Lisp, Clojure, Racket, ACL2, AutoLisp, ISLISP, Dylan, SKILL, Hy, Shen,
Carp, Janet, uLisp, Picolisp, Gamelisp, TXR, and so on. We encourage
everyone interested in Lisp to participate.

The European Lisp Symposium 2021 invites high quality papers about
novel research results, insights and lessons learned from practical
applications, and educational perspectives. We also encourage
submissions about known ideas as long as they are presented in a new
setting and/or in a highly elegant way.

Topics include but are not limited to:

- Context-, aspect-, domain-oriented and generative programming
- Macro-, reflective-, meta- and/or rule-based development approaches
- Language design and implementation
- Language integration, inter-operation and deployment
- Development methodologies, support and environments
- Educational approaches and perspectives
- Experience reports and case studies


Technical Program
~~~~~~~~~~~~~~~~~
We invite submissions in the following forms:

* Papers: Technical papers of up to 8 pages that describe original
  results or explain known ideas in new and elegant ways.

* Demonstrations: Abstracts of up to 4 pages for demonstrations of
  tools, libraries, and applications.

* Tutorials: Abstracts of up to 4 pages for in-depth presentations
  about topics of special interest for at least 90 minutes and up to
  180 minutes.

All submissions should be formatted following the ACM SIGS guidelines
and include ACM Computing Classification System 2012 concepts and
terms. Submissions should be uploaded to Easy Chair, at the following
http://www.easychair.org/conferences/?conf=els2021

Note: to help us with the review process please indicate the type of
submission by entering either "paper", "demo", or "tutorial" in the
Keywords field.


Programme Chair
~~~~~~~~~~~~~~~
Marco Heisig - FAU Erlangen-Nürnberg, Germany

Local Chairs
~~~~~~~~~~~~
Michał Herda
Mark Evenson - RavenPack

Programme Committee
~~~~~~~~~~~~~~~~~~~
Ioanna Dimitriou - Igalia
Irène Durand - LaBRI University of Bordeaux
R. Matthew Emerson - thoughtstuff LLC
Matthew Flatt - University of Utah
Jonathan Godbout - Google
Paulo Matos - Linki Tools
David McClain - SpectroDynamics, LLC
Stefan Monnier - University of Montreal
Jim Newton - EPITA Research Lab
Kent Pitman - HyperMeta Inc.
Christophe Rhodes - Google
Kai Selgrad - OTH Regensburg
Olin Shivers - Northeastern University
Robert Smith - Rigetti Quantum Computing
Michael Sperber - DeinProgramm
Evrim Ulu - Middle East Technical University
Breanndán Ó Nualláin - Machine Learning Programs

-- 
Lisp, Jazz, Aïkido: http://www.didierverna.info

Re: [clisp-list] Reader problem in REP loop on Windows.

[Christoph K. <ku...@ph...>]

> Am 14.02.2021 um 21:57 schrieb Cyril Alberga <Cy...@al...>:
> 
> I am starting clisp with the short-cut command:
> 
> "C:\Program Files (x86)\clisp-2.49\MyLisp.exe" -K full -I -M MyLisp.mem  -ansi -E ISO-8859-1
> 
> The character § (hex a7) cannot be entered.  Clisp will read and print it from/to files, but
> if it is typed (using Windows US-International keyboard) all of the text on the line before it is
> erased and the cursor shifts back to to the start.
> 
> There are no problems enterring the character in text editors, nor in the Windows command window.
> 
> What do I have set incorrectly?
> 
Just a shot in the dark, but recently I had a problem with non-ascii characters (> 127) and I solved it using  the following 
command ine:

clisp -B /opt/local/lib/clisp-2.49.92  -Efile WINDOWS-1252 -M  /opt/local/lib/clisp-2.49.92/base/lispinit.mem myfile.lisp

—
Christoph

[clisp-list] Reader problem in REP loop on Windows.

[Cyril A. <Cy...@al...>]

I am starting clisp with the short-cut command:

"C:\Program Files (x86)\clisp-2.49\MyLisp.exe" -K full -I -M MyLisp.mem  -ansi -E ISO-8859-1

The character § (hex a7) cannot be entered.  Clisp will read and print it from/to files, but
if it is typed (using Windows US-International keyboard) all of the text on the line before it is
erased and the cursor shifts back to to the start.

There are no problems enterring the character in text editors, nor in the Windows command window.

What do I have set incorrectly?

[clisp-list] [CfP] ELS'21, 14th European Lisp Symposium, online, May 3-4 2021

[Didier V. <di...@lr...>]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

                     14th European Lisp Symposium

                           Call for Papers

                         May 3 - May 4, 2021
                         Online / Everywhere

             http://www.european-lisp-symposium.org/2021

                   Sponsored by EPITA and RavenPack
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~


Invited Speakers
~~~~~~~~~~~~~~~~
tba


Important Dates
~~~~~~~~~~~~~~~
- Submission deadline: March 7, 2021
- Author notification: April 6, 2021
- Final papers due:    April 19, 2021
- Symposium:           May 3 - May 4, 2021


Scope
~~~~~

The European Lisp Symposium is a premier forum for the discussion and
dissemination of all aspects of design, implementation and application
of any of the Lisp dialects, including Common Lisp, Scheme, Emacs
Lisp, Clojure, Racket, ACL2, AutoLisp, ISLISP, Dylan, SKILL, Hy, Shen,
Carp, Janet, uLisp, Picolisp, Gamelisp, TXR, and so on. We encourage
everyone interested in Lisp to participate.

The European Lisp Symposium 2021 invites high quality papers about
novel research results, insights and lessons learned from practical
applications, and educational perspectives. We also encourage
submissions about known ideas as long as they are presented in a new
setting and/or in a highly elegant way.

Topics include but are not limited to:

- Context-, aspect-, domain-oriented and generative programming
- Macro-, reflective-, meta- and/or rule-based development approaches
- Language design and implementation
- Language integration, inter-operation and deployment
- Development methodologies, support and environments
- Educational approaches and perspectives
- Experience reports and case studies


Technical Program
~~~~~~~~~~~~~~~~~
We invite submissions in the following forms:

* Papers: Technical papers of up to 8 pages that describe original
  results or explain known ideas in new and elegant ways.

* Demonstrations: Abstracts of up to 4 pages for demonstrations of
  tools, libraries, and applications.

* Tutorials: Abstracts of up to 4 pages for in-depth presentations
  about topics of special interest for at least 90 minutes and up to
  180 minutes.

All submissions should be formatted following the ACM SIGS guidelines
and include ACM Computing Classification System 2012 concepts and
terms. Submissions should be uploaded to Easy Chair, at the following
http://www.easychair.org/conferences/?conf=els2021

Note: to help us with the review process please indicate the type of
submission by entering either "paper", "demo", or "tutorial" in the
Keywords field.


Programme Chair
~~~~~~~~~~~~~~~
Marco Heisig - FAU Erlangen-Nürnberg, Germany

Local Chairs
~~~~~~~~~~~~
Michał Herda
Mark Evenson - RavenPack

Programme Committee
~~~~~~~~~~~~~~~~~~~
tba


-- 
Didier Verna

[clisp-list] [solved]: Re: string too long: desired length 6553600 exceeds the supported maximum length

[Jean L. <bu...@gn...>]

* Pascal Bourguignon <pj...@in...> [2020-12-23 05:13]:
> 
> Le 22/12/2020 à 19:21, Jean Louis a écrit :
> > I am getting this error:
> > 
> > *** - string too long: desired length 6553600
> >        exceeds the supported maximum length
> > 
> > as I have 96532 database entries where I am constructing something
> > like:
> > 
> > (defun cf-interactions-total-for-people (people)
> >    "For list of PEOPLE calculate the total of interactions"
> >    (let* ((or-clause (mapcar (lambda (id) (format nil "interactions_contacts = ~A" id)) people))
> > 	 (or-clause (format nil "~{~A~^ OR ~}" or-clause))
> > 	 (sql (format nil "SELECT sum(interactions_count) FROM interactions WHERE ~A" or-clause))
> > 	 (sum (car (rcd-sql-first sql))))
> >      sum))
> > 
> > and "interactions_contacts = ~A or interactions_contacts = ~A" is
> > repeated so many times.
> > 
> > How can I increase that limit?
> 
> 
> The limit for strings is the same as for other arrays:
> array-total-size-limit (it's a constant variable).
> 
> Note that if you want to write a conforming CL program, you cannot count on
> that limit to be bigger than 1024.
> 
> Put those people IDs in a table, and use SQL!
> 
> "select sum(interaction_count) from interactions,contact_people where
> interactions_contacts=contact_people.id"
> 
> Note how this SQL request is less than 1024 characters long.

Thank you Pascal.

If it is constant I have to accommodate programs.

For the SQL I did not get fully how you mean it. What I made is I have
shortened a string by avoiding "interactions_contacts = 1 OR
interactions_contacts = 2" construct for almost 100,000+ times and
replaced it with the Postgresql clause:

WHERE 1 IN (1, 2, 3, 4... 100,000 times) which made it shorter and I
could just guess it could make it to work with even 200,000 people at
once or more until I have to find better solution.

;; Following function may solve about 100,000 people at once
(defun cf-interactions-total-for-people (people)
  "For list of PEOPLE calculate the total of interactions"
  (let* ((list (format nil "~{~A~^, ~}" people))
	 (sql (format nil "SELECT sum(interactions_count) FROM interactions WHERE interactions_contacts IN (~A)" list))
	 (sum (car (rcd-sql-first sql))))
    sum))

In general the list of people is list of their IDs and there are
interactions in the SQL table interactions like emails sent, mailings
sent, SMS sent, and so on, and the sum of it pin points specific
people as well established relations to be contacted again.

Jean

Re: [clisp-list] string too long: desired length 6553600 exceeds the supported maximum length

[Pascal B. <pj...@in...>]

Le 22/12/2020 à 19:21, Jean Louis a écrit :
> I am getting this error:
>
> *** - string too long: desired length 6553600
>        exceeds the supported maximum length
>
> as I have 96532 database entries where I am constructing something
> like:
>
> (defun cf-interactions-total-for-people (people)
>    "For list of PEOPLE calculate the total of interactions"
>    (let* ((or-clause (mapcar (lambda (id) (format nil "interactions_contacts = ~A" id)) people))
> 	 (or-clause (format nil "~{~A~^ OR ~}" or-clause))
> 	 (sql (format nil "SELECT sum(interactions_count) FROM interactions WHERE ~A" or-clause))
> 	 (sum (car (rcd-sql-first sql))))
>      sum))
>
> and "interactions_contacts = ~A or interactions_contacts = ~A" is
> repeated so many times.
>
> How can I increase that limit?


The limit for strings is the same as for other arrays: 
array-total-size-limit (it's a constant variable).

Note that if you want to write a conforming CL program, you cannot count 
on that limit to be bigger than 1024.

Put those people IDs in a table, and use SQL!

"select sum(interaction_count) from interactions,contact_people where 
interactions_contacts=contact_people.id"

Note how this SQL request is less than 1024 characters long.



-- 
__Pascal Bourguignon__

[clisp-list] string too long: desired length 6553600 exceeds the supported maximum length

[Jean L. <bu...@gn...>]

I am getting this error:

*** - string too long: desired length 6553600
      exceeds the supported maximum length

as I have 96532 database entries where I am constructing something
like:

(defun cf-interactions-total-for-people (people)
  "For list of PEOPLE calculate the total of interactions"
  (let* ((or-clause (mapcar (lambda (id) (format nil "interactions_contacts = ~A" id)) people))
	 (or-clause (format nil "~{~A~^ OR ~}" or-clause))
	 (sql (format nil "SELECT sum(interactions_count) FROM interactions WHERE ~A" or-clause))
	 (sum (car (rcd-sql-first sql))))
    sum))

and "interactions_contacts = ~A or interactions_contacts = ~A" is
repeated so many times.

How can I increase that limit?

Jean

[clisp-list] ./clisp-link: line 97: 30408 Segmentation fault "$@"

[Jean L. <bu...@gn...>]

I have done git pull on latest yesterday and I see I get this
error. Please help me compile it or understand what is to be done.

Jean

gcc -g -O2 -no-integrated-cpp -W -Wswitch -Wcomment -Wpointer-arith -Wreturn-type -Wmissing-declarations -Wimplicit -Wno-sign-compare -Wno-format-nonliteral -Wno-shift-negative-value -O -fwrapv -pthread -fno-strict-aliasing -DNO_ASM -DNO_ARI_ASM -DNO_SP_ASM -DNO_FAST_DISPATCH -DNO_FAST_FLOAT -DNO_FAST_DOUBLE -DNO_ALLOCA -DNO_ADDRESS_SPACE_ASSUMPTIONS -DNO_GENERATIONAL_GC -DNO_SYMBOLFLAGS -DENABLE_UNICODE -DMULTITHREAD -DPOSIX_THREADS -DDYNAMIC_FFI -DDYNAMIC_MODULES -fPIC -DPIC -Wl,--export-dynamic modules.o readline.o -lreadline -lncurses regexi.o calls.o -lm -lcrypt gettext.o lisp.a libgnu.a -lreadline -lncurses -ldl -lffcall -lsigsegv -lunistring -o lisp.run
boot/lisp.run -B . -M boot/lispinit.mem -norc -q -i i18n/preload.lisp -i syscalls/preload.lisp -i regexp/preload.lisp -x (saveinitmem "base/lispinit.mem")
;; Loading file i18n/preload.lisp ...
;; Loaded file i18n/preload.lisp
;; Loading file syscalls/preload.lisp ...
;; Loaded file syscalls/preload.lisp
;; Loading file regexp/preload.lisp ...
;; Loaded file regexp/preload.lisp
;; Wrote the memory image into base/lispinit.mem (3,403,824 bytes)
Bytes permanently allocated:            192,480
Bytes currently in use:               3,200,920
Bytes available until next GC:           75,080
3200920 ;
75080 ;
192480 ;
2 ;
245928 ;
20000
base/lisp.run -B . -M base/lispinit.mem -norc -q -i i18n/i18n -i syscalls/posix -i regexp/regexp -i readline/readline -x (saveinitmem "base/lispinit.mem")
./clisp-link: line 97: 30408 Segmentation fault      "$@"
./clisp-link: failed in /home/data1/protected/hyperscope/3/5/1/4/8/clisp/build-2020-12-21-00:59:40-Monday
make: *** [Makefile:2420: base] Error 1

Re: [clisp-list] clisp.cons.org down

[Fred C. <fc...@al...>]

I just tried it and it worked for me.


  - If you don't want our emails any more, reply and say so-
  -This is confidential to the parties I intend it to serve-
  Fred Cohen - 831-200-4006 - All.Net & Affiliated Companies
  http://all.net/ PO Box 811 Pebble Beach, CA 93953

On Sun, Dec 20, 2020, 14:29 Pascal Bourguignon <pj...@in...>
wrote:

> Hi
>
> the http server for clisp is down.
>
> eg. https://clisp.sourceforge.io/clash.html gives:
>
> An error has been encountered in accessing this page.
>
> 1. Server: clisp.sourceforge.io
> 2. URL path: /clash.html
> 3. Error notes: Server unable to read htaccess file, denying access to
> be safe
> 4. Error type: 403
> 5. Request method: GET
> 6. Request query string: NONE
> 7. Time: 2020-12-20 18:08:54 UTC (1608487734)
>
> Reporting this problem: The problem you have encountered is with a
> project web site hosted by SourceForge.net. This issue should be
> reported to the SourceForge.net-hosted project (not to SourceForge.net).
>
> If this is a severe or recurring/persistent problem, please do one of
> the following, and provide the error text (numbered 1 through 7, above):
>
>  1. Contact the project via their designated support resources
>     <
> https://sourceforge.net/support/prweb-lookup.php?host=clisp.sourceforge.io&support=1
> >.
>  2. Contact the project administrators of this project via email (see
>     the upper right-hand corner of the Project Summary page
>     <
> https://sourceforge.net/support/prweb-lookup.php?host=clisp.sourceforge.io
> > for
>     their usernames) at use...@us...
>
> If you are a maintainer of this web content, please refer to the Site
> Documentation regarding web services
> <https://sourceforge.net/p/forge/documentation/Project%20Web%20Services/> for
>
> further assistance.
>
> NOTE: As of 2008-10-23 directory index display has been disabled by
> default. This option may be re-enabled by the project by placing a file
> with the name ".htaccess" with this line:
>
> Options +Indexes
>
> http://clisp.org gives:
>
>
>   503 Service Unavailable
>
> No server is available to handle this request.
>
>
> etc.
>
> -- __Pascal Bourguignon__
>
>
> _______________________________________________
> clisp-list mailing list
> cli...@li...
> https://lists.sourceforge.net/lists/listinfo/clisp-list
>

[clisp-list] clisp.cons.org down

[Pascal B. <pj...@in...>]

Hi

the http server for clisp is down.

eg. https://clisp.sourceforge.io/clash.html gives:

An error has been encountered in accessing this page.

1. Server: clisp.sourceforge.io
2. URL path: /clash.html
3. Error notes: Server unable to read htaccess file, denying access to 
be safe
4. Error type: 403
5. Request method: GET
6. Request query string: NONE
7. Time: 2020-12-20 18:08:54 UTC (1608487734)

Reporting this problem: The problem you have encountered is with a 
project web site hosted by SourceForge.net. This issue should be 
reported to the SourceForge.net-hosted project (not to SourceForge.net).

If this is a severe or recurring/persistent problem, please do one of 
the following, and provide the error text (numbered 1 through 7, above):

 1. Contact the project via their designated support resources
    <https://sourceforge.net/support/prweb-lookup.php?host=clisp.sourceforge.io&support=1>.
 2. Contact the project administrators of this project via email (see
    the upper right-hand corner of the Project Summary page
    <https://sourceforge.net/support/prweb-lookup.php?host=clisp.sourceforge.io> for
    their usernames) at use...@us...

If you are a maintainer of this web content, please refer to the Site 
Documentation regarding web services 
<https://sourceforge.net/p/forge/documentation/Project%20Web%20Services/> for 
further assistance.

NOTE: As of 2008-10-23 directory index display has been disabled by 
default. This option may be re-enabled by the project by placing a file 
with the name ".htaccess" with this line:

Options +Indexes

http://clisp.org gives:


  503 Service Unavailable

No server is available to handle this request.


etc.

-- __Pascal Bourguignon__

Re: [clisp-list] Broken link to ANSI Std

[Nemo N. <cy...@gm...>]

On 11/17/20 02:55, Christoph Kukulies wrote:
> Don’t know who takes care of this and if it lies in the responsibility of anyone in this list but I wanted to invoke
>
> ANSI Common Lisp standard X3.226-1994 <http://www.x3.org/tc_home/j13sd4.htm>
>
> but the link is broken. (page is https://courses.cs.washington.edu/courses/cse415/03wi/clisp_doc/clisp.html#reference <https://courses.cs.washington.edu/courses/cse415/03wi/clisp_doc/clisp.html#reference>)
>
> Christoph Kukulies

Oh my, X3 has been overhauled substantially.  Is this what you want? 
https://standards.incits.org/apps/group_public/project/details.php?project_id=1012

N.

Re: [clisp-list] Broken link to ANSI Std

[edgar <edg...@we...>]

Am Tue, 17 Nov 2020 08:55:29 +0100
schrieb Christoph Kukulies <ku...@ph...>:

> Don’t know who takes care of this and if it lies in the
> responsibility of anyone in this list but I wanted to invoke
> 
> ANSI Common Lisp standard X3.226-1994
> <http://www.x3.org/tc_home/j13sd4.htm>
> 
> but the link is broken. (page is
> https://courses.cs.washington.edu/courses/cse415/03wi/clisp_doc/clisp.html#reference
> <https://courses.cs.washington.edu/courses/cse415/03wi/clisp_doc/clisp.html#reference>)
> 
> Christoph Kukulies

Unfortunately I have no idea who the maintainer of said website
above is, but it's an archived website from 2003 with obviously
outdated information. 

The current AI courses from washington.edu are here:
-> https://courses.cs.washington.edu/courses/cse415/

The current CLISP docs can be found here:
-> https://www.gnu.org/software/clisp/

Hope that helps at least a bit :-)

-edgar

[clisp-list] Broken link to ANSI Std

[Christoph K. <ku...@ph...>]

Don’t know who takes care of this and if it lies in the responsibility of anyone in this list but I wanted to invoke

ANSI Common Lisp standard X3.226-1994 <http://www.x3.org/tc_home/j13sd4.htm>

but the link is broken. (page is https://courses.cs.washington.edu/courses/cse415/03wi/clisp_doc/clisp.html#reference <https://courses.cs.washington.edu/courses/cse415/03wi/clisp_doc/clisp.html#reference>)

Christoph Kukulies