RE: cond clause does not allow definitions

[Maxime Devos]

>but it is allowed in else clause:
>scheme@(guile-user)> (cond (else (define x 7) x))
>$4 = 7
>
>not really logic

Probably in the implementation of ‘cond’, (cond (else X)) reduces to ‘X’.

It’s tricky to ensure the same behaviour here as is the case when there is more 
than only the ‘else’ clause – without tail-calling, you could use 
‘call-with-values’ in the macro to artificially make an expression context 
etc., but ‘cond’ needs to tail-call for X.

If someone wishes to implement this, I would propose defining some new syntax 
‘begin-expression’ (like ‘begin’, but instead of splicing, it interprets things 
as a bunch of expressions to evaluate in-order, and with the last expression in 
tail-position). Would probably be needed to be implemented as a primitive.

Then, ‘(cond (else X))’ could be implemented as (begin-expression X).

The documentation complains a bit about how ‘begin’ does both splicing and this 
‘begin-expression’, but 'begin’ can be split! (At least, I think so, it has 
been a while since I read that part.)

>It is allowed in Kawa and Racket but they are not scheme references
the R5RS and R7RS talk about 'clause' without more information

I don’t know what the standard says about this.

>is it normal for Guile to consider clause for cond to be an expression
context and not a definition context?

Personally, I don’t care whether something is ‘normal’, whatever that’s 
supposed to mean. What I would care about, is whether the implementation 
matches the documentation, whether the documentation is complete (even saying 
“It is unspecified whether [this] or [that].” would suffice) and whether the 
(documented) semantics is desired, useful, convenient and consistent with 
relevant standards and conventions.

In this case, not all of these are satisfied.

>should not be better to consider definition context? that would allow more
possibilities.

That would be possible – (cond (a x) ...) could be interpreted as (cond (a (let 
() x)) ...) instead.

However, I don’t think it has the semantics you desire. Some time ago, you 
asked questions  along the lines of making a macro ‘define-block’ that allows 
doings things like

(define (f)
  (if blah
      (define-block foo 1)
      (define-block foo 2))
  [do things with foo here])

but that’s not how scoping, macros and in particular ‘let’ works in Scheme, as 
mentioned there.

Personally, I think implementing ‘cond’ as the cond+let stuff mentioned above 
is a bit risky w.r.t. misunderstanding scoping, consider for example:

(define (f x)
  (define y x)
  (cond ((square? x) (define y (sqrt x)) (pk “took a square root”))
             [more branches here])
 y)

which would silently do the wrong thing (unless you enable warnings for 
shadowing, but you can do neat things with shadowing – you can write pure code 
in a somewhat imperative style (*)).

Best regards,
Maxime Devos

(*)  See, e.g., 
https://git.gnunet.org/gnunet-scheme.git/tree/gnu/gnunet/config/parser.scm, 
where ‘let^’ can do (if X (return Y)) and ‘continue’ without let/ec (not an use 
of shadowing but sounds like something you may be interested in). On line 
https://git.gnunet.org/gnunet-scheme.git/tree/gnu/gnunet/config/parser.scm#n481 
and 485, you can see how shadowing is used as a replacement of mutation.