unofficial mirror of guile-devel@gnu.org 
 help / color / mirror / Atom feed
* [Patch] definitions in when,  unless,  do as well as in cond- and case-clauses
@ 2021-06-16 19:11 Linus Björnstam
  2021-06-17  9:06 ` Maxime Devos
  2022-02-03 10:48 ` Linus Björnstam
  0 siblings, 2 replies; 24+ messages in thread
From: Linus Björnstam @ 2021-06-16 19:11 UTC (permalink / raw)
  To: guile-devel

[-- Attachment #1: Type: text/plain, Size: 1056 bytes --]

Hi there!

This patch updates some derived conditional forms (and do and and-let*) to support definitions in expression context. Meaning it makes this valid code:

(cond 
  ((pred? arg) 
    (define a (something arg))
    (when (error-case a)
      (error "a is broken"))
    (define b (something2 a))
    (when  (= 3 *log-level*)
      (display "logging something1 and 2 as successful"))
    (define c (something3 b a))
    (when (odd? c)
       (error "something went wrong in something3"))
    c)
  (else 
    ;;chosen by fair dice roll. Guaranteed to be random
    4)))

While awful, is sometimes what the world makes us do. 

The change means cond, case, when and unless behaves like it does in racket. Do was below case, so I changed that as well, and will actually become yet another way guile is superior to racket. 

I did also change the documentation, but I learned english by watching Beverly Hills cop, so that might need some fine touches by a capable english speaker.
            

Best regards
  Linus Björnstam

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-Allow-definitions-in-derived-conditional-forms.patch --]
[-- Type: text/x-patch; name="0001-Allow-definitions-in-derived-conditional-forms.patch", Size: 4916 bytes --]

From 7af96162bf531b70e66170864cd536032b1c89c7 Mon Sep 17 00:00:00 2001
From: Linus <bjornstam.linus@fastmail.se>
Date: Wed, 16 Jun 2021 20:47:41 +0200
Subject: [PATCH] Allow definitions in derived conditional forms

This allows definitions in the bodies of when, unless, do, and
 and-let*. It also adds support for definitions in cond- and
case-clauses.

 * doc/ref/api-control.texi (when, unless, cond, case): update
   documentation to reflect changes.
 * module/ice-9/and-let-star.scm: Changed (begin ...) to (let () ...)
 * module/ice-9/boot-9.scm (when, unless, cond, case, do): changed
   (begin ...) to (let () ...)
---
 doc/ref/api-control.texi      | 10 +++++-----
 module/ice-9/and-let-star.scm |  6 +++---
 module/ice-9/boot-9.scm       | 12 ++++++------
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/doc/ref/api-control.texi b/doc/ref/api-control.texi
index 5df5344c5..eaa2b4dbf 100644
--- a/doc/ref/api-control.texi
+++ b/doc/ref/api-control.texi
@@ -152,10 +152,10 @@ documentation:
 
 @example
 (define-syntax-rule (when test stmt stmt* ...)
-  (if test (begin stmt stmt* ...)))
+  (if test (let () stmt stmt* ...)))
 
 (define-syntax-rule (unless condition stmt stmt* ...)
-  (if (not test) (begin stmt stmt* ...)))
+  (if (not test) (let () stmt stmt* ...)))
 @end example
 
 That is to say, @code{when} evaluates its consequent statements in order
@@ -167,11 +167,11 @@ statements if @var{test} is false.
 Each @code{cond}-clause must look like this:
 
 @lisp
-(@var{test} @var{expression} @dots{})
+(@var{test} @var{expression-or-definition} @dots{})
 @end lisp
 
-where @var{test} and @var{expression} are arbitrary expressions, or like
-this
+where @var{test} is an arbitrary expression, and @var{expression-or-definition}
+is an arbitrary expression or a definition, like @code{define}.
 
 @lisp
 (@var{test} => @var{expression})
