Pascal Costanza wrote:

> > Indentation in Lisp is not clear enough. Let's look at an example from
> > http://www-users.cs.umn.edu/~gini/aiprog/graham/onlisp.lisp:
> >
> > (defun mostn (fn lst)
> > (if (null lst)
> > (values nil nil)
> > (let ((result (list (car lst)))
> > (max (funcall fn (car lst))))
> > (dolist (obj (cdr lst))
> > (let ((score (funcall fn obj)))
> > (cond ((> score max)
> > (setq max score
> > result (list obj)))
> > ((= score max)
> > (push obj result)))))
> > (values (nreverse result) max))))
> >
> > Note that only one pair of adjacent lines is indented by the same amount.
> > Other alignments are in the middle of lines.
> >
> > Here is a straightforward translation into my dream language; note that
> > there aren't a lot of parens despite insignificant indentation and despite
> > using braces (like C) instead of bracketing keywords (like Pascal):
> >
> > def mostn Fun [] = [], null;
> > def mostn Fun (First\List) {
> > var Result = [First];
> > var Max = Fun First;
> > each List ?Obj {
> > let Score = Fun Obj;
> > if Score > Max {Max = Score; Result = [Obj]}
> > if Score == Max {Result = Obj\Result}
> > };
> > reversed Result, Max
> > };
>
> Apparently, Paul Graham doesn't like CLOS nor the LOOP macro. Here is
> another verson in Common Lisp (and this is not a dream language ;):
>
> (defmethod mostn (fn (list (eql nil)))
> (declare (ignore fn list))
> (values nil nil))
>
> (defmethod mostn (fn list)
> (loop with result = (list (car list))
> with max = (funcall fn (car list))
> for object in (cdr list)
> for score = (funcall fn object)
> when (> score max) do (setq max score
> result (list object))
> when (= score max) do (push object result)
> finally return (values (nreverse result) max)))

Gauche Scheme

(use gauche.collection) ;; fold2

