From Newsgroup: comp.lang.scheme

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

(define (max-by func List)
(fold
(lambda (x best)
(let1 score (func x)
(cond ((or (not (car best)) (> score (car best)))
`(,score (,x)))
((= score (car best)) (push! (cadr best) x) best)
(#t best))))
'(#f ())
List))

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

Shorter:

(max-by (cut modulo <> 5) '(22 23 24 25 26 27 28 29))


--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.scheme

David Steuber wrote:

Try doing this in C++, Python, or whatever:

(do ((a 1 b) (b 1 (+ a b)))
(nil a)
(print a))

That ought to be:

(do ((a 0 b) (b 1 (+ a b)))
(nil)
(print b))

In Gauche Scheme using do_:

(do_ ((a 0 b) (b 1 (+ a b)))
()
(print b))

Another way:

(do_ (: a 0 b b 1 (+ a b))
()
(print b))

Given:

(define-syntax do_-aux
(syntax-rules ( <> @ :in :collect :below :to : )
[ (do_-aux ((x what <>) more ...) (seen ...) stuff ...)
(do_-aux (more ...) (seen ... (x what what)) stuff ...) ]
[ (do_-aux ((x a :below b) more ...) seen lets (bool z ...) stuff ...)
(do_-aux ((top b)
(x a (+ x 1)) more ...) seen lets
((or (>= x top) bool) z ...) stuff ...) ]
[ (do_-aux ((x a :to b) more ...) stuff ...)
(do_-aux ((x a :below (+ 1 b)) more ...) stuff ...) ]
[ (do_-aux ((x :in seq) more ...) seen (lets ...) (bool z ...) stuff ...)
(do_-aux ((x (and (pair? the-list) (car the-list)) <>) more ...)
seen
(lets ... (the-list seq))
((or (null? the-list) (begin (pop! the-list) #f) bool) z ...)
stuff ...) ]
[ (do_-aux ((accum :collect x) more ...) stuff ...)
(do_-aux ((accum '() (cons x accum)) more ...) stuff ...) ]
[ (do_-aux (: v init update more ...) (seen ...) stuff ...)
(do_-aux (: more ...) (seen ... (v init update)) stuff ...) ]
[ (do_-aux (:) stuff ...)
(do_-aux () stuff ...) ]
[ (do_-aux (spec more ...) (seen ...) stuff ...)
(do_-aux (more ...) (seen ... spec) stuff ...) ]
[ (do_-aux () seen lets (bool y ... @ result) stuff ...)
(do_-aux () seen lets (bool y ... (reverse result)) stuff ...) ]
[ (do_-aux () seen (lets ...) more ...)
(let (lets ...)
(do seen more ...))
] ))
(define-syntax do_
(syntax-rules ()
[ (do_ specs () more ...)
(do_ specs (#f) more ...) ]
[ (do_ specs more ...)
(do_-aux specs () () more ...) ] ))
--- Synchronet 3.21a-Linux NewsLink 1.2

From Newsgroup: comp.lang.scheme

Here's a more realistic example that illustrates exactly the
opposite point. Take the task of finding the sum of the square of a
bunch of numbers.
Do people really think to themselves when they do this task:
Umm first make a variable called sum
then set that variable sum to zero.
Then get the next number in the list,
square it,
add it to the old value of sum,
store the resulting value into sum,
then get the next variable,etc....

No they they think: sum up the square of a bunch of numbers.
This has an almost direct translation to the lisp style:
(apply '+ (mapcar #'(lambda(x)(* x x)) numlist)).

Well..
sum (map (\x -> x ** 2) [1..10])
in Haskell, or
sum (map ((lambda x: x ** 2), range(1,11)))

Too much line noise ;-)

sum([x*x for x in range(1,11)])

It's shorter in Gauche Scheme.

(use srfi-42) ;; sum-ec

(sum-ec (: n 11) (* n n))
===>
385

Less condensed:

(sum-ec (:range n 1 11) (* n n))

Then I would say that a clearer way to express what a person think is:
(loop for number in numberlist sum (expt number power))

Gauche Scheme

(use srfi-42) ;; sum-ec

(sum-ec (:list n '(3 4 5 6)) (* n n))
===>
86
--- Synchronet 3.22a-Linux NewsLink 1.2

From Newsgroup: comp.lang.scheme

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

(define (max-by func List)
(fold
(lambda (x best)
(let1 score (func x)
(cond ((or (not (car best)) (> score (car best)))
`(,score (,x)))
((= score (car best)) (push! (cadr best) x) best)
(#t best))))
'(#f ())
List))

(max-by (lambda(x) (modulo x 5)) '(22 23 24 25 26 27 28 29))
===>
(4 (29 24))
--- Synchronet 3.22a-Linux NewsLink 1.2