Yeah. Trying to write a pattern-matching utility (that doesn’t depend on core.logic!)

I want symbols to be equivalent based on their name alone

Fully-qualified symbols makes it hard to use across namespaces

Some general comments : * You can use cond to replace all do if. Even better you can use case case : https://clojuredocs.org/clojure.core/case. * Repetitive println calls to print menu can be replaced with a for loop even better a print menu function. * Try using let statements instead of defs for choice, prod_name etc since they are local bindings * using - is encouraged over underscores in functions like cust_tot which reads better with customer-total

But I would still get tail error since I want an infinite loop and if I get wrong input I want to recur. The tail error happens at the first if

Some improved code. It might not compile this is how I will refactor this :

(defn print-menu
  (let [menu  ["*** Sales Menu ***"
               "------------------"
               "1. Display Customer Table"
               "2. Display Product Table"
               "3. Display Sales Table"
               "4. Total Sales for Customer"
               "5. Total Count for Product"
               "6. EXIT"]]
    (doseq [item menu]
      (println item))))


(let [options ["1" "2" "3" "4" "5" "6"]]
  (loop []
    (do print-menu
        (let [choice (read-line)]
          (if (= nil (some #(= choice %) options))
            ((println "Please PLEASE!! Enter properly!!") (recur))
            (case choice
              1
              (do
                (doseq [i cust]
                  (do (println (str (subs (str i) 2 3) ": [" (subs (str i) 5 (count (str i)))))))
                (recur))
              2
              (do
                (doseq [i prod]
                  (do (println (str (subs (str i) 2 3) ": [" (subs (str i) 5 (count (str i)))))))
                (recur))
              3
              (do
                (doseq [i sales]
                  (do (println (str (subs (str i) 2 3) ": [" (subs (str i) 5 (count (str i)))))))
                (recur))
              4
              (do (println "Enter Customer Name: ")
                  (let [customer-name (read-line)]
                    (println (str customer-name ": " (cust_tot customer-name)))) (recur))
              5
              (do (println "Enter Product Name: ")
                  (let [product-name (read-line)]
                  (println (str product-name ": " (prod_tot product-name)))) (recur))
              6
              (println "Good    Bye")))))))

By tail error do you mean recur can be used only in tail calls or do you have some kind of stack overflow due to infinite recursion ?

((println "Please PLEASE!! Enter properly!!") (recur))

java.lang.UnsupportedOperationException: Can only recur from tail position

You can change them to case statements and have please enter properly as the last catch all clause. Ex :

user=> (loop []
  #_=>   (case (read-line)
  #_=>     "1"  (do (println "wrong") (recur))
  #_=>     "2"  (do (println "wrong") (recur))
  #_=>     "3"  (do (println "correct"))
  #_=>     (do (println "invalid option") (recur))))
1
wrong
2
wrong
5
invalid option
3
correct
nil

(case choice
1 (do-for-1)
2 (do-for-2)
(do (println "Please PLEASE!! Enter properly!!") (recur))

Yep figured that part though, but then the rest of the if statement wont work as recur wont be at tail end. Now I am really confused about how to create infinite loop with break on condition.

The only advice I can give is to take a step back and try to go back to basics. Clojure is an expression-based language -- you're still trying to write statement-based code.

if should never have one arm, always two. That's part of why your recur isn't in the tail position. You have multiple if expressions stacked up like statements.

The body of your loop should be a single expression, not a sequence of expressions. That will let you use recur.

You're also still trying to use for as if it were a "for-loop" rather than a comprehension that produces a sequence. And you have additional ( .. ) wrapped around those (doall (for ...)) expressions -- again, not valid.

If you just want to loop over something and print each element of a sequence, use doseq:

(doseq [i sales] (println ...))

Then if you wrap that with (do ... (recur)) you're a step closer.

But you also need to replace that series of separate if expressions with a single conditional cond and then you'll have a single expression.

(if (condition? ...)
  (then-expression ...))

My point is that you have

(if (condition)
  (then-expression))
(if (condition)
  (then-expression))
(if (condition)
  (then-expression))
...

I can do that for cond?

(cond (condition) (then-expression)
      (condition) (then-expression)
      (condition) (then-expression))

Ohhh...It doesnt fall through!!

Clojure is expression-based not statement-based 🙂

user=> (let [x 42]
(cond (< 50 x) "big"
      (< 0 x 50) "medium"
      (< x 0) "negative"))
"medium"
user=>

Note that these are expressions, not statements.

I also just noticed that you're doing (read-line) which gives you a string but you're testing choice against integers -- so those will never match.

(let [choice (read-line)]
  (case choice
  "1" ...
  "2" ...
  "3" ...
  "4" ...
  "5" ...
  "6" ...
  (println "Please PLEASE!! Enter properly!!"))
  (when-not (= choice "6")
    (recur)))

case takes pairs of values and expressions and then a default expression. Since you are only doing stuff for side-effects for each choice, you can do the whole thing in a case expression (and ignore the nil result) and then you can have a single expression which conditionally does the recur -- and which will be in tail position.

Does that help?

Yep

Try *'

Also (range 1 100N) returns a sequence of longs, not BigInt's. If you instead use (range 1N 100), it returns a sequence of BigInt's, and then the normal * function will preserve them as BigInt's.

I didn't have that memorized -- just tried out (range 1 100N) and then (range 1N 100) in a REPL, and saw the difference in return values.