{ANN} defun: A beautiful macro to define clojure functions with pattern match.

[dennis zhuang]

Hi , i am pleased to introduce defun: a beautiful macro to define clojure functions with pattern match.

Some examples:

(defun say-hi

  ([:dennis] "Hi,good morning, dennis.")

  ([:catty] "Hi, catty, what time is it?")

  ([:green] "Hi,green, what a good day!")

  ([other] (str "Say hi to " other)))

(say-hi :dennis)

;;  "Hi,good morning, dennis."

(say-hi :catty)

;;  "Hi, catty, what time is it?"

(say-hi :green)

;;  "Hi,green, what a good day!"

(say-hi "someone")

;;  "Say hi to someone"

Recursive function? It's all right:

(defun count-down

  ([0] (println "Reach zero!"))

  ([n] (println n)

     (recur (dec n))))

(defun fib

    ([0] 0)

    ([1] 1)

    ([n] (+ (fib (- n 1)) (fib (- n 2)))))

Guard functions? it's all right:

(defun valid-geopoint?

    ([(_ :guard #(and (> % -180) (< % 180)))

      (_ :guard #(and (> % -90) (< % 90)))] true)

    ([_ _] false))

(valid-geopoint? 30 30)

;; true

(valid-geopoint? -181 30)

;; false

It's really cool,all the magic are from core.match, much more details please see 

https://github.com/killme2008/defun

--
庄晓丹
Email:        killm...@gmail.com xzh...@avos.com
Site:           http://fnil.net
Twitter:      @killme2008

[dennis zhuang]

Released 0.1.0-RC,  defun collect :arglists metadata, another recursive function example:

 (defun accum
      ([0 ret] ret)
      ([n ret] (recur (dec n) (+ n ret)))
      ([n] (recur n 0)))

     (accum 100) ;; the result is 5050

[Herwig Hochleitner]

Hi Dennis,

marrying core.match to defn is a pretty neat idea. Thanks for releasing it!

I see that you actually extended defn in that you made it possible to recur between different arities.

Can you give a quick rundown on how you made that work? Are the arities still separate IFn arities? Does it still run in constant stack space?

kind regards

PS @adrian: If you feel like "Friendly advice" ing someone, why not do so in a private email?

[dennis zhuang]

Hi Herwig

Actually,defun just define a variadic arguments function,so it doesn't have different arities. And when using defun macro ,it walk through the body forms, find 'recur'  forms and replace them with (recur (vector ...arguments)) instead.

A macroexpand-1 result of accum:

(macroexpand-1 

  '(defun accum

      ([0 ret] ret)

      ([n ret] (recur (dec n) (+ n ret)))

      ([n] (recur n 0))))

=>

(clojure.core/defn

 accum

 {:arglists '([0 ret] [n ret] [n])}

 [& args__4602__auto__]

 (clojure.core.match/match

  [(clojure.core/vec args__4602__auto__)]

  [[0 ret]]

  (do ret)

  [[n ret]]

  (do (recur (vector (dec n) (+ n ret))))

  [[n]]

  (do (recur (vector n 0)))))

The core procedure is at https://github.com/killme2008/defun/blob/master/src/defun.clj#L97-107

--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clo...@googlegroups.com
Note that posts from new members are moderated - please be patient with your first post.
To unsubscribe from this group, send email to
clojure+u...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups "Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email to clojure+u...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[dennis zhuang]

And of course ,it still run in constant stack space just like normal recur form.

P.S. I think adrian's advice is good, please forgive my poor english,and i changes the description to ' a macro to define clojure functions with pattern match just like erlang or elixir.

[adrian...@mail.yu.edu]

Criticism accepted Herwig. I apologize for not doing so initially. 

[Bozhidar Batsov]

Cool idea! I really wish something similar was available out-of-the-box - perhaps it makes sense to include such a macro in core.match itself as some point?

—

Cheers, 
Bozhidar

[Henrik Eneroth]

For all the good qualities of the Clojure group, it can sometimes produce a bit of a harsh tone. Don't let that get you down though, it's great that you're building stuff and showing it off!

As far as defun goes, it looks interesting. The out-of-the-box pattern matching was one of the things I enjoyed with ML. It's usually a quite tidy way to handle the termination conditions of recursions. It's less useful in Clojure, since we're more or less confined to loop and recur, but I still like the looks of this.

[Max Gonzih]

Amazing! Would love to have something like that in clojure.core.

On Sunday, September 14, 2014 8:47:28 AM UTC+2, dennis wrote:

[killm...@gmail.com]

I am glad it's helpful.I am using defun to write transform functions for instaparse in a DSL parser,it's really good at it.I am not sure if i can create a pull request to core.match.

发自我的 iPad

[Devin Walters]

I didn't read it that way.

On Sep 14, 2014, at 7:45 AM, adrian...@mail.yu.edu wrote:

Friendly advice: when you describe anything you create with adjectives like beautiful, it comes off as unnecessarily arrogant to native English speakers.

Adrian

[J David Eisenberg]

On Saturday, September 13, 2014 11:47:28 PM UTC-7, dennis wrote:

Hi , i am pleased to introduce defun: a beautiful macro to define clojure functions with pattern match.

[snip]

This is totally wonderful. Elegant, and useful.

[Jacob Goodson]

I did this same thing and called it defmatch.  You can use vinyasa to inject functions into core through leiningen.  I did that and it allowed me to have defmatch anywhere I wanted to have it.  Anyway, I guess someone else had this idea lol =P.

[Ivan L]

Is this clojurescript ready?  This looks amazing, I would also love to have it in core.

On Sunday, September 14, 2014 2:47:28 AM UTC-4, dennis wrote:

[Andre Richards]

Don't think Rich Hickey is a fan of pattern matching, which is probably why it is not in core to begin with.

If you watch his "Simple made easy" talk, pattern matching is one of the items listed under Complexity Toolkit, with this description: "Complects multiple who/what pairs".

I'm not sure where core.match is positioned - might have a better change to get added there?

[dennis zhuang]

I will add supporting for clojurescript this weekend.Thanks for your suggestion.

--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clo...@googlegroups.com
Note that posts from new members are moderated - please be patient with your first post.
To unsubscribe from this group, send email to
clojure+u...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups "Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email to clojure+u...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

[Mars0i]

I think it is a beautiful macro.

[Max Gonzih]

Are there any updates on clojurescript support?

[Jay Porcasi]

hi Dennis

wow... that's beyond beautiful, it's awesome

this makes Clojure even more 'Haskell-ish', which is a good thing in my opinion
thanks for sharing this gem with the world

Jay

[Daniel Szmulewicz]

A very instructional presentation about pattern matching in general and defun in particular was given by Sean Johnson at Clojure West.

https://www.youtube.com/watch?v=n7aE6k8o_BU

Recommended watching.