(define (max-by fn lst)
(if (null? lst)
(values '() #f)
(fold2
(lambda (x best worth)
(let ((score (fn x)))
(cond ((> score worth) (values (list x) score))
((= score worth) (values (cons x best) worth))
(#t (values best worth)))))
(take lst 1) (fn (car lst))
(cdr lst))))

(max-by (lambda(x) (modulo x 5)) '(22 23 24 25 26 27 28 29))

===>
(29 24)
4

On 6/28/2024 2:54 PM, B. Pym wrote:
> Pascal Costanza wrote:
>
>>> Indentation in Lisp is not clear enough. Let's look at an example from
>>> http://www-users.cs.umn.edu/~gini/aiprog/graham/onlisp.lisp:
>>>
>>> (defun mostn (fn lst)
>>> (if (null lst)
>>> (values nil nil)
>>> (let ((result (list (car lst)))
>>> (max (funcall fn (car lst))))
>>> (dolist (obj (cdr lst))
>>> (let ((score (funcall fn obj)))
>>> (cond ((> score max)
>>> (setq max score
>>> result (list obj)))
>>> ((= score max)
>>> (push obj result)))))
>>> (values (nreverse result) max))))
>>>
>>> Note that only one pair of adjacent lines is indented by the same amount.
>>> Other alignments are in the middle of lines.
>>>
>>> Here is a straightforward translation into my dream language; note that
>>> there aren't a lot of parens despite insignificant indentation and despite
>>> using braces (like C) instead of bracketing keywords (like Pascal):
>>>
>>> def mostn Fun [] = [], null;
>>> def mostn Fun (First\List) {
>>> var Result = [First];
>>> var Max = Fun First;
>>> each List ?Obj {
>>> let Score = Fun Obj;
>>> if Score > Max {Max = Score; Result = [Obj]}
>>> if Score == Max {Result = Obj\Result}
>>> };
>>> reversed Result, Max
>>> };
>>
>> Apparently, Paul Graham doesn't like CLOS nor the LOOP macro. Here is
>> another verson in Common Lisp (and this is not a dream language ;):
>>
>> (defmethod mostn (fn (list (eql nil)))
>> (declare (ignore fn list))
>> (values nil nil))
>>
>> (defmethod mostn (fn list)
>> (loop with result = (list (car list))
>> with max = (funcall fn (car list))
>> for object in (cdr list)
>> for score = (funcall fn object)
>> when (> score max) do (setq max score
>> result (list object))
>> when (= score max) do (push object result)
>> finally return (values (nreverse result) max)))
>
> Gauche Scheme
>
> (use gauche.collection) ;; fold2
>
> (define (max-by fn lst)
> (if (null? lst)
> (values '() #f)
> (fold2
> (lambda (x best worth)
> (let ((score (fn x)))
> (cond ((> score worth) (values (list x) score))
> ((= score worth) (values (cons x best) worth))
> (#t (values best worth)))))
> (take lst 1) (fn (car lst))
> (cdr lst))))
>
> (max-by (lambda(x) (modulo x 5)) '(22 23 24 25 26 27 28 29))
>
> ===>
> (29 24)
> 4

How do i avoid using -99999 ???

(define (print x) (newline) (write x) (newline))

(define (max-by fn Lis) (maxBy fn Lis '() -99999))

(define (maxBy fn x cLis cMax)
(cond
((null? x) (cons (reverse x) cMax))
((= (fn (car x)) cMax) (maxBy fn (cdr x) (cons (car x) cLis) cMax))
((> (fn (car x)) cMax) (maxBy fn (cdr x) (list (car x)) (fn (car x))))
(else (maxBy fn (cdr x) cLis cMax))))

(print (max-by (lambda(x) (modulo x 5)) '(4 5 6 7 8 9 3 44)))
(print (max-by (lambda(x) (modulo x 5)) '(24 25 26 27 28 29 33 44)))

On 6/28/2024 8:48 PM, HenHanna wrote:
> On 6/28/2024 2:54 PM, B. Pym wrote:
>> Pascal Costanza wrote:
>>
>>>> Indentation in Lisp is not clear enough. Let's look at an example from
>>>> http://www-users.cs.umn.edu/~gini/aiprog/graham/onlisp.lisp:
>>>>
>>>> (defun mostn (fn lst)
>>>>    (if (null lst)
>>>>        (values nil nil)
>>>>        (let ((result (list (car lst)))
>>>>              (max (funcall fn (car lst))))
>>>>          (dolist (obj (cdr lst))
>>>>            (let ((score (funcall fn obj)))
>>>>              (cond ((> score max)
>>>>                     (setq max    score
>>>>                           result (list obj)))
>>>>                    ((= score max)
>>>>                     (push obj result)))))
>>>>          (values (nreverse result) max))))
>>>>
>>>> Note that only one pair of adjacent lines is indented by the same
>>>> amount.
>>>> Other alignments are in the middle of lines.
>>>>
>>>> Here is a straightforward translation into my dream language; note that
>>>> there aren't a lot of parens despite insignificant indentation and
>>>> despite
>>>> using braces (like C) instead of bracketing keywords (like Pascal):
>>>>
>>>> def mostn Fun [] = [], null;
>>>> def mostn Fun (First\List) {
>>>>     var Result = [First];
>>>>     var Max = Fun First;
>>>>     each List ?Obj {
>>>>        let Score = Fun Obj;
>>>>        if Score >  Max {Max = Score; Result = [Obj]}
>>>>        if Score == Max {Result = Obj\Result}
>>>>     };
>>>>     reversed Result, Max
>>>> };
>>>
>>> Apparently, Paul Graham doesn't like CLOS nor the LOOP macro. Here is
>>> another verson in Common Lisp (and this is not a dream language ;):
>>>
>>> (defmethod mostn (fn (list (eql nil)))
>>>     (declare (ignore fn list))
>>>     (values nil nil))
>>>
>>> (defmethod mostn (fn list)
>>>     (loop with result = (list (car list))
>>>           with max = (funcall fn (car list))
>>>           for object in (cdr list)
>>>           for score = (funcall fn object)
>>>           when (> score max) do (setq max score
>>>                                       result (list object))
>>>           when (= score max) do (push object result)
>>>           finally return (values (nreverse result) max)))
>>
>> Gauche Scheme
>>
>> (use gauche.collection) ;; fold2
>>
>> (define (max-by fn lst)
>>    (if (null? lst)
>>      (values '() #f)
>>      (fold2
>>        (lambda (x best worth)
>>          (let ((score (fn x)))
>>            (cond ((> score worth) (values (list x) score))
>>                  ((= score worth) (values (cons x best) worth))
>>                  (#t (values best worth)))))
>>        (take lst 1) (fn (car lst))
>>        (cdr lst))))
>>
>> (max-by (lambda(x) (modulo x 5)) '(22 23 24 25 26 27 28 29))
>>
>>    ===>
>> (29 24)
>> 4
>
>
>
> How do i avoid using   -99999   ???
>
>
> (define (print x) (newline) (write x) (newline))
>
> (define (max-by fn Lis)    (maxBy fn Lis '() -99999))
>
> (define (maxBy fn x cLis cMax)
>  (cond
>   ((null? x)             (cons (reverse x) cMax))
>   ((= (fn (car x)) cMax) (maxBy fn (cdr x) (cons (car x) cLis) cMax))
>   ((> (fn (car x)) cMax) (maxBy fn (cdr x) (list (car x)) (fn (car x))))
>   (else                  (maxBy fn (cdr x) cLis cMax))))
>
> (print (max-by (lambda(x) (modulo x 5)) '(4 5 6 7 8 9 3 44)))
> (print (max-by (lambda(x) (modulo x 5)) '(24 25 26 27 28 29 33 44)))
In Common Lisp, symbolic constants were defined for the IEEE plus and
minus infinities. I don't recall the syntax at the moment but do
remember they were quite useful in making certain codes easier to read
and understand.
--
Jeff Barnett

On 6/28/2024 8:11 PM, Jeff Barnett wrote:
> On 6/28/2024 8:48 PM, HenHanna wrote:
>> On 6/28/2024 2:54 PM, B. Pym wrote:
>>> Pascal Costanza wrote:
>>>
>>>>> Indentation in Lisp is not clear enough. Let's look at an example from
>>>>> http://www-users.cs.umn.edu/~gini/aiprog/graham/onlisp.lisp:
>>>>>
>>>>> (defun mostn (fn lst)
>>>>>    (if (null lst)
>>>>>        (values nil nil)
>>>>>        (let ((result (list (car lst)))
>>>>>              (max (funcall fn (car lst))))
>>>>>          (dolist (obj (cdr lst))
>>>>>            (let ((score (funcall fn obj)))
>>>>>              (cond ((> score max)
>>>>>                     (setq max    score
>>>>>                           result (list obj)))
>>>>>                    ((= score max)
>>>>>                     (push obj result)))))
>>>>>          (values (nreverse result) max))))
>>>>>
>>>>> Note that only one pair of adjacent lines is indented by the same
>>>>> amount.
>>>>> Other alignments are in the middle of lines.
>>>>>
>>>>> Here is a straightforward translation into my dream language; note
>>>>> that
>>>>> there aren't a lot of parens despite insignificant indentation and
>>>>> despite
>>>>> using braces (like C) instead of bracketing keywords (like Pascal):
>>>>>
>>>>> def mostn Fun [] = [], null;
>>>>> def mostn Fun (First\List) {
>>>>>     var Result = [First];
>>>>>     var Max = Fun First;
>>>>>     each List ?Obj {
>>>>>        let Score = Fun Obj;
>>>>>        if Score >  Max {Max = Score; Result = [Obj]}
>>>>>        if Score == Max {Result = Obj\Result}
>>>>>     };
>>>>>     reversed Result, Max
>>>>> };
>>>>
>>>> Apparently, Paul Graham doesn't like CLOS nor the LOOP macro. Here is
>>>> another verson in Common Lisp (and this is not a dream language ;):
>>>>
>>>> (defmethod mostn (fn (list (eql nil)))
>>>>     (declare (ignore fn list))
>>>>     (values nil nil))
>>>>
>>>> (defmethod mostn (fn list)
>>>>     (loop with result = (list (car list))
>>>>           with max = (funcall fn (car list))
>>>>           for object in (cdr list)
>>>>           for score = (funcall fn object)
>>>>           when (> score max) do (setq max score
>>>>                                       result (list object))
>>>>           when (= score max) do (push object result)
>>>>           finally return (values (nreverse result) max)))
>>>
>>> Gauche Scheme
>>>
>>> (use gauche.collection) ;; fold2
>>>
>>> (define (max-by fn lst)
>>>    (if (null? lst)
>>>      (values '() #f)
>>>      (fold2
>>>        (lambda (x best worth)
>>>          (let ((score (fn x)))
>>>            (cond ((> score worth) (values (list x) score))
>>>                  ((= score worth) (values (cons x best) worth))
>>>                  (#t (values best worth)))))
>>>        (take lst 1) (fn (car lst))
>>>        (cdr lst))))
>>>
>>> (max-by (lambda(x) (modulo x 5)) '(22 23 24 25 26 27 28 29))
>>>
>>>    ===>
>>> (29 24)
>>> 4
>>
>>
>>
>> How do i avoid using   -99999   ???
>>
>>
>> (define (print x) (newline) (write x) (newline))
>>
>> (define (max-by fn Lis)    (maxBy fn Lis '() -99999))
>>
>> (define (maxBy fn x cLis cMax)
>>   (cond
>>    ((null? x)             (cons (reverse x) cMax))
>>    ((= (fn (car x)) cMax) (maxBy fn (cdr x) (cons (car x) cLis) cMax))
>>    ((> (fn (car x)) cMax) (maxBy fn (cdr x) (list (car x)) (fn (car x))))
>>    (else                  (maxBy fn (cdr x) cLis cMax))))
>>
>> (print (max-by (lambda(x) (modulo x 5)) '(4 5 6 7 8 9 3 44)))
>> (print (max-by (lambda(x) (modulo x 5)) '(24 25 26 27 28 29 33 44)))
>
> In Common Lisp, symbolic constants were defined for the IEEE plus and
> minus infinities. I don't recall the syntax at the moment but do
> remember they were quite useful in making certain codes easier to read
> and understand.

Thanks!!!

Yes, some Scheme implementations support negative infinity, often
denoted as -inf.0.

Here's a breakdown:

Concept: Negative infinity represents a value on the number line
that is infinitely far in the negative direction.

Representation: The specific notation for negative infinity can
vary depending on the Scheme implementation. However, -inf.0 is a common
representation, where:

-inf signifies negative infinity.

..0 indicates that it's an inexact number (as opposed to an exact
mathematical concept of negative infinity).

Not all Scheme implementations are guaranteed to support negative
infinity.

The latest Scheme standard, R7RS-small, recommends the use of +inf.0,
-inf.0, and +nan.0 for positive infinity, negative infinity, and
Not-a-Number, respectively.

Jeff Barnett <jbb@notatt.com> writes:
> In Common Lisp, symbolic constants were defined for the IEEE plus and
> minus infinities. I don't recall the syntax at the moment but do
> remember they were quite useful in making certain codes easier to read
> and understand.

That's pretty horrendous either way (-99999 or -INF) . Better to return
an empty list in the event that that the input is empty. Also if I
understand the intention of that function, you really have to make two
passes through the list, which is simpler anyway.

On Tue, 02 Jul 2024 16:49:33 -0700, Paul Rubin wrote:

> Jeff Barnett <jbb@notatt.com> writes:
>
>> In Common Lisp, symbolic constants were defined for the IEEE plus and
>> minus infinities.
>
> That's pretty horrendous either way (-99999 or -INF) . Better to return
> an empty list in the event that that the input is empty.

If a function like “max” or “min” is defined to return a number, then it
makes sense that the maximum of an empty list should be -∞, and the
minimum should be +∞. Being numbers, they can be compared with other
numbers in the usual way, and a lot of special cases no longer become
special.

Lawrence D'Oliveiro <ldo@nz.invalid> writes:
> If a function like “max” or “min” is defined to return a number,

They are defined to return the larger or smaller of two members of any
datatype with an order relation, e.g. lexicographic order on strings.
There is no infinity for strings. There's also none for integers, for
that matter.

> then it makes sense that the maximum of an empty list should be -∞,

Meh, it's just undefined. Otherwise you can't tell whether the list is
empty or actually contains -∞ as a value.

> and a lot of special cases no longer become special.

More likely a lot of errors go undetected. Better to handle the special
cases in some sane way, if they can happen in the program and need
handling.

On 7/2/2024 6:15 PM, Paul Rubin wrote:
> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>> If a function like “max” or “min” is defined to return a number,
>
> They are defined to return the larger or smaller of two members of any
> datatype with an order relation, e.g. lexicographic order on strings.
> There is no infinity for strings. There's also none for integers, for
> that matter.
>
>> then it makes sense that the maximum of an empty list should be -∞,
>
> Meh, it's just undefined. Otherwise you can't tell whether the list is
> empty or actually contains -∞ as a value.
Consider a SUM of a set of integers: mathematicians define that operator
to return 0 for the empty set
Similarly:
MAX empty-set = -oo
MIN empty-set = +oo
PRODUCT empty-set = 1
and, in general,
GROUP OPERATOR empty-set = group-identity-element
This convention makes a whole lot of sense because, for one thing, it
makes definition of indefinite number of argument functions very easy.
For example SUM nil = 0
and SUM (CONS x list) = x + SUM list
If you try this sort of definition for MAX, the only value in all known
mathematics that can replace 0 in the above is -oo.
If you want to get into details, what I've said here applies to abelian
groups; we need to be careful about order in other settings.
>> and a lot of special cases no longer become special.
>
> More likely a lot of errors go undetected. Better to handle the special
> cases in some sane way, if they can happen in the program and need
> handling.
PS oo is meant to stand for numerical infinity.
--
Jeff Barnett

On Tue, 02 Jul 2024 17:15:56 -0700, Paul Rubin wrote:

> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>
>> then it makes sense that the maximum of an empty list should be -∞,
>
> Meh, it's just undefined. Otherwise you can't tell whether the list is
> empty or actually contains -∞ as a value.

If it does contain that as a value, then it obviously doesn’t contain any
other values. There is an infinity of combinations of arguments to max
that give -∞ as the function result; what’s so special about
distinguishing the empty argument list?

Lawrence D'Oliveiro <ldo@nz.invalid> writes:
> There is an infinity of combinations of arguments to max that give -∞
> as the function result; what’s so special about distinguishing the
> empty argument list?

max is a two-argument function, just like +. If you don't have two args
to give it, there is no result.

Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>> max is a two-argument function, just like +.
> Not in all the good languages.

Ah ok, yeah for the variadic versions in CL and Scheme, (max 2) gives 2
but (max) throws a wrong-number-of-args error. In Haskell, max always
takes two args of an ordered type, and maximum takes a list arg.
maximum [2] gives 2 but maximum [] throws an empty list exception.
maximum just applies max repeatedly, like using reduce in Lisp.

On 7/3/2024 7:11 PM, Paul Rubin wrote:
> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>>> max is a two-argument function, just like +.
>> Not in all the good languages.
>
> Ah ok, yeah for the variadic versions in CL and Scheme, (max 2) gives 2
> but (max) throws a wrong-number-of-args error. In Haskell, max always
> takes two args of an ordered type, and maximum takes a list arg.
> maximum [2] gives 2 but maximum [] throws an empty list exception.
> maximum just applies max repeatedly, like using reduce in Lisp.

I believe that (max) and (min) would work just fine in CL if including
the IEEE infinities was required to be conforming. Without them or
something similar, it would be hard to make a sensible definition.

Also refresh my memory: doesn't CL define a map-like function that looks
like (MAP! binary-op list identity-element) so that:
(MAP! #'+ list 0) is the sum of the elements in the list
(MAP! #'* list 10 is the product of the elements in list
(MAP! #'max list -oo) is the max element in the list
(MAP! #'min list +oo) is the minimum element in the list
(MAP! #'append list nil) is the list made by appending the sublists
of list
etc.
In all of these if the list argument is nil, the result is the identity
element.
--
Jeff Barnett

On 2024-07-04, Jeff Barnett <jbb@notatt.com> wrote:
> I believe that (max) and (min) would work just fine in CL if including
> the IEEE infinities was required to be conforming. Without them or
> something similar, it would be hard to make a sensible definition.
>
> Also refresh my memory: doesn't CL define a map-like function that looks
> like (MAP! binary-op list identity-element) so that:
> (MAP! #'+ list 0) is the sum of the elements in the list
> (MAP! #'* list 10 is the product of the elements in list
> (MAP! #'max list -oo) is the max element in the list
> (MAP! #'min list +oo) is the minimum element in the list
> (MAP! #'append list nil) is the list made by appending the sublists
> of list
> etc.
> In all of these if the list argument is nil, the result is the identity
> element.

(reduce #'+ list :initial-value 0)

- If :initial-value is present it's as if it is prepended to the list.

- When the effective list (main input plus any initial value)
contains only one element, that element is returned without the
function being called.

- When the effective list is empty (main input is empty and no
initial value is specified), reduce calls the function with
no arguments to obtain the identity element, which is returned.
This obviously works for + and *.

- :from-end t can be used to obtain a right reduction.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>> In Haskell, max always takes two args of an ordered type, and maximum
>> takes a list arg.

> Seems unnecessary to have two functions when one will do.

In Haskell that doesn't really make sense. Haskell functions actually
all take only one arg. Multi-arg functions work by currying. So
"max [1,2,3]" gives a function that compares [1,2,3] to a list you
supply. The default order relation on lists compares lexicographically.

> But then, Python max and min work for things besides numbers.

Yeah I was surprised to find that in Lisp and Scheme, they only work on
numbers. Haskell has an Ord typeclass, which is like an interface for
datatypes that support comparison. max and min work for any type that
implements Ord.

Lawrence D'Oliveiro <ldo@nz.invalid> writes:

> On Wed, 03 Jul 2024 18:11:35 -0700, Paul Rubin wrote:
>
>> In Haskell, max always
>> takes two args of an ordered type, and maximum takes a list arg.
>> maximum [2] gives 2 but maximum [] throws an empty list exception.
>> maximum just applies max repeatedly, like using reduce in Lisp.
>
> Seems unnecessary to have two functions when one will do.

Haskell is a typed language so the two functions are quite different,
though the list version can be trivially defined from the binary
function.

--
Ben.