A macro to define clojure functions with pattern matching just as erlang or elixir. It supports both clojure and clojurescript.
defun
namespace is renamed to defun.core
.Dependency in leiningen:
[defun "0.3.0-RC1"]
Require defun.core
in clojure:
(require '[defun.core :refer [defun]])
Or refer-macros
in clojurescript:
(ns cljs-test
(:require [defun.core :refer-macros [defun]])
(enable-console-print!)
Since 0.3.0-RC, defun
namespace is renamed to defun.core
.
Try to define function just like defn
:
(defun hello
"hello world"
[name] (str "hello," name))
(hello "defun")
;; "hello,defun"
Supports variadic arguments, doc, metadata etc. as defun
too. No supprises?
The fun thing is coming, let's say hi to people:
(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)))
Then calling say-hi
with different names:
(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"
We define functions just like Erlang's function with parameters pattern match (thanks to core.match), we don't need if,cond,case
any more, that's cool!
Let's move on, what about define a recursive function? That's easy too:
(defun count-down
([0] (println "Reach zero!"))
([n] (println n)
(recur (dec n))))
Invoke it:
(count-down 5)
;;5
;;4
;;3
;;2
;;1
;;Reach zero!
nil
An accumulator from zero to number n
:
(defun accum
([0 ret] ret)
([n ret] (recur (dec n) (+ n ret)))
([n] (recur n 0)))
(accum 100)
;;5050
A fibonacci function:
(defun fib
([0] 0)
([1] 1)
([n] (+ (fib (- n 1)) (fib (- n 2)))))
Output:
(fib 10)
;; 55
Of course it's not tail recursive, but it's really cool, isn't it?
Added a guard function to parameters:
(defun funny
([(N :guard #(= 42 %))] true)
([_] false))
(funny 42)
;; true
(funny 43)
;; false
Another function to detect if longitude and latitude values are both valid:
(defun valid-geopoint?
([(_ :guard #(and (> % -180) (< % 180)))
(_ :guard #(and (> % -90) (< % 90)))] true)
([_ _] false))
(valid-geopoint? 30 30)
;; true
(valid-geopoint? -181 30)
;; false
Of course, you can use defun-
to define a function that is private just as defn-
In fact ,the above say-hi
function will be expanded to be:
(defn
say-hi
{:arglists '([& args])}
[& args#]
(clojure.core.match/match
[(vec args#)]
[[:dennis]]
(do "Hi,good morning, dennis.")
[[:catty]]
(do "Hi, catty, what time is it?")
[[:green]]
(do "Hi,green, what a good day!")
[[other]]
(do (str "Say hi to " other))))
The argument vector is in fact a pattern in core.match, so we can use all patterns that supported by core.match.
For example, matching literals
(defun test1
([true false] 1)
([true true] 2)
([false true] 3)
([false false] 4))
(test1 true true)
;; 2
(test1 false false)
;; 4
Matching sequence:
(defun test2
([([1] :seq)] :a0)
([([1 2] :seq)] :a1)
([([1 2 nil nil nil] :seq)] :a2))
(test2 [1 2 nil nil nil])
;; a2
Matching vector:
(defun test3
([[_ _ 2]] :a0)
([[1 1 3]] :a1)
([[1 2 3]] :a2))
(test3 [1 2 3])
;; :a2
Rest Pattern, Map Pattern, Or Pattern etc.
I don't want to copy the core.match's wiki,please visit it by yourself.
Since 0.2.0, there are two new macros: fun
and letfun
, just like clojure.core/fn
and clojure.core/letfn
((fun
([[_ _ 2]] :a0)
([[1 1 3]] :a1)
([[1 2 3]] :a2))
[1 2 3])
;; :a2
(letfun [(test3 ([[_ _ 2]] :a0)
([[1 1 3]] :a1)
([[1 2 3]] :a2))]
(test3 [1 2 3]))
;; :a2
Uses the above function accum
compared with a normal clojure function:
(require '[criterium.core :refer [bench]])
(defn accum-defn
([n] (accum-defn 0 n))
([ret n] (if (= n 0) ret (recur (+ n ret) (dec n)))))
(defun accum-defun
([0 ret] ret)
([n ret] (recur (dec n) (+ n ret)))
([n] (recur n 0)))
(bench (accum-defn 10000))
;;Evaluation count : 210480 in 60 samples of 3508 calls.
;; Execution time mean : 281.095682 µs
;; Execution time std-deviation : 2.526939 µs
;; Execution time lower quantile : 277.691624 µs ( 2.5%)
;; Execution time upper quantile : 286.618249 µs (97.5%)
;; Overhead used : 1.648269 ns
(bench (accum-defun 10000))
;;Evaluation count : 26820 in 60 samples of 447 calls.
;; Execution time mean : 2.253477 ms
;; Execution time std-deviation : 13.082041 µs
;; Execution time lower quantile : 2.235795 ms ( 2.5%)
;; Execution time upper quantile : 2.281963 ms (97.5%)
;; Overhead used : 1.648269 ns
accum-defn is much faster than accum-defun. Pattern matching does have a tradeoff.
Thanks .
Copyright © 2014 Dennis Zhuang
Distributed under the Eclipse Public License either version 1.0 or (at
your option) any later version.
Can you improve this documentation? These fine people already did:
dennis zhuang, Daniel Compton & Matthias NehlsenEdit on GitHub
cljdoc is a website building & hosting documentation for Clojure/Script libraries
× close