[Дима_]

Вот эта тема (а точнее оффтопное направление по поводу функций\операторов заданное уважаемым ShaggyDoc'ом) натолкнуло меня на мысль о возможности совместить две, одни из самых интересных, возможности LISP - рекурсия и lambda. Вот что из этого вышло:

Код:

[Выделить все]

(defun recurs (p f x);создает рекурсивный список до выполнения условия p функции f с начальным аргументом х
  (if (p x)
      (cons x nil)
      (cons x (recurs p f (f x)))))

При всей малости кода функции, по крайней мере лично для меня, она открывет "большие удобства" а именно - если внутри лямбды хочеться используеть рекурсии - то совсем не обязательно выводить их в новую функцию:
Пример1 - получить список от 0 до х (целое, положительное):
классика:

Код:

[Выделить все]

(defun test (x)
(if (zerop x) (cons x nil) (cons x (test (1- x)))))
(reverse (test 10))

аналог:

Код:

[Выделить все]

(reverse (recurs zerop 1- 10))

Пример2 (посложнее) - выровнять слово str пробелами с правой стороны до 10-ти символов:
классика:

Код:

[Выделить все]

(defun rovno (str)
(if (>=(strlen str) 10) str (rovno (strcat str " "))))
(rovno "test")

аналог:

Код:

[Выделить все]

(last (recurs (lambda (str) (>= (strlen str) 10)) (lambda (str) (strcat str " ")) "test"))

Количество кода в общем-то не уменьшается, но дает возможность использовать рекурсию внутри ламбды - не "засоряя" имена.
p.s. - немного подправил функцию - чтоб сохранял последний аргумент

[SetQ]

Попробовал написать факториал, что-то у меня уж совсем код разросся:

Код:

[Выделить все]

 (DeFun fact1  (x)
  (if (zerop x)
    1
    (* x (fact1 (1- x)))))

(DeFun fact2  (x)
  (caar
    (reverse
      (recurs (lambda (x) (zerop (cdr x)))
	      (lambda (x) (cons (* (car x) (cdr x)) (1- (cdr x))))
	      (cons 1 x)))))

Наверное, можно как-то короче.

[Дима_]

Так или эдак - по размеру почти байт в байт:

Код:

[Выделить все]

 (defun fact3(x)
  (apply '* (recurs (lambda (x) (= x 1)) 1- x)))
(defun fact4(x)
  (apply '* (cdr (reverse (recurs zerop 1- x)))))

[unfold]

Поздравляю, вы почти изобрели функцию unfold из Scheme.
Вот вам ее итеративная (для отважных, в комментарии - рекурсивная) реализация на AutoLISP.

Код:

[Выделить все]

 
;;; unfold p f g seed => result-list
;;; p - determines when to stop unfolding.
;;; f - maps each seed value to the corresponding list element.
;;; g - maps each seed value to next seed value.
;;; seed - the state value for the unfold.
;;; (defun unfold (p f g seed)
;;;   (if (not (apply p (list seed)))
;;;       (cons (apply f (list seed))
;;;             (unfold p f g (apply g (list seed))))))
;;; Fundamental list constructor.
;;; (unfold (function (lambda (x) (> x 10))) 'sqr '1+ 1)
;;; => (1 4 9 16 25 36 49 64 81 100)
(defun unfold (p f g seed / lst)
  (while (not (apply p (list seed)))
    (setq lst (cons (apply f (list seed)) lst)
          seed (apply g (list seed))))
  (reverse lst))

[Веселин]

Ничего не понял. Так есть в Autolisp пространство имён или нет?

[Дима_]

Я в общем тоже не понял - при чемздесь эта тема и пространства имен - но по сути вопроса - в автолиспе их нет - ни в лисп смысле, не в смысле императивных язвыков - эти омонимы сильно различаются, в автолиспе есть только локализированные имена.

[kakt00z]

просто unfold построил еще и 3-й этаж (думаю Дима_ - прото не успел) )))
но это всеравно не идет ни в какое сравнение с шедеврами :
1. (apply 'mapcar (cons 'list[list]))
2. была гдето функция concat вродебы для слияния двух списков вроде даж Димы_
а это - частный, зачастую реализуемый 1-2 раза в решении, и короче, интерфейс (! ИМХО)