Path: ...!3.eu.feeder.erje.net!2.eu.feeder.erje.net!feeder.erje.net!eternal-september.org!feeder3.eternal-september.org!news.eternal-september.org!.POSTED!not-for-mail
From: HenHanna <HenHanna@devnull.tb>
Newsgroups: comp.lang.lisp
Subject: Re: Why don't people like lisp?
Date: Fri, 28 Jun 2024 19:48:46 -0700
Organization: A noiseless patient Spider
Lines: 97
Message-ID: <v5nsmf$3nsv3$1@dont-email.me>
References: <v5nbe0$3he95$1@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Sat, 29 Jun 2024 04:48:48 +0200 (CEST)
Injection-Info: dont-email.me; posting-host="a284b8b9998909dad96ddd00bdf8ce4c";
	logging-data="3929059"; mail-complaints-to="abuse@eternal-september.org";	posting-account="U2FsdGVkX1+gy91o8V/rZyKB+3OgREydfYv8GPSG5fs="
User-Agent: Mozilla Thunderbird
Cancel-Lock: sha1:P4R35zHRftpW5jUBfKsGH1hNIYw=
In-Reply-To: <v5nbe0$3he95$1@dont-email.me>
Content-Language: en-US
Bytes: 4353

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)))