Re: cond(itionals) with optional execution of statements
Hello Damien! I am not sure I understand the reasoning behind condx: I think cond is already a macro, which only evaluates a consequent, if the predicate of its case is #t. Additionally multiple expressions are possible in each branch. To clarify, I ask: What is the case, where condx does or does not evaluate some code, when cond would not or would? Or is it rather about the different nesting / sequence of expressions, which condx seems to enable? I think the flow you demonstrate might save a bit of nesting. Best regards, Zelphir On 9/11/21 11:14 AM, Damien Mattei wrote: > hello, > > i wrote a little macro (file condx.scm) that allow : cond(itionals) with > optional execution of statements before: > > (define-syntax condx > (syntax-rules (exec) > ((_) > (error 'condx "No else clause")) > ((_ (else e ...)) > (let () e ...)) > ((_ (exec s ...) d1 ...) > (let () s ... (condx d1 ...))) > ((_ (t e ...) tail ...) > (if t > (let () e ...) > (condx tail ...) > > use it like that: > > mattei@macbook-pro-touch-bar library-FunctProg % guile > GNU Guile 3.0.7 > Copyright (C) 1995-2021 Free Software Foundation, Inc. > > Guile comes with ABSOLUTELY NO WARRANTY; for details type `,show w'. > This program is free software, and you are welcome to redistribute it > under certain conditions; type `,show c' for details. > > Enter `,help' for help. > scheme@(guile-user)> (load "condx.scm") > ;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0 > ;;; or pass the --no-auto-compile argument to disable. > ;;; compiling /Users/mattei/Dropbox/git/library-FunctProg/condx.scm > ;;; compiled > /Users/mattei/.cache/guile/ccache/3.0-LE-8-4.5/Users/mattei/Dropbox/git/library-FunctProg/condx.scm.go > scheme@(guile-user)> (define x 1) > > (condx ((= x 7) 'never) > (exec > (define y 3) > (set! x 7)) > ((= y 1) 'definitely_not) > (exec > (set! y 10) > (define z 2)) > ((= x 7) (+ x y z)) > (else 'you_should_not_be_here)) > $1 = 19 > > i share it to have idea about critics or idea to improve it as it will be > part of a Scheme extension to scheme language that will include other > features > > have a good day > > Damien -- repositories: https://notabug.org/ZelphirKaltstahl
Re: cond(itionals) with optional execution of statements
Hello Zelphir,
condx evaluate all code(s) in the 'exec' block until a conditional is true,
it then evaluate the consequent code of course.
So ,yes your true it saves a lot of nesting parenthesis as in this example:
here a code with condx and without it:
(define (ssigma-proto-condx L t)
(set! cpt {cpt + 1})
(define ls (length L))
(define dyn (array-ref dyna ls t))
;; dyna[ls][t] means 0: unknown solution, 1: solution found, 2: no solution
(condx [(not (zero? dyn)) (one? dyn)]
[(null? L) (array-set! dyna 2 ls t) #f] ;; return #f
[exec (define c (first L))]
;; c is the solution
[{c = t} (array-set! dyna 1 ls t) #t] ;; return #t
[exec (define R (rest L))]
;; continue searching a solution in the rest
[{c > t} (define s (ssigma-proto R t))
(array-set! dyna
(one-two s)
ls t)
s] ;; return s
;; else :
;; c < t at this point
;; c is part of the solution or his approximation
;; or c is not part of solution
[else (define s {(ssigma-proto R {t - c}) or (ssigma-proto R t)})
(array-set! dyna (one-two s)
ls t)
s]))
without condx:
(define (ssigma-proto L t)
(set! cpt {cpt + 1})
(define ls (length L))
(define dyn (array-ref dyna ls t))
;; dyna[ls][t] means 0: unknown solution, 1: solution found, 2: no solution
(cond [(not (zero? dyn)) (one? dyn)]
[(null? L) (array-set! dyna 2 ls t) #f] ;; return #f
[else (let [(c (first L))]
(if {c = t} ;; c is the solution
(begin
(array-set! dyna 1 ls t)
#t) ;; return #t
;; else
(let [(R (rest L))]
(if {c > t} ;; continue searching a solution in the rest
(let [(s (ssigma-proto R t))]
(array-set! dyna
(one-two s)
ls t)
s) ;; return s
;; else
;; c < t at this point
;; c is part of the solution or his approximation
;; or c is not part of solution
(let [(s {(ssigma-proto R {t - c}) or (ssigma-proto R
t)})]
(array-set! dyna (one-two s)
ls t)
s)
] ))
there a lot more of indentation and nesting.
Note also that the use of let () in condx definition allow to use define in
consequent and 'exec' block.
Damien
On Sun, Sep 12, 2021 at 11:41 AM Zelphir Kaltstahl <
zelphirkaltst...@posteo.de> wrote:
> Hello Damien!
>
> I am not sure I understand the reasoning behind condx: I think cond is
> already a
> macro, which only evaluates a consequent, if the predicate of its case is
> #t.
> Additionally multiple expressions are possible in each branch.
>
> To clarify, I ask: What is the case, where condx does or does not evaluate
> some
> code, when cond would not or would? Or is it rather about the different
> nesting
> / sequence of expressions, which condx seems to enable? I think the flow
> you
> demonstrate might save a bit of nesting.
>
> Best regards,
> Zelphir
>
> On 9/11/21 11:14 AM, Damien Mattei wrote:
> > hello,
> >
> > i wrote a little macro (file condx.scm) that allow : cond(itionals)
> with
> > optional execution of statements before:
> >
> > (define-syntax condx
> > (syntax-rules (exec)
> > ((_)
> > (error 'condx "No else clause"))
> > ((_ (else e ...))
> > (let () e ...))
> > ((_ (exec s ...) d1 ...)
> > (let () s ... (condx d1 ...)))
> > ((_ (t e ...) tail ...)
> > (if t
> > (let () e ...)
> > (condx tail ...)
> >
> > use it like that:
> >
> > mattei@macbook-pro-touch-bar library-FunctProg % guile
> > GNU Guile 3.0.7
> > Copyright (C) 1995-2021 Free Software Foundation, Inc.
> >
> > Guile comes with ABSOLUTELY NO WARRANTY; for details type `,show w'.
> > This program is free software, and you are welcome to redistribute it
> > under certain conditions; type `,show c' for details.
> >
> > Enter `,help' for help.
> > scheme@(guile-user)> (load "condx.scm")
> > ;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0
> > ;;; or pass the --no-auto-compile argument to disable.
> > ;;; compiling /Users/mattei/Dropbox/git/library-FunctProg/condx.scm
> > ;;; compiled
> >
> /Users/mattei/.cache/guile/ccache/3.0-LE-8-4.5/Users/mattei/Dropbox/git/library-FunctProg/condx.scm.go
> > scheme@(guile-user)> (define x 1
Re: cond(itionals) with optional execution of statements
On 12.09.2021 19:05, Damien Mattei wrote:
> Hello Zelphir,
>
> condx evaluate all code(s) in the 'exec' block until a conditional is true,
> it then evaluate the consequent code of course.
> So ,yes your true it saves a lot of nesting parenthesis as in this example:
>
Interesting macro. I think I've occasionally felt the need for such a thing.
Two comments:
1. Using 'begin' instead of 'exec' might feel more familiar to Schemers, and
since the 'literals' of syntax-rules are matched hygienically starting
from Guile 2.2 (I think), it might be a good idea to use a common core
identifier instead of an unbound one like 'exec'. (Or you could bind it.)
A little elaboration, in case you don't know what I'm talking about: the
"literals" of a syntax-rules macro are not matched by "name" (the string
representing the symbol seen in code) but by "variable binding."
For example:
(let ((else #f))
(cond
((= 1 0) 'foo)
(else 'bar)
(#t 'qux)))
; => qux
The code returns qux, because the 'cond' macro doesn't recognize the 'else'
as the 'else' that it knows of, since it's been rebound via let.
An example that would work in a conforming R7RS-small implementation; don't
know if it works with Guile, it's just to explain the principle:
;; Import core bindings, but renaming 'else' to 'otherwise'
(import (rename (scheme base) (else otherwise)))
(cond
((= 1 0) 'foo)
((= 2 3) 'bar)
(otherwise 'qux))
; => qux
The (scheme base) library defined by R7RS-small exports the identifier 'else'
which is used by 'cond' for matching. This allows the programmer to rename
the 'else' used by 'cond' while importing the base library. (The 'else' is
not bound to anything useful, it's just bound at all so it can be renamed.)
Likewise you might want to bind 'exec' to anything and export it along with
the 'condx' identifier, so if some Schemer uses the identifier 'exec' for
something different in their code, they can still use your macro by renaming
your 'exec' to something else. Otherwise there's no way to make it work.
If 'exec' was unbound during the definition of 'condx' then it must remain
unbound for 'condx' to recognized it again, meaning it can't be renamed.
Or (IMO better) you could reuse the 'begin' binding (in Guile's case, from
boot-9, in R7RS-small, from (scheme base)), because it's very unlikely that
someone will use 'begin' for something else in their code, and it would force
them to rename the core 'begin' to something else and then that would work
with your code automatically. E.g. if someone renames 'begin' to 'start' it
will automatically work in your macro if you had defined it with 'begin' in
the literals list of syntax-rules.
2. You might be interested in let/ec, which lets you bind a variable to an
"escape continuation" i.e. a way to "return" from a block of code. Here's
your code using condx rewritten to use let/ec instead:
(define (ssigma-proto-condx L t)
(set! cpt {cpt + 1})
(define ls (length L))
(define dyn (array-ref dyna ls t))
;; dyna[ls][t] means 0: unknown solution, 1: solution found, 2: no solution
(let/ec return
(when (not (zero? dyn))
(return (one? dyn)))
(when (null? L)
(array-set! dyna 2 ls t)
(return #f))
(define c (first L))
(when {c = t}
(array-set! dyna 1 ls t)
(return #t))
(define R (rest L))
;; continue searching a solution in the rest
(when {c > t}
(define s (ssigma-proto R t))
(array-set! dyna (one-two s) ls t)
(return s))
;; else :
;; c < t at this point
;; c is part of the solution or his approximation
;; or c is not part of solution
(define s {(ssigma-proto R {t - c}) or (ssigma-proto R t)})
(array-set! dyna (one-two s) ls t)
(return s)))
I've turned all 'condx' branches that weren't exec to use 'when' because it
felt more natural with the imperative style. Of course you could still use
the regular 'cond' here and there or the regular 'if'. 'When' is just short
for an 'if' without an else part.
The last '(return s)' could just be 's' but I find it more consistent and
readable to use 'return' there as well.
--
Taylan
Re: cond(itionals) with optional execution of statements
Hi Damien!
I see! Indeed, some indentation happening there. I get the point now, thank you.
Could be well worth it, but it depends on how much you get out of it, compared
to how much additional mental load you get for introducing a new control flow
concept. Sometimes it is worth taking a step back and refactoring part of the
logic out into a separate procedure, which then starts at a lower level of
indentation again, avoiding the problem. I don't know your scenario though, so
this is only a general idea.
I would probably write the `cond` version a bit different, to avoid `begin` and
break a few lines at other places to avoid the indentation taking a lot of
horizontal space. I am not sure it makes sense in your context, but here it is:
(define (ssigma-proto L t)
(set! cpt {cpt + 1})
(define ls (length L))
(define dyn (array-ref dyna ls t))
;; dyna[ls][t] means 0: unknown solution, 1: solution found, 2: no solution
(cond
[(not (zero? dyn)) (one? dyn)]
[(null? L) (array-set! dyna 2 ls t) #f] ;; return #f
[else
(let [(c (first L))]
(cond
[{c = t} ;; c is the solution
(array-set! dyna 1 ls t)
#t] ;; return #t
[else
(let [(R (rest L))]
(cond
[{c > t} ;; continue searching a solution in the rest
(let [(s (ssigma-proto R t))]
(array-set! dyna (one-two s) ls t)
s)] ;; return s
[else
;; c < t at this point
;; c is part of the solution or his approximation
;; or c is not part of solution
(let [(s {(ssigma-proto R {t - c}) or (ssigma-proto R t)})]
(array-set! dyna (one-two s) ls t)
s)]))]))]))
(Removed some empty lines for brevity in this e-mail. Sometimes I like good
empty lines too! Could the `set!` be replaced using a `define`?)
I guess the expressions in braces are using infix operations like the `or` or
`=` in the condition of `{c = t}`.
Best regards,
Zelphir
On 9/12/21 7:05 PM, Damien Mattei wrote:
> Hello Zelphir,
>
> condx evaluate all code(s) in the 'exec' block until a conditional is true, it
> then evaluate the consequent code of course.
> So ,yes your true it saves a lot of nesting parenthesis as in this example:
>
> here a code with condx and without it:
>
>
> (define (ssigma-proto-condx L t)
>
> (set! cpt {cpt + 1})
>
> (define ls (length L))
> (define dyn (array-ref dyna ls t))
>
> ;; dyna[ls][t] means 0: unknown solution, 1: solution found, 2: no solution
>
> (condx [(not (zero? dyn)) (one? dyn)]
>[(null? L) (array-set! dyna 2 ls t) #f] ;; return #f
>
>[exec (define c (first L))]
>
>;; c is the solution
>[{c = t} (array-set! dyna 1 ls t) #t] ;; return #t
>
>[exec (define R (rest L))]
>
>;; continue searching a solution in the rest
>[{c > t} (define s (ssigma-proto R t))
> (array-set! dyna
> (one-two s)
> ls t)
> s] ;; return s
>
>;; else :
>;; c < t at this point
>;; c is part of the solution or his approximation
>;; or c is not part of solution
>[else (define s {(ssigma-proto R {t - c}) or (ssigma-proto R t)})
> (array-set! dyna (one-two s)
> ls t)
> s]))
>
>
> without condx:
>
>
>
> (define (ssigma-proto L t)
>
> (set! cpt {cpt + 1})
>
> (define ls (length L))
> (define dyn (array-ref dyna ls t))
>
> ;; dyna[ls][t] means 0: unknown solution, 1: solution found, 2: no solution
>
> (cond [(not (zero? dyn)) (one? dyn)]
> [(null? L) (array-set! dyna 2 ls t) #f] ;; return #f
>
> [else (let [(c (first L))]
>
> (if {c = t} ;; c is the solution
>
> (begin
> (array-set! dyna 1 ls t)
> #t) ;; return #t
>
> ;; else
> (let [(R (rest L))]
>
> (if {c > t} ;; continue searching a solution in the rest
>
> (let [(s (ssigma-proto R t))]
> (array-set! dyna
> (one-two s)
> ls t)
>
> s) ;; return s
>
> ;; else
> ;; c < t at this point
> ;; c is part of the solution or his approximation
> ;; or c is not part of solution
> (let [(s {(ssigma-proto R {t - c}) or (ssigma-proto R
> t)})]
> (array-set! dyna (one-two s)
> ls t)
> s)
> ] ))
>
>
> there a lo