diff --git a/module/ice-9/and-let-star.scm b/module/ice-9/and-let-star.scm
index 2d53ff384..9427c1733 100644
--- a/module/ice-9/and-let-star.scm
+++ b/module/ice-9/and-let-star.scm
@@ -53,12 +53,12 @@
       ((_ orig-form ((var expr)) . body)
        (identifier? #'var)
        #'(let ((var expr))
-           (and var (begin . body))))
+           (and var (let () . body))))
       ((_ orig-form ((expr)) . body)
-       #'(and expr (begin . body)))
+       #'(and expr (let () . body)))
       ((_ orig-form (var) . body)
        (identifier? #'var)
-       #'(and var (begin . body)))
+       #'(and var (let () . body)))
 
       ;; Handle bad clauses.
       ((_ orig-form (bad-clause . rest) . body)
diff --git a/module/ice-9/boot-9.scm b/module/ice-9/boot-9.scm
index 2323b1ec5..675f38633 100644
--- a/module/ice-9/boot-9.scm
+++ b/module/ice-9/boot-9.scm
@@ -417,10 +417,10 @@ If returning early, return the return value of F."
 (include-from-path "ice-9/quasisyntax")
 
 (define-syntax-rule (when test stmt stmt* ...)
-  (if test (begin stmt stmt* ...)))
+  (if test (let () stmt stmt* ...)))
 
 (define-syntax-rule (unless test stmt stmt* ...)
-  (if (not test) (begin stmt stmt* ...)))
+  (if (not test) (let () stmt stmt* ...)))
 
 (define-syntax else
   (lambda (x)
@@ -461,7 +461,7 @@ If returning early, return the return value of F."
                          ((else e e* ...)
                           (lambda (tail)
                             (if (null? tail)
-                                #'((begin e e* ...))
+                                #'((let () e e* ...))
                                 (bad-clause "else must be the last clause"))))
                          ((else . _) (bad-clause))
                          ((test => receiver)
@@ -488,7 +488,7 @@ If returning early, return the return value of F."
                          ((test e e* ...)
                           (lambda (tail)
                             #`((if test
-                                   (begin e e* ...)
+                                   (let () e e* ...)
                                    #,@tail))))
                          (_ (bad-clause))))
                      #'(clause clauses ...))))))))
@@ -534,7 +534,7 @@ If returning early, return the return value of F."
                                ((=> receiver ...)
                                 (bad-clause
                                  "wrong number of receiver expressions"))
-                               ((e e* ...) #'(begin e e* ...))
+                               ((e e* ...) #'(let () e e* ...))
                                (_ (bad-clause)))))
                          (syntax-case #'test (else)
                            ((datums ...)
@@ -585,7 +585,7 @@ If returning early, return the return value of F."
                (begin
                  (if #f #f)
                  expr ...)
-               (begin
+               (let ()
                  command
                  ...
                  (loop (do "step" var step ...)
-- 
2.25.1


^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: [Patch] definitions in when,  unless,  do as well as in cond- and case-clauses
  2021-06-16 19:11 [Patch] definitions in when, unless, do as well as in cond- and case-clauses Linus Björnstam
@ 2021-06-17  9:06 ` Maxime Devos
  2021-06-17 12:57   ` Linus Björnstam
  2022-02-03 10:48 ` Linus Björnstam
  1 sibling, 1 reply; 24+ messages in thread
From: Maxime Devos @ 2021-06-17  9:06 UTC (permalink / raw)
  To: Linus Björnstam, guile-devel

[-- Attachment #1: Type: text/plain, Size: 1134 bytes --]

Linus Björnstam schreef op wo 16-06-2021 om 21:11 [+0200]:
> Hi there!
> 
> This patch updates some derived conditional forms (and do and and-let*)
> to support definitions in expression context. Meaning it makes this valid code:
> 
> (cond 
>   ((pred? arg) 
>     (define a (something arg))
>     (when (error-case a)
>       (error "a is broken"))  [...]

This seems a useful change to me. However, this is not valid R6RS.
From <http://www.r6rs.org/final/r6rs.pdf>:

(cond hcond clause1i hcond clause2i . . . ) syntax
=> auxiliary syntax
else auxiliary syntax
Syntax: Each hcond clausei must be of the form
(htesti hexpression1i . . . )
where htesti is an expression. Alternatively, a
hcond clausei may be of the form
(htesti => hexpressioni)

This seems a compatibility pitfall, so maybe note
in the documentation that using definitions in the clauses
is a Guile and Racket extension and not standard R6RS?

(I try to write Scheme code as R6RS / R7RS library & define-library
forms, importing mostly R6RS / R7RS & SRFI libraries, though I occasionally
use a Guile extension.)

Greetings,
Maxime

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: [Patch] definitions in when,   unless,   do as well as in cond- and case-clauses
  2021-06-17  9:06 ` Maxime Devos
@ 2021-06-17 12:57   ` Linus Björnstam
  2021-06-17 13:54     ` Maxime Devos
  0 siblings, 1 reply; 24+ messages in thread
From: Linus Björnstam @ 2021-06-17 12:57 UTC (permalink / raw)
  To: Maxime Devos, guile-devel

Guile already does definitions in expression context in the bodies of lambda and let-variants. I think this is not a big problem since any valid r6rs code is still valid guile.

The discussion is in my opinion whether guile's r6rs modules should enforce this behaviour. That might be a good thing, even though we will provide 2 cons and case forms to do that.

-- 
  Linus Björnstam

On Thu, 17 Jun 2021, at 11:06, Maxime Devos wrote:
> Linus Björnstam schreef op wo 16-06-2021 om 21:11 [+0200]:
> > Hi there!
> > 
> > This patch updates some derived conditional forms (and do and and-let*)
> > to support definitions in expression context. Meaning it makes this valid code:
> > 
> > (cond 
> >   ((pred? arg) 
> >     (define a (something arg))
> >     (when (error-case a)
> >       (error "a is broken"))  [...]
> 
> This seems a useful change to me. However, this is not valid R6RS.
> From <http://www.r6rs.org/final/r6rs.pdf>:
> 
> (cond hcond clause1i hcond clause2i . . . ) syntax
> => auxiliary syntax
> else auxiliary syntax
> Syntax: Each hcond clausei must be of the form
> (htesti hexpression1i . . . )
> where htesti is an expression. Alternatively, a
> hcond clausei may be of the form
> (htesti => hexpressioni)
> 
> This seems a compatibility pitfall, so maybe note
> in the documentation that using definitions in the clauses
> is a Guile and Racket extension and not standard R6RS?
> 
> (I try to write Scheme code as R6RS / R7RS library & define-library
> forms, importing mostly R6RS / R7RS & SRFI libraries, though I occasionally
> use a Guile extension.)
> 
> Greetings,
> Maxime
> 
> Attachments:
> * signature.asc



^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: [Patch] definitions in when,  unless,  do as well as in cond- and case-clauses
  2021-06-17 12:57   ` Linus Björnstam
@ 2021-06-17 13:54     ` Maxime Devos
  0 siblings, 0 replies; 24+ messages in thread
From: Maxime Devos @ 2021-06-17 13:54 UTC (permalink / raw)
  To: Linus Björnstam, guile-devel

[-- Attachment #1: Type: text/plain, Size: 999 bytes --]

Linus Björnstam schreef op do 17-06-2021 om 14:57 [+0200]:
> Guile already does definitions in expression context in
> the bodies of lambda and let-variants. I think this is
> not a big problem since any valid r6rs code is still valid guile.

‘Guile already does definitions in expression context in [...]’:
good point.

> The discussion is in my opinion whether guile's r6rs modules should
> enforce this behaviour. That might be a good thing, even though we
> will provide 2 cons and case forms to do that.

Pro: if your code works when using r6rs modules (in Guile), then it should
work on any r6rs-conforming implementation.

Con: (@ (guile) cond) != (@ (rnrs base) cond), which can be surprising.

Con: ‘I know this usage isn't universally portable, but I'll cross that
bridge when needed. All the Scheme I care about do have this extension.
If a Scheme doesn't have this extension, I'll just patch that Scheme
(free software for the win!)’

Greetings,
Maxime.

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2021-06-16 19:11 [Patch] definitions in when, unless, do as well as in cond- and case-clauses Linus Björnstam
  2021-06-17  9:06 ` Maxime Devos
@ 2022-02-03 10:48 ` Linus Björnstam
       [not found]   ` <CAGua6m1Cqe=aLOD7-jfzoqxP1aOxvWn3=UgcKyk+Dx7_51Bq3w@mail.gmail.com>
  1 sibling, 1 reply; 24+ messages in thread
From: Linus Björnstam @ 2022-02-03 10:48 UTC (permalink / raw)
  To: guile-devel

Hi guys,

It looks like a 3.0.8 might be happening. I am curious to know whether this (perhaps minus the do form) is considered something that the maintainers of guile could find interesting. 

If subset compatibility of r6|7rs is desired, I could provide a patch for those files as well so that they enforce the distinction between definition and expression context.

I myself find this a worthwhile patch since it has no drawbacks. a (let () ...) without definitions does not start a new lexical context and runs as fast as a begin, so there should be no performance regressions.

It also removes the last bodies in guile forms that have a definition context, which may be confusing for beginners.

I would say that the compatibility question with the enforcing cond of rnrs is the only thing that needs proper addressing.

Best
  Linus Björnstam

On Wed, 16 Jun 2021, at 21:11, Linus Björnstam wrote:
> Hi there!
>
> This patch updates some derived conditional forms (and do and and-let*) 
> to support definitions in expression context. Meaning it makes this 
> valid code:
>
> (cond 
>   ((pred? arg) 
>     (define a (something arg))
>     (when (error-case a)
>       (error "a is broken"))
>     (define b (something2 a))
>     (when  (= 3 *log-level*)
>       (display "logging something1 and 2 as successful"))
>     (define c (something3 b a))
>     (when (odd? c)
>        (error "something went wrong in something3"))
>     c)
>   (else 
>     ;;chosen by fair dice roll. Guaranteed to be random
>     4)))
>
> While awful, is sometimes what the world makes us do. 
>
> The change means cond, case, when and unless behaves like it does in 
> racket. Do was below case, so I changed that as well, and will actually 
> become yet another way guile is superior to racket. 
>
> I did also change the documentation, but I learned english by watching 
> Beverly Hills cop, so that might need some fine touches by a capable 
> english speaker.
>            
>
> Best regards
>   Linus Björnstam
> Attachments:
> * 0001-Allow-definitions-in-derived-conditional-forms.patch



^ permalink raw reply	[flat|nested] 24+ messages in thread

* Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
       [not found]   ` <CAGua6m1Cqe=aLOD7-jfzoqxP1aOxvWn3=UgcKyk+Dx7_51Bq3w@mail.gmail.com>
@ 2022-02-04 20:11     ` Stefan Israelsson Tampe
  2022-02-04 20:58       ` Maxime Devos
  0 siblings, 1 reply; 24+ messages in thread
From: Stefan Israelsson Tampe @ 2022-02-04 20:11 UTC (permalink / raw)
  To: guile-devel

[-- Attachment #1: Type: text/plain, Size: 3085 bytes --]

---------- Forwarded message ---------
From: Stefan Israelsson Tampe <stefan.itampe@gmail.com>
Date: Thu, Feb 3, 2022 at 5:41 PM
Subject: Re: [Patch] definitions in when, unless, do as well as in cond-
and case-clauses
To: Linus Björnstam <linus.bjornstam@veryfast.biz>


using an implicit let in conditionals are bad in that you cannot
escape from the let form which means that you loos conditional defines for
example in the toplevel. e.g.

(if 1 (define a 1) (define a 2)) will not work at the top level because of
an implicit let. If you need implicit defines a simple macro for those are
easy and if we need to state a syntax in stone for those, we should name
them differently like when-let  unless-let if-let cond-let case-let.

On Thu, Feb 3, 2022 at 11:55 AM Linus Björnstam <
linus.bjornstam@veryfast.biz> wrote:

> Hi guys,
>
> It looks like a 3.0.8 might be happening. I am curious to know whether
> this (perhaps minus the do form) is considered something that the
> maintainers of guile could find interesting.
>
> If subset compatibility of r6|7rs is desired, I could provide a patch for
> those files as well so that they enforce the distinction between definition
> and expression context.
>
> I myself find this a worthwhile patch since it has no drawbacks. a (let ()
> ...) without definitions does not start a new lexical context and runs as
> fast as a begin, so there should be no performance regressions.
>
> It also removes the last bodies in guile forms that have a definition
> context, which may be confusing for beginners.
>
> I would say that the compatibility question with the enforcing cond of
> rnrs is the only thing that needs proper addressing.
>
> Best
>   Linus Björnstam
>
> On Wed, 16 Jun 2021, at 21:11, Linus Björnstam wrote:
> > Hi there!
> >
> > This patch updates some derived conditional forms (and do and and-let*)
> > to support definitions in expression context. Meaning it makes this
> > valid code:
> >
> > (cond
> >   ((pred? arg)
> >     (define a (something arg))
> >     (when (error-case a)
> >       (error "a is broken"))
> >     (define b (something2 a))
> >     (when  (= 3 *log-level*)
> >       (display "logging something1 and 2 as successful"))
> >     (define c (something3 b a))
> >     (when (odd? c)
> >        (error "something went wrong in something3"))
> >     c)
> >   (else
> >     ;;chosen by fair dice roll. Guaranteed to be random
> >     4)))
> >
> > While awful, is sometimes what the world makes us do.
> >
> > The change means cond, case, when and unless behaves like it does in
> > racket. Do was below case, so I changed that as well, and will actually
> > become yet another way guile is superior to racket.
> >
> > I did also change the documentation, but I learned english by watching
> > Beverly Hills cop, so that might need some fine touches by a capable
> > english speaker.
> >
> >
> > Best regards
> >   Linus Björnstam
> > Attachments:
> > * 0001-Allow-definitions-in-derived-conditional-forms.patch
>
>

[-- Attachment #2: Type: text/html, Size: 4010 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-04 20:11     ` Fwd: " Stefan Israelsson Tampe
@ 2022-02-04 20:58       ` Maxime Devos
       [not found]         ` <CAGua6m11r27x=rq4S4fF09vHY+S-Az7GOZfmoT41hEBDSkLJQg@mail.gmail.com>
  0 siblings, 1 reply; 24+ messages in thread
From: Maxime Devos @ 2022-02-04 20:58 UTC (permalink / raw)
  To: Stefan Israelsson Tampe, guile-devel

[-- Attachment #1: Type: text/plain, Size: 851 bytes --]

Stefan Israelsson Tampe schreef op vr 04-02-2022 om 21:11 [+0100]:
> using an implicit let in conditionals are bad in that you cannot
> escape from the let form which means that you loos
> conditional defines for example in the toplevel. e.g. [...]

While old versions of Guile (Guile 1.8?) did support conditional
defines on the top-level, new versions of Guile (Guile 2.0 and later)
don't:

(if #true
    (define x 'foo)
    (define x 'bar))

While compiling expression:
Syntax error:
unknown file:2:4: definition in expression context, where definitions
are not allowed, in form (define x (quote foo))

The following still works though of course:

(define x (if #true 'foo 'bar))

So for the current version of Guile (3.0.X), there don't appear to be
backwards-compatibility problems in this area.

Greetings,
Maxime.

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Fwd: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
       [not found]         ` <CAGua6m11r27x=rq4S4fF09vHY+S-Az7GOZfmoT41hEBDSkLJQg@mail.gmail.com>
@ 2022-02-04 21:40           ` Stefan Israelsson Tampe
  2022-02-04 23:39           ` Maxime Devos
  1 sibling, 0 replies; 24+ messages in thread
From: Stefan Israelsson Tampe @ 2022-02-04 21:40 UTC (permalink / raw)
  To: guile-devel

[-- Attachment #1: Type: text/plain, Size: 2088 bytes --]

---------- Forwarded message ---------
From: Stefan Israelsson Tampe <stefan.itampe@gmail.com>
Date: Fri, Feb 4, 2022 at 10:40 PM
Subject: Re: Fwd: [Patch] definitions in when, unless, do as well as in
cond- and case-clauses
To: Maxime Devos <maximedevos@telenet.be>


I tested and yes you are right, in guile conditionals do not have this
property and similarly,  all other directives I could find
does not work, but because scheme has macros this is not super important.
So then we should fix this to replace the definition
from,
(if p x y)

to

(if p (let () x) (let () y))

And then all other conditional, that is expressed as macros from if have
the correct a let binding if we want this. This change will
make new code non compilable by old guile's but that is not a huge issue,
just make a macro package that you introduce conditionally
to your project and recompile. The good thing is namely that issues will
brake at compile time and not through some mysterious
run time bug.

Anyhow conditional defining vars is a common theme in other languages so I
think it was kind of natural to implement if as it was done.



Regards
Stefan

On Fri, Feb 4, 2022 at 9:58 PM Maxime Devos <maximedevos@telenet.be> wrote:

> Stefan Israelsson Tampe schreef op vr 04-02-2022 om 21:11 [+0100]:
> > using an implicit let in conditionals are bad in that you cannot
> > escape from the let form which means that you loos
> > conditional defines for example in the toplevel. e.g. [...]
>
> While old versions of Guile (Guile 1.8?) did support conditional
> defines on the top-level, new versions of Guile (Guile 2.0 and later)
> don't:
>
> (if #true
>     (define x 'foo)
>     (define x 'bar))
>
> While compiling expression:
> Syntax error:
> unknown file:2:4: definition in expression context, where definitions
> are not allowed, in form (define x (quote foo))
>
> The following still works though of course:
>
> (define x (if #true 'foo 'bar))
>
> So for the current version of Guile (3.0.X), there don't appear to be
> backwards-compatibility problems in this area.
>
> Greetings,
> Maxime.
>

[-- Attachment #2: Type: text/html, Size: 3062 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
       [not found]         ` <CAGua6m11r27x=rq4S4fF09vHY+S-Az7GOZfmoT41hEBDSkLJQg@mail.gmail.com>
  2022-02-04 21:40           ` Fwd: " Stefan Israelsson Tampe
@ 2022-02-04 23:39           ` Maxime Devos
  2022-02-05  1:14             ` Stefan Israelsson Tampe
  1 sibling, 1 reply; 24+ messages in thread
From: Maxime Devos @ 2022-02-04 23:39 UTC (permalink / raw)
  To: Stefan Israelsson Tampe; +Cc: guile-devel

[-- Attachment #1: Type: text/plain, Size: 1410 bytes --]

Stefan Israelsson Tampe schreef op vr 04-02-2022 om 22:40 [+0100]:
> Anyhow conditional defining vars is a common theme in other languages
> so I think it was kind of natural to implement if as it was done.

AFAIK no Lisp or Scheme except for Guile < 2.0 implements conditionally
defining local variables (but then I usually only consider Guile Scheme
and the RnRS, so this doesn't mean much).  In my experience, I have
never seen a need for conditionally defining a local variable in Scheme
code (if you have a real-world example, please share).

It also seems impossible to implement this w.r.t. the macro system ---
what should, say, bound-identifier=? do when one of its identifiers is
only conditionally bound?  Or for another example:

If I do

(define foo 'bar)
(define-syntax foobar
  (syntax-rules (foo)
    ((_ foo)
     (begin (pk "it's a foo!") foo))
    ((_ goo)
     (begin (pk "it's not a foo ...") goo))))
   
(define (zebra stripes)
  (if stripes
      (define foo 'quux))
  (foobar foo)) ;; <--- ***

then sometimes the 'foo' in '***' refers to the global variable 'foo'
and hence 'foobar' expands to the "it's a foo'.'  Sometimes the 'foo'
in '***' refers to the local variable 'foo' (!= the global foo) hence
'foobar' expands to the "it's not a foo ...".

However, it's impossible for a macro to expand to multiple things at
once!

Greetings,
Maxime.

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-04 23:39           ` Maxime Devos
@ 2022-02-05  1:14             ` Stefan Israelsson Tampe
  2022-02-05 10:55               ` Maxime Devos
  0 siblings, 1 reply; 24+ messages in thread
From: Stefan Israelsson Tampe @ 2022-02-05  1:14 UTC (permalink / raw)
  To: Maxime Devos; +Cc: guile-devel

[-- Attachment #1: Type: text/plain, Size: 1655 bytes --]

For conditional variables you gave a default value. So then why on earth do
you not have an implicit let ?
There must be a good reason.

On Sat, Feb 5, 2022 at 12:39 AM Maxime Devos <maximedevos@telenet.be> wrote:

> Stefan Israelsson Tampe schreef op vr 04-02-2022 om 22:40 [+0100]:
> > Anyhow conditional defining vars is a common theme in other languages
> > so I think it was kind of natural to implement if as it was done.
>
> AFAIK no Lisp or Scheme except for Guile < 2.0 implements conditionally
> defining local variables (but then I usually only consider Guile Scheme
> and the RnRS, so this doesn't mean much).  In my experience, I have
> never seen a need for conditionally defining a local variable in Scheme
> code (if you have a real-world example, please share).
>
> It also seems impossible to implement this w.r.t. the macro system ---
> what should, say, bound-identifier=? do when one of its identifiers is
> only conditionally bound?  Or for another example:
>
> If I do
>
> (define foo 'bar)
> (define-syntax foobar
>   (syntax-rules (foo)
>     ((_ foo)
>      (begin (pk "it's a foo!") foo))
>     ((_ goo)
>      (begin (pk "it's not a foo ...") goo))))
>
> (define (zebra stripes)
>   (if stripes
>       (define foo 'quux))
>   (foobar foo)) ;; <--- ***
>
> then sometimes the 'foo' in '***' refers to the global variable 'foo'
> and hence 'foobar' expands to the "it's a foo'.'  Sometimes the 'foo'
> in '***' refers to the local variable 'foo' (!= the global foo) hence
> 'foobar' expands to the "it's not a foo ...".
>
> However, it's impossible for a macro to expand to multiple things at
> once!
>
> Greetings,
> Maxime.
>

[-- Attachment #2: Type: text/html, Size: 2241 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-05  1:14             ` Stefan Israelsson Tampe
@ 2022-02-05 10:55               ` Maxime Devos
  2022-02-05 17:31                 ` Stefan Israelsson Tampe
  0 siblings, 1 reply; 24+ messages in thread
From: Maxime Devos @ 2022-02-05 10:55 UTC (permalink / raw)
  To: Stefan Israelsson Tampe; +Cc: guile-devel

[-- Attachment #1: Type: text/plain, Size: 1430 bytes --]

Hi,

> > (define foo 'bar) ;; <--- ^^^
> > (define-syntax foobar
> >   (syntax-rules (foo)
> >     ((_ foo)
> >      (begin (pk "it's a foo!") foo))
> >     ((_ goo)
> >      (begin (pk "it's not a foo ...") goo))))
> > 
> > (define (zebra stripes)
> >   (if stripes
> >       (define foo 'quux)) ;;  <--- ###
> >   (foobar foo)) ;; <--- ***

Stefan Israelsson Tampe schreef op za 05-02-2022 om 02:14 [+0100]:
> For conditional variables you gave a default value.

I don't understand the question, I didn't give a default value?

The variable 'foo' (^^^) is a different variable from 'foo' (###)
since 'foo' (^^^) is a module variable, and 'foo' (###) is a local
variable in 'zebra'.  Merely having the same name does not imply
being the same variable, c.f. shadowing, so '^^^' does _not_ give
a default value to the 'foo' in '###'.

(If '###' was 'set!' instead of 'define', then the two variables would
have been the same.)

> So then why on earth do you not have an implicit let ?
> There must be a good reason.

I don't understand the question, there's an implicit 'let' here:
the definition of 'zebra'.  Also, I don't see what the question ‘why do
you not have an implicit let?’ has to do with ‘For conditional
variables you gave a default value.’.

Also, AFAICT these questions don't seem to have anything to do
with the macro system problems I noted?

Greetings,
Maxime.

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-05 10:55               ` Maxime Devos
@ 2022-02-05 17:31                 ` Stefan Israelsson Tampe
  2022-02-05 17:36                   ` Maxime Devos
  2022-02-06  6:44                   ` Linus Björnstam
  0 siblings, 2 replies; 24+ messages in thread
From: Stefan Israelsson Tampe @ 2022-02-05 17:31 UTC (permalink / raw)
  To: Maxime Devos; +Cc: guile-devel

[-- Attachment #1: Type: text/plain, Size: 1923 bytes --]

Hmm this was wrong, I mean

For conditional variables we have a default begin. So then why on earth do
you not have an implicit let?, Just laziness?
There should  be a good reason or? this is a pretty fundamental change that
I support but then we should not be lazy not trying to understand the
design choices of the old beards.

On Sat, Feb 5, 2022 at 11:55 AM Maxime Devos <maximedevos@telenet.be> wrote:

> Hi,
>
> > > (define foo 'bar) ;; <--- ^^^
> > > (define-syntax foobar
> > >   (syntax-rules (foo)
> > >     ((_ foo)
> > >      (begin (pk "it's a foo!") foo))
> > >     ((_ goo)
> > >      (begin (pk "it's not a foo ...") goo))))
> > >
> > > (define (zebra stripes)
> > >   (if stripes
> > >       (define foo 'quux)) ;;  <--- ###
> > >   (foobar foo)) ;; <--- ***
>
> Stefan Israelsson Tampe schreef op za 05-02-2022 om 02:14 [+0100]:
> > For conditional variables you gave a default value.
>
> I don't understand the question, I didn't give a default value?
>
> The variable 'foo' (^^^) is a different variable from 'foo' (###)
> since 'foo' (^^^) is a module variable, and 'foo' (###) is a local
> variable in 'zebra'.  Merely having the same name does not imply
> being the same variable, c.f. shadowing, so '^^^' does _not_ give
> a default value to the 'foo' in '###'.
>
> (If '###' was 'set!' instead of 'define', then the two variables would
> have been the same.)
>
> > So then why on earth do you not have an implicit let ?
> > There must be a good reason.
>
> I don't understand the question, there's an implicit 'let' here:
> the definition of 'zebra'.  Also, I don't see what the question ‘why do
> you not have an implicit let?’ has to do with ‘For conditional
> variables you gave a default value.’.
>
> Also, AFAICT these questions don't seem to have anything to do
> with the macro system problems I noted?
>
> Greetings,
> Maxime.
>

[-- Attachment #2: Type: text/html, Size: 2604 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-05 17:31                 ` Stefan Israelsson Tampe
@ 2022-02-05 17:36                   ` Maxime Devos
  2022-02-06  6:44                   ` Linus Björnstam
  1 sibling, 0 replies; 24+ messages in thread
From: Maxime Devos @ 2022-02-05 17:36 UTC (permalink / raw)
  To: Stefan Israelsson Tampe; +Cc: guile-devel

[-- Attachment #1: Type: text/plain, Size: 887 bytes --]

Stefan Israelsson Tampe schreef op za 05-02-2022 om 18:31 [+0100]:
> Hmm this was wrong, I mean
> 
> For conditional variables we have a default begin. So then why on
> earth do you not have an implicit let?, Just laziness?

Do you mean Guile in general, or the particular example I gave?
Also, I don't know what you mean with ‘for conditional variables we
have a default begin’ -- what's a ‘default begin’ here, and also Guile
doesn't (currently) have conditional variables.

> There should  be a good reason or? this is a pretty fundamental
> change that I support but then we should not be lazy not trying to
> understand the design choices of the old beards.

I think the thread of the following message
<https://lists.gnu.org/archive/html/guile-devel/2002-11/msg00039.html>
is relevant, though I've only just started reading it.

Greetings,
Maxime.

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-05 17:31                 ` Stefan Israelsson Tampe
  2022-02-05 17:36                   ` Maxime Devos
@ 2022-02-06  6:44                   ` Linus Björnstam
  2022-02-06  9:27                     ` tomas
  1 sibling, 1 reply; 24+ messages in thread
From: Linus Björnstam @ 2022-02-06  6:44 UTC (permalink / raw)
  To: Stefan Israelsson Tampe, Maxime Devos; +Cc: guile-devel


On Sat, 5 Feb 2022, at 18:31, Stefan Israelsson Tampe wrote:
> Hmm this was wrong, I mean
>
> For conditional variables we have a default begin. So then why on earth 
> do you not have an implicit let?, Just laziness?
> There should  be a good reason or? this is a pretty fundamental change 
> that I support but then we should not be lazy not trying to understand 
> the design choices of the old beards.

In other languages let starts a new lexical context which can be expensive. I don't know guile internals but a let without any defines is trivially converted to a begin by the optimizer.






^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-06  6:44                   ` Linus Björnstam
@ 2022-02-06  9:27                     ` tomas
  2022-02-06  9:40                       ` Maxime Devos
  2022-02-06  9:45                       ` Linus Björnstam
  0 siblings, 2 replies; 24+ messages in thread
From: tomas @ 2022-02-06  9:27 UTC (permalink / raw)
  To: guile-devel

[-- Attachment #1: Type: text/plain, Size: 1383 bytes --]

On Sun, Feb 06, 2022 at 07:44:31AM +0100, Linus Björnstam wrote:
> 
> On Sat, 5 Feb 2022, at 18:31, Stefan Israelsson Tampe wrote:
> > Hmm this was wrong, I mean
> >
> > For conditional variables we have a default begin. So then why on earth 
> > do you not have an implicit let?, Just laziness?
> > There should  be a good reason or? this is a pretty fundamental change 
> > that I support but then we should not be lazy not trying to understand 
> > the design choices of the old beards.
> 
> In other languages let starts a new lexical context which can be expensive. I don't know guile internals but a let without any defines is trivially converted to a begin by the optimizer.

It seems that in Guile 3 the expander is smart enough for an empty
bindings list in let:

| tomas@trotzki:~$ guile
| GNU Guile 3.0.7.6-22120
| Copyright (C) 1995-2021 Free Software Foundation, Inc.

[...]

| scheme@(guile-user)> ,expand (let () (message #t "Yikes"))
| $1 = (message #t "Yikes")
| scheme@(guile-user)> ,expand (let ((x 3)) (message #t "Yikes ~S" x))
| $2 = (let ((x 3)) (message #t "Yikes ~S" x))

...but doesn't "see" whether bindings are actually used (quite possibly
those go away in a later optimisation phase, though):

| scheme@(guile-user)> ,expand (let ((x 3)) (message #t "Yikes"))
| $3 = (let ((x 3)) (message #t "Yikes"))

Cheers
-- 
t

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-06  9:27                     ` tomas
@ 2022-02-06  9:40                       ` Maxime Devos
  2022-02-06  9:45                       ` Linus Björnstam
  1 sibling, 0 replies; 24+ messages in thread
From: Maxime Devos @ 2022-02-06  9:40 UTC (permalink / raw)
  To: tomas, guile-devel

[-- Attachment #1: Type: text/plain, Size: 452 bytes --]

tomas@tuxteam.de schreef op zo 06-02-2022 om 10:27 [+0100]:
> ...but doesn't "see" whether bindings are actually used (quite
> possibly
> those go away in a later optimisation phase, though):
> 
> | scheme@(guile-user)> ,expand (let ((x 3)) (message #t "Yikes"))
> | $3 = (let ((x 3)) (message #t "Yikes"))

They do go away during optimisation:

scheme@(guile-user)> ,optimize (let ((x 3)) (message #t "Yikes"))
$1 = (message #t "Yikes")


[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-06  9:27                     ` tomas
  2022-02-06  9:40                       ` Maxime Devos
@ 2022-02-06  9:45                       ` Linus Björnstam
  2022-02-06 10:48                         ` tomas
  1 sibling, 1 reply; 24+ messages in thread
From: Linus Björnstam @ 2022-02-06  9:45 UTC (permalink / raw)
  To: tomas, guile-devel

You need to use ,optimize. 

-- 
  Linus Björnstam

On Sun, 6 Feb 2022, at 10:27, tomas@tuxteam.de wrote:
> On Sun, Feb 06, 2022 at 07:44:31AM +0100, Linus Björnstam wrote:
>> 
>> On Sat, 5 Feb 2022, at 18:31, Stefan Israelsson Tampe wrote:
>> > Hmm this was wrong, I mean
>> >
>> > For conditional variables we have a default begin. So then why on earth 
>> > do you not have an implicit let?, Just laziness?
>> > There should  be a good reason or? this is a pretty fundamental change 
>> > that I support but then we should not be lazy not trying to understand 
>> > the design choices of the old beards.
>> 
>> In other languages let starts a new lexical context which can be expensive. I don't know guile internals but a let without any defines is trivially converted to a begin by the optimizer.
>
> It seems that in Guile 3 the expander is smart enough for an empty
> bindings list in let:
>
> | tomas@trotzki:~$ guile
> | GNU Guile 3.0.7.6-22120
> | Copyright (C) 1995-2021 Free Software Foundation, Inc.
>
> [...]
>
> | scheme@(guile-user)> ,expand (let () (message #t "Yikes"))
> | $1 = (message #t "Yikes")
> | scheme@(guile-user)> ,expand (let ((x 3)) (message #t "Yikes ~S" x))
> | $2 = (let ((x 3)) (message #t "Yikes ~S" x))
>
> ...but doesn't "see" whether bindings are actually used (quite possibly
> those go away in a later optimisation phase, though):
>
> | scheme@(guile-user)> ,expand (let ((x 3)) (message #t "Yikes"))
> | $3 = (let ((x 3)) (message #t "Yikes"))
>
> Cheers
> -- 
> t
>
> Attachments:
> * signature.asc



^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-06  9:45                       ` Linus Björnstam
@ 2022-02-06 10:48                         ` tomas
  2022-02-06 20:13                           ` Stefan Israelsson Tampe
  0 siblings, 1 reply; 24+ messages in thread
From: tomas @ 2022-02-06 10:48 UTC (permalink / raw)
  To: Linus Björnstam; +Cc: guile-devel

[-- Attachment #1: Type: text/plain, Size: 185 bytes --]

On Sun, Feb 06, 2022 at 10:45:54AM +0100, Linus Björnstam wrote:
> You need to use ,optimize. 

Thanks you both, Maxime and Linus, for giving me a new lantern :)

Cheers
-- 
t

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-06 10:48                         ` tomas
@ 2022-02-06 20:13                           ` Stefan Israelsson Tampe
  2022-02-06 20:28                             ` Maxime Devos
  2022-02-07  5:56                             ` Linus Björnstam
  0 siblings, 2 replies; 24+ messages in thread
From: Stefan Israelsson Tampe @ 2022-02-06 20:13 UTC (permalink / raw)
  To: tomas; +Cc: guile-devel, Linus Björnstam

[-- Attachment #1: Type: text/plain, Size: 313 bytes --]

Hmm just why conditionals use begin and not let,

On Sun, Feb 6, 2022 at 11:49 AM <tomas@tuxteam.de> wrote:

> On Sun, Feb 06, 2022 at 10:45:54AM +0100, Linus Björnstam wrote:
> > You need to use ,optimize.
>
> Thanks you both, Maxime and Linus, for giving me a new lantern :)
>
> Cheers
> --
> t
>

[-- Attachment #2: Type: text/html, Size: 605 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-06 20:13                           ` Stefan Israelsson Tampe
@ 2022-02-06 20:28                             ` Maxime Devos
  2022-02-06 20:31                               ` tomas
       [not found]                               ` <CAGua6m3BHMXOhT3PHZcxdqHqHomTFESO31j5CcSNK3pbA7K-Kg@mail.gmail.com>
  2022-02-07  5:56                             ` Linus Björnstam
  1 sibling, 2 replies; 24+ messages in thread
From: Maxime Devos @ 2022-02-06 20:28 UTC (permalink / raw)
  To: Stefan Israelsson Tampe, tomas; +Cc: Linus Björnstam, guile-devel

[-- Attachment #1: Type: text/plain, Size: 356 bytes --]

Stefan Israelsson Tampe schreef op zo 06-02-2022 om 21:13 [+0100]:
> Hmm just why conditionals use begin and not let,

I'd assume the reason is that this is how it has been done in the past
and because of performance reasons (which don't seem to apply
anymore?), so I guess that we could now switch to the more general
'let'?

Greetings,
Maxime.

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-06 20:28                             ` Maxime Devos
@ 2022-02-06 20:31                               ` tomas
       [not found]                               ` <CAGua6m3BHMXOhT3PHZcxdqHqHomTFESO31j5CcSNK3pbA7K-Kg@mail.gmail.com>
  1 sibling, 0 replies; 24+ messages in thread
From: tomas @ 2022-02-06 20:31 UTC (permalink / raw)
  To: Maxime Devos; +Cc: Linus Björnstam, guile-devel

[-- Attachment #1: Type: text/plain, Size: 598 bytes --]

On Sun, Feb 06, 2022 at 09:28:15PM +0100, Maxime Devos wrote:
> Stefan Israelsson Tampe schreef op zo 06-02-2022 om 21:13 [+0100]:
> > Hmm just why conditionals use begin and not let,
> 
> I'd assume the reason is that this is how it has been done in the past
> and because of performance reasons (which don't seem to apply
> anymore?), so I guess that we could now switch to the more general
> 'let'?

Hm. Perhaps it's just ergonomics of sorts. The intention of `begin' seems
somehow clearer than a `let' with no bindings (or, more insidious, with
unused bindings ;)

Cheers
-- 
t

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 195 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
       [not found]                               ` <CAGua6m3BHMXOhT3PHZcxdqHqHomTFESO31j5CcSNK3pbA7K-Kg@mail.gmail.com>
@ 2022-02-06 21:26                                 ` Maxime Devos
  2022-02-06 21:27                                   ` Maxime Devos
  0 siblings, 1 reply; 24+ messages in thread
From: Maxime Devos @ 2022-02-06 21:26 UTC (permalink / raw)
  To: Stefan Israelsson Tampe; +Cc: guile-devel

[-- Attachment #1: Type: text/plain, Size: 1131 bytes --]

Stefan Israelsson Tampe schreef op zo 06-02-2022 om 22:10 [+0100]:
> I think you are right on this, I looked at the scheme spec and I find
> no trace for using a let or not or not in the spec.
> So it is an implementation detail. Now, this is important, if I want
> to write portable code if cond case allows definitions
> without an explicit let, it is not portable anymore!! So this is the
> only cost I see with your idea. This issue can probably 
> be mitigated but it means that we must maintain two versions of the
> conditional constructs.

Any old portable code (in particular, not assuming the proposed Guile
behaviour) still has the same semantics; old portable code remains
portable code.

As such, we don't have to have two versions of the conditional
constructs in Guile, there is no backwards incompatibility.

However, there would admittedly be a slightly higher risk of writing
unportable code _by accident_.

FWIW, Guile already exports unportable syntax in (rnrs base):
R6RS doesn't mention named let anywhere, yet Guile exports it as 'let'
in (rnrs base) anyway.

Greetings,
Maxime.

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 260 bytes --]

^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-06 21:26                                 ` Maxime Devos
@ 2022-02-06 21:27                                   ` Maxime Devos
  0 siblings, 0 replies; 24+ messages in thread
From: Maxime Devos @ 2022-02-06 21:27 UTC (permalink / raw)
  To: Stefan Israelsson Tampe; +Cc: guile-devel

Maxime Devos schreef op zo 06-02-2022 om 22:26 [+0100]:
> FWIW, Guile already exports unportable syntax in (rnrs base):
> R6RS doesn't mention named let anywhere, yet Guile exports it as
> 'let'
> in (rnrs base) anyway.

Nevermind, R6RS has named let:
<http://www.r6rs.org/final/html/r6rs/r6rs-Z-H-2.html#node_toc_node_sec_11.16>




^ permalink raw reply	[flat|nested] 24+ messages in thread

* Re: Fwd: [Patch] definitions in when, unless, do as well as in cond- and case-clauses
  2022-02-06 20:13                           ` Stefan Israelsson Tampe
  2022-02-06 20:28                             ` Maxime Devos
@ 2022-02-07  5:56                             ` Linus Björnstam
  1 sibling, 0 replies; 24+ messages in thread
From: Linus Björnstam @ 2022-02-07  5:56 UTC (permalink / raw)
  To: Stefan Israelsson Tampe; +Cc: guile-devel

Historical garage maybe. I just remember some old bug in WebKit where let was a lot slower than var because it created what was called lexical context which affected interpreter speed because of some kind of linear time variable lookup.

Anyway, that stuff doesn't apply to guile versions after 2. Especially since a (let () body ...) where the body contains no (define ...) gets converted to a (begin body ...) by the optimizer. 

The behaviour of begin Vs let is well specified and any begin outside of a body context is just chain of expressions. It just lacks internal definitions. 

-- 
  Linus Björnstam

On Sun, 6 Feb 2022, at 21:13, Stefan Israelsson Tampe wrote:
> Hmm just why conditionals use begin and not let,
>
> On Sun, Feb 6, 2022 at 11:49 AM <tomas@tuxteam.de> wrote:
>> On Sun, Feb 06, 2022 at 10:45:54AM +0100, Linus Björnstam wrote:
>> > You need to use ,optimize. 
>> 
>> Thanks you both, Maxime and Linus, for giving me a new lantern :)
>> 
>> Cheers
>> -- 
>> t



^ permalink raw reply	[flat|nested] 24+ messages in thread

end of thread, other threads:[~2022-02-07  5:56 UTC | newest]

Thread overview: 24+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-06-16 19:11 [Patch] definitions in when, unless, do as well as in cond- and case-clauses Linus Björnstam
2021-06-17  9:06 ` Maxime Devos
2021-06-17 12:57   ` Linus Björnstam
2021-06-17 13:54     ` Maxime Devos
2022-02-03 10:48 ` Linus Björnstam
     [not found]   ` <CAGua6m1Cqe=aLOD7-jfzoqxP1aOxvWn3=UgcKyk+Dx7_51Bq3w@mail.gmail.com>
2022-02-04 20:11     ` Fwd: " Stefan Israelsson Tampe
2022-02-04 20:58       ` Maxime Devos
     [not found]         ` <CAGua6m11r27x=rq4S4fF09vHY+S-Az7GOZfmoT41hEBDSkLJQg@mail.gmail.com>
2022-02-04 21:40           ` Fwd: " Stefan Israelsson Tampe
2022-02-04 23:39           ` Maxime Devos
2022-02-05  1:14             ` Stefan Israelsson Tampe
2022-02-05 10:55               ` Maxime Devos
2022-02-05 17:31                 ` Stefan Israelsson Tampe
2022-02-05 17:36                   ` Maxime Devos
2022-02-06  6:44                   ` Linus Björnstam
2022-02-06  9:27                     ` tomas
2022-02-06  9:40                       ` Maxime Devos
2022-02-06  9:45                       ` Linus Björnstam
2022-02-06 10:48                         ` tomas
2022-02-06 20:13                           ` Stefan Israelsson Tampe
2022-02-06 20:28                             ` Maxime Devos
2022-02-06 20:31                               ` tomas
     [not found]                               ` <CAGua6m3BHMXOhT3PHZcxdqHqHomTFESO31j5CcSNK3pbA7K-Kg@mail.gmail.com>
2022-02-06 21:26                                 ` Maxime Devos
2022-02-06 21:27                                   ` Maxime Devos
2022-02-07  5:56                             ` Linus Björnstam

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).