How to create selection menu in Common Lisp? - common-lisp

Question

I have the menu which is created in the options function and the functionality of that is to have the user input a number (1 or 2 or 3) in order to solve the problem with the chosen method (DFS, BFS, BESTFS). This method is supposed to return what the user selected in this line of code
(SearchProblem '(0 0 2 6 4) '(0 0 0 0 0) (Options)) in the end. The problem is that when I compile the problem it displays this error "Undefined function DFS called with arguments ().". How can I fix that?
Code
; ----------------------------------------------------------------------------
; ******** Search Code for DFS and other search methods
; ******** (expanding front and extending queue)
; ******** author: AI lab
; ********
; ******** Κώδικας για DFS και άλλες μεθόδους αναζήτησης
; ******** (επέκταση μετώπου και διαχείριση ουράς)
; ******** Συγγραφέας: Εργαστήριο ΤΝ
; ----------------------------------------------------------------------------
; **** starting search
; **** έναρξη αναζήτησης
(defun searchProblem (start-state goal method )
( cond
((StateValidation start-state)(print "Invalid data!") nil)
( T (findSolution (MakeFront start-state) (MakeQueue start-state) () goal method ) )
)
;(print '____BEGIN_SEARCHING_____ )
)
; **** Checking for valid states
(defun StateValidation (state)
(cond
( (or (> (first state) 3) (<(first state) 0)) t)
(T nil)
)
)
; ----------------------------------------------------------------------------
; **** Basic recursive function to create search tree (recursive tree expantion)
; **** Βασική αναδρομική συνάρτηση για δημιουργία δέντρου αναζήτησης (αναδρομική επέκταση δέντρου)
(defun FindSolution (front queue closed goal method )
(cond
((null front) 'no_solution)
((mymember (car front) closed) (FindSolution (cdr front) (cdr queue) closed goal method ))
((equal (car front) goal) (format T "This is the solution: ~a" (reverse (first queue))))
(T (FindSolution (ExpandFront front method) (ExtendQueue queue method) (cons (car front) closed) goal method ))
)
)
; ----------------------------------------------------------------------------
; **** FRONT
; **** Διαχείριση Μετώπου
; ----------------------------------------------------------------------------
; ** initialization of front
; ** Αρχικοποίηση Μετώπου
(defun MakeFront (node)
(list node)
)
; ----------------------------------------------------------------------------
; **** expanding front
; **** επέκταση μετώπου
(defun ExpandFront (front method)
(cond
( (eq method 'DFS) (append ( removeNils ( findchildren (car front))) (cdr front) ) )
( (eq method 'BFS) (append (cdr front) ( removeNils (findchildren (car front)))))
( (eq method 'BESTFS) (sort (append ( removeNils ( findchildren (car front))) (cdr front))#'check) )
( T "other methods to be added" )
)
)
; ----------------------------------------------------------------------------
; **** QUEUE
; **** Διαχείριση ουράς
; ----------------------------------------------------------------------------
; ** initialization of queue
; ** Αρχικοποίηση ουράς
(defun MakeQueue (node)
(list (list node))
)
; ----------------------------------------------------------------------------
; **** expanding queue
; **** επέκταση ουράς
;;; expanding queue
(defun ExtendQueue (queue method)
(cond
( (eq method 'DFS) (append ( growPath (car queue)) (rest queue) ) )
( (eq method 'BFS) (append (rest queue) (growPath (car queue)) ) )
( (eq method 'BESTFS) (sort (append ( growPath (car queue) ) (rest queue))#'check1) )
( T "other methods to be added" )
)
)
(defun check (s1 s2)
(< (+ (third s1) (fourth s1) (fifth s1)) (+ (third s2) (fourth s2) (fifth s2)) )
)
(defun check1 (s1 s2)
(< (+ (third (first s1)) (fourth (first s1)) (fifth (first s1))) (+ (third (first s2)) (fourth (first s2)) (fifth (first s2))))
)
(defvar opt 0) ;Variable definition for the menu
;----------Otptions menu------------------------------------------------------
(defun Options ()
( print "Searching methods." )
( print "For DFS method press 1." )
( print "For BFS method press 2." )
( print "For BESTFS method press 3." )
( print "Choose searching method" )
( let (opt (read)))
(cond
( ( = opt 1 ) (T (DFS) ) )
( ( = opt 2 ) (T (BFS) ) )
( ( = opt 3 ) (T (BESTFS) ) )
)
( T (nil) )
)
; ----------------------------------------------------------------------------
; **** growing path towards each different child of the selected parent node
; **** επεκταση μονοπατιου προς καθε διαφορετικό παιδί-κόμβο από τον επιλεγμένο γονέα-κόμβο
(defun growPath (path)
(removecycles (grow1 path (removeNils (findchildren (car path)))))
)
(defun grow1 (path children)
(cond
((null children) nil )
( T (cons (cons (car children) path) (grow1 path (cdr children))) )
)
)
; ----------------------------------------------------------------------------
; **** Supportive functions
; **** Υποστηρικτικές συναρτήσεις
(defun mymember(x Y)
(cond
((endp y) nil )
((equal x (first y)) T )
(T (mymember x (rest y)) )
)
)
(defun removeNils (X)
(cond
((endp x) nil )
((eq (first x) NIL) (removeNils (rest x)) )
(T (cons (first x) (removeNils (rest x))) )
)
)
(defun removecycles (paths)
(cond
((null paths) nil )
((member (caar paths) (cdar paths)) (removecycles (cdr paths)) )
(T (cons (car paths) (removecycles (cdr paths))) )
)
)
; ----------------------------------------------------------------------------
; **** Problem's World & Problem depending functions
; **** κόσμος του προβλήματος (αν απαιτείται) και συναρτήσεις σχετικές με το πρόβλημα
;;;; #### to be added ####
(defvar capacity 5)
(defun goToGround (state)
(cond
( (or (= (+ (third state) (fourth state) (fifth state)) 0) (= (second state) capacity))
(list 0 0 (third state)(fourth state)(fifth state))
)
(T nil)
)
)
(defun goToFirst (state)
(cond
(
(and (< (second state) capacity) (> (third state) 0))
(goToFirst (list 1 (+ (second state) 1) (- (third state) 1) (fourth state) (fifth state)))
)
(T (list (first state) (second state) (third state) (fourth state) (fifth state)))
)
)
(defun goToSecond (state)
(cond
(
(and (< (second state) capacity) (> (fourth state) 0))
(goToSecond (list 2 (+ (second state) 1) (third state) (- (fourth state) 1) (fifth state)))
)
(T (list (first state) (second state) (third state) (fourth state) (fifth state)))
)
)
(defun goToThird (state)
(cond
(
(and (< (second state) capacity) (> (fifth state) 0))
(goToThird (list 3 (+ (second state) 1) (third state) (fourth state) (- (fifth state) 1)))
)
(T (list (first state) (second state) (third state) (fourth state) (fifth state)))
)
)
; ----------------------------------------------------------------------------
; ** function to find the children nodes of a parent state node
; ** συνάρτηση εύρεσης απογόνων
(defun findchildren (state)
(list (goToGround state) (goToFirst state) (goToSecond state) (goToThird state))
)
; ----------------------------------------------------------------------------
; ** Executing the code
; ** κλήση εκτέλεσης κώδικα
;(trace SearchProblem)
(SearchProblem '(0 0 2 6 4) '(0 0 0 0 0) (Options) )

Answer 1

I heavily recommend you to properly indent common-lisp code following existing guidelines, else the parentheses are a mess.
Here, using slime and regex search and replace, I properly indented your code and simplified some stuff and also by this indenting - discovered some parenthesis mistakes.
And I corrected them.
By the level of the indentation, you can see, where paren mistakes occur.
To your question, I suggest:
(defun options ()
(print "Searching methods.")
(print "For DFS method press 1.")
(print "For BFS method press 2.")
(print "For BESTFS method press 3.")
(print "Choose searching method")
(let ((opt (read))) ;; here were some paren' mistakes!
(case opt ;; case is the `switch` in cl
(1 'DFS)
(2 'BFS)
(3 'BESTFS) ;; here was an erroneous parenthesis
(otherwise 'nil)))) ;; here one paren' added
The whole code correctly indented (using emacs SLIME mode for common-lisp) and with some changes for simplification:
;; --------------------------------------------------
;; ******** Search Code for DFS and other search methods
;; ******** (expanding front and extending queue)
;; ******** author: AI lab
;; ********
;; ******** Κώδικας για DFS και άλλες μεθόδους αναζήτησης
;; ******** (επέκταση μετώπου και διαχείριση ουράς)
;; ******** Συγγραφέας: Εργαστήριο ΤΝ
;; --------------------------------------------------
;; **** starting search
;; **** έναρξη αναζήτησης
(defun searchProblem (start-state goal method)
(if (StateValidation start-state)
(print "Invalid data!") ;; print returns nil
(findSolution (MakeFront start-state)
(MakeQueue start-state)
()
goal
method)))
;;**** Checking for valid states
(defun StateValidation
(or (> (first state) 3)
(< (first state) 0))) ;; if condition is true, returns T else nil
;;--------------------------------------------------
;;**** Basic recursive function to create search tree (recursive tree expantion)
;;**** Βασική αναδρομική συνάρτηση για δημιουργία δέντρου αναζήτησης (αναδρομική επέκταση δέντρου)
(defun FindSolution (front queue closed goal method)
(cond ((null front) 'no_solution)
((mymember (car front) closed)
(FindSolution (cdr front)
(cdr queue)
closed
goal
method))
((equal (car front) goal)
(format T "This is the solution: ~a" (reverse (first queue))))
(T (FindSolution (ExpandFront front method)
(ExtendQueue queue method)
(cons (car front) closed)
goal
method))))
;;--------------------------------------------------
;;**** FRONT
;;**** Διαχείριση Μετώπου
;;--------------------------------------------------
;;** initialization of front
;;** Αρχικοποίηση Μετώπου
(defun MakeFront (node)
(list node))
;;--------------------------------------------------
;;**** expanding front
;;**** επέκταση μετώπου
(defun ExpandFront (front method)
(case method
(DFS (append (removeNils (findchildren (car front)))
(cdr front)))
(BFS (append (cdr front)
(removeNils (findchildren (car front)))))
(BESTFS (sort (append (removeNils (findchildren (car front)))
(cdr front)) #'check))
(otherwise "other methods to be added")))
;;--------------------------------------------------
;;**** QUEUE
;;**** Διαχείριση ουράς
;;--------------------------------------------------
;;** initialization of queue
;;** Αρχικοποίηση ουράς
(defun MakeQueue (node)
(list (list node)))
;;--------------------------------------------------
;;**** expanding queue
;;**** επέκταση ουράς
;;; expanding queue
(defun ExtendQueue (queue method)
(case method
(DFS (append (growPath (car queue))
(rest queue)))
(BFS (append (rest queue)
(growPath (car queue))))
(BESTFS (sort (append (growPath (car queue))
(rest queue)) #'check1))
(otherwise "other methods to be added")))
#|
(defun check (s1 s2)
(< (+ (third s1)
(fourth s1)
(fifth s1))
(+ (third s2)
(fourth s2)
(fifth s2))))
|#
(defun sum-3rd-to-5th (s)
(+ (third s) (fourth s) (fifth s)))
(defun check (s1 s2)
(< (sum-3rd-to-5th s1)
(sum-3rd-to-5th s2)))
(defun check1 (s1 s2)
(check (first s1) (first s2))) ;; this is equivalent to before - uses `check` above
(defvar opt 0) ;Variable definition for the menu
;;----------Otptions menu------------------------------------------------------
(defun options ()
(print "Searching methods.")
(print "For DFS method press 1.")
(print "For BFS method press 2.")
(print "For BESTFS method press 3.")
(print "Choose searching method")
(let ((opt (read))) ;; parenthesis mistakes also here!
(case opt
(1 'DFS)
(2 'BFS)
(3 'BESTFS) ;; here was an erroneous paranthesis
(otherwise 'nil)))) ;; here one added
;;--------------------------------------------------
;;**** growing path towards each different child of the selected parent node
;;**** επεκταση μονοπατιου προς καθε διαφορετικό παιδί-κόμβο από τον επιλεγμένο γονέα-κόμβο
(defun growPath (path)
(removecycles (grow1 path (removeNils (findchildren (car path))))))
(defun grow1 (path children)
(cond ((null children) nil)
(T (cons (cons (car children) path)
(grow1 path (cdr children))))))
;;--------------------------------------------------
;;**** Supportive functions
;;**** Υποστηρικτικές συναρτήσεις
#|
(defun mymember(x y)
(cond ((null y) nil)
((equal x (first y)) T)
(T (mymember x (rest y)))))
(defun removeNils (x)
(cond ((null x) nil)
((eq (first x) NIL) (removeNils (rest x)))
(T (cons (first x)
(removeNils (rest x))))))
|#
(defun mymember (x y)
(member x y :test #'equal))
(defun removeNils (x)
(remove-if #'null x))
(defun removecycles (paths)
(cond ((null paths) nil)
((member (caar paths)
(cdar paths))
(removecycles (cdr paths)))
(T (cons (car paths)
(removecycles (cdr paths))))))
;;--------------------------------------------------
;;**** Problem's World & Problem depending functions
;;**** κόσμος του προβλήματος (αν απαιτείται) και συναρτήσεις σχετικές με το πρόβλημα
#| isn't state a list of 5 elements?
(list (first state)
(second state)
(third state)
(fourth state)
(fifth state)) ;; ===> state
|#
;;;; #### to be added ####
(defvar capacity 5)
(defun goToGround (state)
(if (or (zerop (sum-3rd-to-5th state))
(zerop (second state) capacity))
(list 0
0
(third state)
(fourth state)
(fifth state))
nil))
(defun goToFirst (state)
(if (and (< (second state) capacity)
(> (third state) 0))
(goToFirst (list 1
(1+ (second state))
(1- (third state))
(fourth state)
(fifth state)))
state))
(defun goToSecond (state)
(if (and (< (second state) capacity)
(> (fourth state) 0))
(goToSecond (list 2
(1+ (second state))
(third state)
(1- (fourth state))
(fifth state)))
state))
(defun goToThird (state)
(if (and (< (second state) capacity)
(> (fifth state) 0))
(goToThird (list 3
(1+ (second state))
(third state)
(fourth state)
(1- (fifth state))))
state))
;;--------------------------------------------------
;;** function to find the children nodes of a parent state node
;;** συνάρτηση εύρεσης απογόνων
(defun findchildren (state)
(list (goToGround state)
(goToFirst state)
(goToSecond state)
(goToThird state)))
;;--------------------------------------------------
;;** Executing the code
;;** κλήση εκτέλεσης κώδικα
;; (trace SearchProblem)
(SearchProblem '(0 0 2 6 4)
'(0 0 0 0 0)
(Options))

Answer 2

You're trying to call DFS, BFS, and BESTFS as functions. They're just symbols that should be returned, and they'll be passed on to other functions as parameters.
They shouldn't be wrapped in (T ...), either. And (T (nil)) needs to be a clause of the COND, not after it. And again, nil shouldn't be inside parentheses, that means to try to call it as a function. You don't really need this clause, though, since COND returns NIL by default if none of the conditions match.
The code that tests opt needs to be inside the let that binds it.
(defun Options ()
( print "Searching methods." )
( print "For DFS method press 1." )
( print "For BFS method press 2." )
( print "For BESTFS method press 3." )
( print "Choose searching method" )
( let (opt (read))
(cond
( ( = opt 1 ) 'DFS )
( ( = opt 2 ) 'BFS )
( ( = opt 3 ) 'BESTFS )
( T nil )))
)
)