Дана схема метрополитена, найти кратчайший путь между станциями

(defun F (Net Init Term &optional (Route_list (list (list Init))))
 (apply
 '(lambda (result next)
   (if result
    (mapcar 'reverse result)
    (F Net Init Term (UPDATE_ROUTE Net next))))
  (EXTRACT_RESULT Term Route_list)))
 
(defun EXTRACT_RESULT (Term Route_list)
 (if Route_list
  (apply
  '(lambda (route result next)
    (if (equal (car route) Term)
     (list (cons route result) next)
     (list result (cons route next))))
   (cons
    (car Route_list)
    (EXTRACT_RESULT Term (cdr Route_list))))
 '(nil nil)))
 
(defun UPDATE_ROUTE (Net Route_list)
 (apply 'append
  (mapcar
  '(lambda (route)
    (mapcar
    '(lambda (link)
      (cons link route))
     (cdr (assoc (car route) Net))))
   Route_list)))

(setq sampleNet
'((A B)(B A C)(C B D)(D C E X)(E D F O)(F E J)(G H)(H G I W)(I H J)
  (J I K F)(K J T Z)(L M)(M L N)(N M O Y)(O N P E)(P O Q)(Q P R U)
  (R P S)(S R)(T K U)(U T V Q)(V U W)(W V X H)(X W Y D)(Y X Z N)
  (Z Y K)))

(F sampleNet 'B 'T)

((B C D E F J K T) (B C D X W V U T) (B C D X Y Z K T))

;; список вершин, связанных с данной и не посещенных             
             
(defun getall (v graph chk) 
 (remove-if #'(lambda (z) (member z chk))
                 (mapcar #'(lambda (y) (if (eq (car y) v) (cadr y) (car y))) 
                        (remove-if-not #'(lambda (x) (member v x)) graph))))
  
;; Построение стягивающего дерева
             
(defun bfsi (graph &optional (chk '(1)) (queue '(1)))
   (cond ((null queue) nil)
         (t (let ((n (getall (car queue) graph chk)))
                 (append (mapcar #'(lambda (x) (list (car queue) x)) n)
                         (bfsi graph (append chk n) (append (cdr queue) n)))))))
 
(defun bfs (graph v)
  (bfsi graph (list v) (list v)))                         
 
;; Поиск пути  в стягивающем дереве
                 
(defun find-path (stree v1 v2 &optional path)
  (if (eq v1 (caar path)) path
         (dolist (i stree nil)
           (when (eq (cadr i) v2) (return (find-path stree v1 (car i) (cons i path)))))))
         
;; ведущая программа: поиск в графе graph кратчайшего пути от vbeg до vend
        
(defun shortest-path (graph vbeg vend)
  (let ((stree (bfs graph vbeg)))
       (find-path stree vbeg vend))) 
 
(shortest-path '((1 2) (1 3) (2 4) (3 4) (4 5) (4 6) (4 7) (5 6) (6 7) (7 8) (7 9) (8 10) (8 11) (9 10) (9 11)) 4 11)
 
==> ((4 7) (7 8) (8 11))

(defun DIJKSTRA (Net Init Term &optional (Tmp nil) (Fix (list (cons Init 0))))
 ((lambda (fix_label fix_value)
   (if (equal fix_label Term) fix_value
    (apply 
     #'(lambda (newTmp newFix)
      (DIJKSTRA Net Init Term newTmp newFix))
     (TRANSFER_MIN
      (UPDATE_Tmp Tmp Fix (cdr (assoc fix_label Net)))
      Fix))))
  (caar Fix)
  (cdar Fix)))

(defun UPDATE_Tmp (Tmp Fix Links)
 (if Links
  ((lambda (link_label link_value)
    (UPDATE_Tmp
     (if (assoc link_label Fix :test 'EQUAL) Tmp
      ((lambda (link mark)
        (if link
         (subst
          (cons link_label (min mark (cdr link)))
          link
          Tmp
          :test 'EQUAL)
         (cons (cons link_label mark) Tmp)))
       (assoc link_label Tmp :test 'EQUAL)
       (+ link_value (cdar Fix))))
     Fix
     (cdr Links)))
   (caar Links)
   (cdar Links))
  Tmp))

(defun TRANSFER_MIN (Tmp Fix)
 (if Tmp
  (if (cdr Tmp)
   (apply
    #'(lambda (elem newTmp newFix)
     (if (< (cdr elem) (cdar newFix))
      (list
       (cons (car newFix) newTmp)
       (cons elem (cdr newFix)))
      (list
       (cons elem newTmp)
       newFix)))
    (cons (car Tmp) (TRANSFER_MIN (cdr Tmp) Fix)))
   (list
    (cdr Tmp)
    (cons (car Tmp) Fix)))
  (list Tmp Fix)))

(("3-three" "350" "2-two")     ("4-four" "350" "3-three")    ("5-five" "350" "4-four") 
 ("6-six" "350" "5-five")      ("8-eight" "1345.36" "1-one") ("8-eight" "1345.36" "7-seven")
 ("10-ten" "1098.41" "9-nine") ("1-one" "549.19" "9-nine")   ("7-seven" "549.19" "10-ten")
 ("7-seven" "300" "6-six")     ("2-two" "300" "1-one"))

> (define (foo)
    (define (nested) (foo))
    (nested))
> (nested)
. . D:\programs\Racket\collects\racket\private\more-scheme.rkt:263:2: nested: undefined;
 cannot reference an identifier before its definition
>

_$ (defun foo ()  (defun nested() (foo)) (nested))
FOO
_$ (nested)
_$

((lambda (/ x)
   (setq x "value"))
)

((lambda (x) 
    x)
 "value")

;; Создание списка именованных лямбда выражений
 
(defun make-locfunct (nlist lbdlist)
  (mapcar #'(lambda (nam lbd) (cons nam lbd)) nlist lbdlist))
 
==> make-locfunct
 
;; создаем...
 
(setq *f* (make-locfunct '(f1 f2 f3) '((lambda (x y) (* x y)) (lambda (x y) (- x y)) (lambda (x y) (/ x y)))))
 
==> ((f1 LAMBDA (x y) (* x y)) (f2 LAMBDA (x y) (- x y)) (f3 LAMBDA (x y) (/ x y)))
 
;; Вызов локальной функции по имени:
 
(defun loc-funcall (flist fnam &rest r)
  (dolist (f flist nil)
   (when (eq (car f) fnam)
     (return (apply (cdr f) r)))))
 
==> loc-funcall
 
(loc-funcall *f* 'f1 2 3)
 
==> 6
 
(loc-funcall *f* 'f2 2 3)
 
==> -1
 
(loc-funcall *f* 'f3 2 3)
 
==> 2/3
 
;; а когда функции уже не нужны:
 
(setq *f* nil)