Destructuring and Function Overloading

[danielgomez3]

I've noticed there is no destructuring like Clojure.. or there was but now there aren't?
This arbitrary Clojure example:

(defn process-data
  ([] (println "No data provided"))
  ([status-keyword]
   (cond
     (= :success status-keyword) (println "Operation completed successfully")
     (= :error status-keyword) (println "Error occurred")
     :else (println "Unknown status")))
  ([status-keyword message]
   (cond
     (= :success status-keyword) (println "Operation completed successfully with message:" message)
     (= :error status-keyword) (println "Error occurred with message:" message)
     :else (println "Unknown status"))))

;; Example usage
(process-data)
(process-data :success)

Can it be done as simply in Hy?

If not, this is a pretty big deal for me deciding to adopt this language. I'm coming from the Erlang Pattern matching side of things, and I just don't know the Hy equivalent.

[scauligi]

Hy doesn't (natively) have function overloading like that, but—just as you can with Python—you can implement something similar by using Python's own match/destructuring:

(require hyrule [case])

(defn process-data [#* args]
  (match args
    [] (print "No data provided")
    ["success"] (print "Operation completed successfully")
    ["error"] (print "Error occurred")
    [_] (print "Unknown status")
    [status-keyword message]
      (case status-keyword
        "success" (print "Operation completed successfully with message:" message)
        "error" (print "Error occurred with message:" message)
        else (print "Unknown status"))))

;; Example usage
(process-data)
(process-data "success")

(:keywords work a little differently in Hy than they do in Clojure, so I used strings instead)

[danielgomez3]

That was really helpful!
My problem is coming from OCaml and Erlang, it feels like in Python and Hy I'm constantly fighting against error/edge-cases. Consider this arbitrary code:

(require hyrule [case])

(defn process-data [#* args]
  (match args
         [] (print "No data provided")
         [status-keyword]
         (case status-keyword
               'success (print "Operation completed successfully " )
               'error (print "Error occurred " )
               else (print "Invalid Input"))
         [status-keyword message]
         (case status-keyword 
               'success (print "Operation completed successfully with message:" message)
               'error (print "Error occurred with message:" message)
               else (print "Invalid Input (pt.2)"))))

;; ;; Error Cases:
(process-data)
(process-data "success")
(process-data "success" "errror")
;; No data provided
;; Invalid Input
;; Invalid Input (pt.2)

;; ;; Normal Cases:
(process-data)
(process-data 'success)
(process-data 'success "hey")
(process-data 'error "noo")
;; No data provided
;; Operation completed successfully
;; Operation completed successfully with message: hey
;; Error occurred with message: noo

I insist on using symbols to represent immutable data!
I'm trying to put all of the error cases under one branch of 'Invalid Input', but I feel like I really can't with python or hyrule's match and case.
Is there any way to do that? Otherwise, I really feel like I'm just writing spaghetti.

[Kodiologist]

I insist on using symbols to represent immutable data!

You may find that Python modules that you want to use insist on using strings.

I'm trying to put all of the error cases under one branch of 'Invalid Input'

Try one of the following:

• Use a subroutine.
• Use try, throw exceptions, and deal with the error cases in except.
• Use cond or Hyrule's branch instead of the more restrictive match or case.

[Kodiologist]

(Or just write your own macro that does what you want. It is Lisp, after all.)

[Kodiologist]

There's also some fancier destructuring macros in Hyrule.