in CL (Common Lisp) , i'd use catch/throw ?

in Scheme , i'd have to use Call/cc ?

https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops

for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, 'equals', x, '*', n//x)
break
else:
# loop fell through without finding a factor
print(n, 'is a prime number')

2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3

the keyword ELSE doesn't quite sound right.

* Hen Hanna <d568b860-a810-4506-8807-cc1d4c4ad74an@googlegroups.com> :
Wrote on Sun, 5 Mar 2023 21:03:32 -0800 (PST):

> in CL (Common Lisp) , i'd use catch/throw ?

I think to implement the control structure indicated in python one would
require co-routines at the language level. Common Lisp does have
co-routines, and so cannot adequately implement the pattern.

I haven't come across or used a call/cc implementation in CL which lets
me express this (with the semantics as the python generator), I think in
principe it shouldn't be possible but I haven't all all call/cc
packages. if you find one do let me know. (The closest thing I've seen
of something that's capable of implementing this is probably the
co-operative multithreading MP package in cmucl)

> in Scheme , i'd have to use Call/cc ?
>
> https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops
>
> for n in range(2, 10):
> for x in range(2, n):
> if n % x == 0:
> print(n, 'equals', x, '*', n//x)
> break
> else:
> # loop fell through without finding a factor
> print(n, 'is a prime number')
>
>
> 2 is a prime number
> 3 is a prime number
> 4 equals 2 * 2
> 5 is a prime number
> 6 equals 2 * 3
> 7 is a prime number
> 8 equals 2 * 4
> 9 equals 3 * 3
>
>
> the keyword ELSE doesn't quite sound right.

the else: matches the if: and should probably be aligned to it.

On Sun, 5 Mar 2023 21:03:32 -0800 (PST)
Hen Hanna <henhanna@gmail.com> wrote:
> in CL (Common Lisp) , i'd use catch/throw ?

You could do it with CATCH and THROW but for this kind of thing RETURN
is more natural.

> in Scheme , i'd have to use Call/cc ?

You'd be better off asking this on comp.lang.scheme .

> https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops
>
> for n in range(2, 10):
> for x in range(2, n):
> if n % x == 0:
> print(n, 'equals', x, '*', n//x)
> break
> else:
> # loop fell through without finding a factor
> print(n, 'is a prime number')
>
>
> 2 is a prime number
> 3 is a prime number
> 4 equals 2 * 2
> 5 is a prime number
> 6 equals 2 * 3
> 7 is a prime number
> 8 equals 2 * 4
> 9 equals 3 * 3

(do ((n 2 (+ 1 n)))
((eql n 10))
(do ((x 2 (+ 1 x)))
((eql x n) (format t "~A is a prime number~%" n))
(when (eql 0 (mod n x))
(format t "~A equals ~A * ~A~%" n x (/ n x))
(return))))

Or , to avoid doing the division of n / x twice ,

(do ((n 2 (+ 1 n)))
((eql n 10))
(do ((x 2 (+ 1 x)))
((eql x n) (format t "~A is a prime number~%" n))
(multiple-value-bind (quot rem) (floor n x)
(when (eql 0 rem)
(format t "~A equals ~A * ~A~%" n x quot)
(return)))))

> the keyword ELSE doesn't quite sound right.

For this kind of construct it doesn't sound right to me either. Perhaps
something like loop_ended would better express what's happening.

--
vlaho.ninja/prog

Madhu <enometh@meer.net> writes:
>
> https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops
>
> for n in range(2, 10):
> for x in range(2, n):
> if n % x == 0:
> print(n, 'equals', x, '*', n//x)
> break
> else:
> # loop fell through without finding a factor
> print(n, 'is a prime number')

the else: matches the if: and should probably be aligned to it.

No, it really does match the 'for x'. This use of 'else' is a
(controversial) feature of Python. The code above is quoted directly
from the Python tutorial at the given URL, which nicely explains how it
works.

It's controversial, not because there is something wrong with the
feature itself, but because many people find naming it 'else' to be
confusing.

There is probably a LOOP clause that means the same thing, but I'm too
lazy to look that up (since I never use LOOP).

- Alan

On Monday, March 6, 2023 at 9:44:33 AM UTC-8, Alan Bawden wrote:
> Madhu <eno...@meer.net> writes:
> >
> > https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops
> >
> > for n in range(2, 10):
> > for x in range(2, n):
> > if n % x == 0:
> > print(n, 'equals', x, '*', n//x)
> > break
> > else:
> > # loop fell through without finding a factor
> > print(n, 'is a prime number')
> the else: matches the if: and should probably be aligned to it.
> No, it really does match the 'for x'. This use of 'else' is a
> (controversial) feature of Python. The code above is quoted directly
> from the Python tutorial at the given URL, which nicely explains how it
> works.
>
> It's controversial, not because there is something wrong with the
> feature itself, but because many people find naming it 'else' to be
> confusing.
>
> There is probably a LOOP clause that means the same thing, but I'm too
> lazy to look that up (since I never use LOOP).

Since you insist :)

(loop for n from 2 below 10
do (loop for x from 2 below n
when (zerop (mod n x))
do (format t "~d equals ~d * ~d~%" n x (/ n x))
and return nil
finally (format t "~d is a prime number.~%" n)))

Alan Bawden <alan@csail.mit.edu> writes:

There is probably a LOOP clause that means the same thing, but I'm too
lazy to look that up....

And let me add before somebody else points it out: it's also the same
as the "result-form" in a DO loop. I didn't think of that at first
because DO doesn't have keywords that introduce clauses...

In any case there is no need to reach for anything like CATCH/THROW for
this.

- Alan

* Alan Bawden <86edq1wz9h.fsf@williamsburg.bawden.org> :
Wrote on Mon, 06 Mar 2023 12:44:26 -0500:

> Madhu <enometh@meer.net> writes:
> >
> > https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops
> the else: matches the if: and should probably be aligned to it.
>
> No, it really does match the 'for x'. This use of 'else' is a
> (controversial) feature of Python. The code above is quoted directly
> from the Python tutorial at the given URL, which nicely explains how it
> works.

Thanks for pointing it out. ("My blushes if it were possible]")

> It's controversial, not because there is something wrong with the
> feature itself, but because many people find naming it 'else' to be
> confusing.
>
> There is probably a LOOP clause that means the same thing, but I'm too
> lazy to look that up (since I never use LOOP).

LOOP doesn't have Continue. Breaking is by means of RETURN (or
RETURN-FROM a named loop) at any point. and the FINALLY block is
executed when the loop completes normally.

> >
> > for n in range(2, 10):
> > for x in range(2, n):
> > if n % x == 0:
> > print(n, 'equals', x, '*', n//x)
> > break
> > else:
> > # loop fell through without finding a factor
> > print(n, 'is a prime number')

so maybe

(loop for n from 2 below 10 do
(loop for x from 2 below n
if (zerop (mod n x))
do (return (print (list n '= x '* (/ n x))))
finally (print (list n 'isprime))))

On Monday, March 6, 2023 at 4:26:34 AM UTC-8, Spiros Bousbouras wrote:
> On Sun, 5 Mar 2023 21:03:32 -0800 (PST)
> Hen Hanna <henh...@gmail.com> wrote:
> > in CL (Common Lisp) , i'd use catch/throw ?
> You could do it with CATCH and THROW but for this kind of thing RETURN
> is more natural.
> > in Scheme , i'd have to use Call/cc ?
> You'd be better off asking this on comp.lang.scheme .
> > https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops
> >
> > for n in range(2, 10):
> > for x in range(2, n):
> > if n % x == 0:
> > print(n, 'equals', x, '*', n//x)
> > break
> > else:
> > # loop fell through without finding a factor
> > print(n, 'is a prime number')
> >
> >
> > 2 is a prime number
> > 3 is a prime number
> > 4 equals 2 * 2
> > 5 is a prime number
> > 6 equals 2 * 3
> > 7 is a prime number
> > 8 equals 2 * 4
> > 9 equals 3 * 3
> (do ((n 2 (+ 1 n)))
> ((eql n 10))
> (do ((x 2 (+ 1 x)))
> ((eql x n) (format t "~A is a prime number~%" n))
> (when (eql 0 (mod n x))
> (format t "~A equals ~A * ~A~%" n x (/ n x))
> (return))))
>
> Or , to avoid doing the division of n / x twice ,
>
> (do ((n 2 (+ 1 n)))
> ((eql n 10))
> (do ((x 2 (+ 1 x)))
> ((eql x n) (format t "~A is a prime number~%" n))
> (multiple-value-bind (quot rem) (floor n x)
> (when (eql 0 rem)
> (format t "~A equals ~A * ~A~%" n x quot)
> (return)))))

> > the keyword ELSE doesn't quite sound right.

> For this kind of construct it doesn't sound right to me either. Perhaps
> something like loop_ended would better express what's happening.

thanks so much!!!

other candidates are:
for_loop_end: for_nomalend: for_end: ..........

At first, the REuse of the keyword ELSE seemed clever, but
it doesn't quite sound right, and another name that clarifies the matching-pair aspect would be better.

gosh> (+ a b) *** ERROR: operation + is not defined between "12" and "345"

Python's semantic overloading of + is a big win, but not for ELSE

I wonder... if elsewhere in Python , Lisp, or Scheme... there's similar misguided semantic overloading (?)

On Monday, March 6, 2023 at 1:45:59 AM UTC-8, Madhu wrote:
> * Hen Hanna <d568b860-a810-4506...@googlegroups.com> :
> Wrote on Sun, 5 Mar 2023 21:03:32 -0800 (PST):

> > in CL (Common Lisp) , i'd use catch/throw ?

> I think to implement the control structure indicated in python one would
> require co-routines at the language level. Common Lisp does have
> co-routines, and so cannot adequately implement the pattern.
>
> I haven't come across or used a call/cc implementation in CL which lets
> me express this (with the semantics as the python generator), I think in
> principe it shouldn't be possible but I haven't all all call/cc
> packages. if you find one do let me know. (The closest thing I've seen
> of something that's capable of implementing this is probably the
> co-operative multithreading MP package in cmucl)
> > in Scheme , i'd have to use Call/cc ?
> >
> > https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops
> >
> > for n in range(2, 10):
> > for x in range(2, n):
> > if n % x == 0:
> > print(n, 'equals', x, '*', n//x)
> > break
> > else:
> > # loop fell through without finding a factor
> > print(n, 'is a prime number')
> >
> >
> > 2 is a prime number
> > 3 is a prime number
> > 4 equals 2 * 2
> > 5 is a prime number
> > 6 equals 2 * 3
> > 7 is a prime number
> > 8 equals 2 * 4
> > 9 equals 3 * 3
> >

thanks (all) for the great comments !!!

i think.... that These range objects get used right away, so there is no element of [lazy evaluation] or coroutines here.

>>>> The range() is a built-in function that returns a range object that consists (of? a) series of integer numbers, which we can iterate using a for loop.

In Scheme, a solution using tail-recursion is straightforward:

(define (find-primes-up-through n)
;; We will call an auxiliary that starts at 1 and tail-recurses till it gets to n
(find-primes-up-through-aux n 1))

(define (find-primes-up-through-aux n x)
(if (> x n)
;; If x is greater than n, we are done.
#t
;; Otherwise, test x to see if it is a prime,
;; then increase x by 1 and tail-recurse.
(begin
(is-prime x)
(find-primes-up-through-aux n (+ x 1)))))

(define (is-prime n)
;; We will call an auxiliary that tests to see if 2 divides n, then tail
;; recurses on larger values of the proposed divisor.
(is-prime-aux n 2))

(define (is-prime-aux n x)
(if (> x (sqrt n))
;; If the divisor is bigger than (sqrt x), we are done testing n
;; and it is prime.
(begin (display n) (display " is a prime number") (newline))
;; If not then test to see if x divides n.
(if (= (modulo n x) 0)
;; If so, describe the division and return -- we are done testing n.
(begin
(display n) (display " equals ") (display x) (display " * ") (display (/ n x)) (newline))
;; If not, increase x by 1 and tail-recurse.
(is-prime-aux n (+ x 1)))))

(find-primes-up-through 10)
1 is a prime number
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number
6 equals 2 * 3
7 is a prime number
8 equals 2 * 4
9 equals 3 * 3
10 equals 2 * 5
#t

Oops, make that comment:
;; If the divisor is bigger than (sqrt n), we are done testing n ...

On Sunday, March 5, 2023 at 9:03:35 PM UTC-8, Hen Hanna wrote:
> in CL (Common Lisp) , i'd use catch/throw ?
>
> in Scheme , i'd have to use Call/cc ?
>
> https://docs.python.org/3/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops
>
> for n in range(2, 10):
> for x in range(2, n):
> if n % x == 0:
> print(n, 'equals', x, '*', n//x)
> break
> else:
> # loop fell through without finding a factor
> print(n, 'is a prime number')
>
>
> 2 is a prime number
> 3 is a prime number
> 4 equals 2 * 2
> 5 is a prime number
> 6 equals 2 * 3
> 7 is a prime number
> 8 equals 2 * 4
> 9 equals 3 * 3
>
>
> the keyword ELSE doesn't quite sound right.

i think this matching For-Else is kind-of neat and
(pls correct me if i'm mistaken)
the whole point of it is... i can avoid writing a Helping-Function, as ....

def getDivisor( n ):
for x in range(2, n):
if n % x == 0: return(x)
return(False)

for n in range(2, 10):
Div= getDivisor( n )
if Div: print('\t', n, '=', Div, '*', n//Div)
else: print(n, 'is Prime')

______________________
i don't know if i like :=

for n in range(2, 10):
if Div:= getDivisor( n ) : print('\t', n, '=', Div, '*', n//Div)
else: print(n, 'is Prime')

* Madhu <m3ilfdaft1.fsf @leonis4.robolove.meer.net> :
Wrote on Tue, 07 Mar 2023 00:05:38 +0530:
> * Alan Bawden <86edq1wz9h.fsf @williamsburg.bawden.org> :
> Wrote on Mon, 06 Mar 2023 12:44:26 -0500:
>> No, it really does match the 'for x'. This use of 'else' is a
>> (controversial) feature of Python. The code above is quoted directly
>> from the Python tutorial at the given URL, which nicely explains how
>> it works.
> Thanks for pointing it out. ("My blushes if it were possible]")

I had a chance to revisit this, and suggest to myself that the for-else
feature is another not-really-elegant quirk of the python designers'
minds --- if the idea is to offer control-flow

I want to modify some python code with a for loop:
```
for x in [XXX]:
DO-THINGS
```
to skip DO-THINGS if x was in another set [YYY], i.e. the desired
control flow is

```
for x in [XXX]:
for y in [YYY]:
if x == y:
CONTINUE-OUTER-LOOP
DO-THINGS
```

Python of course doesn't have CONTINUE-OUTER-LOOP. The for-else
construct suggests I can expect python to continue evaluation of the
outer loop when breaking out of the inner loop. However it doesn't cover
that. I have to explicitly do, in the inner loop
```
skip = false
for y in [YYY]:
if x == y:
skip = true
break
else:
pass # else is of no help here
if skip continue # the outer loop
```
and the control flow is as clunky as it can be.

>> It's controversial, not because there is something wrong with the
>> feature itself, but because many people find naming it 'else' to be
>> confusing.