3 Examples top

• link | changes

  user=> (defn foo [a b c]
  	    (* a b c))
  #'user/foo
  user=> (foo 1 2 3)
  6
  
  user=> (defn bar [a b & [c]]
           (if c
             (* a b c)
             (* a b 100)))
  #'user/bar
  user=> (bar 5 6)
  3000
  user=> (bar 5 6 2)
  60
  
  user=> (defn baz [a b & {:keys [c d] :or {c 10 d 20}}]
           (* a b c d))
  #'user/baz
  user=> (baz 2 3)
  1200
  user=> (baz 2 3 :c 5)
  600
  user=> (baz 2 3 :c 5 :d 6)
  180
  

  user=> (defn foo [a b c] (* a b c)) #'user/foo user=> (foo 1 2 3) 6 user=> (defn bar [a b & [c]] (if c (* a b c) (* a b 100))) #'user/bar user=> (bar 5 6) 3000 user=> (bar 5 6 2) 60 user=> (defn baz [a b & {:keys [c d] :or {c 10 d 20}}] (* a b c d)) #'user/baz user=> (baz 2 3) 1200 user=> (baz 2 3 :c 5) 600 user=> (baz 2 3 :c 5 :d 6) 180
• link | changes

  user=> (defn bar
           ([a b]   (bar a b 100))
           ([a b c] (* a b c)))
  #'user/bar
  user=> (bar 5 6)
  3000
  user=> (bar 5 6 2)
  60
  

  user=> (defn bar ([a b] (bar a b 100)) ([a b c] (* a b c))) #'user/bar user=> (bar 5 6) 3000 user=> (bar 5 6 2) 60
• link | changes

  ;; You can use destructuring to have keyword arguments. This would be a
  ;; pretty verbose version of map (in an example a bit more verbose than
  ;; the first above):
  
  (defn keyworded-map [& {function :function sequence :sequence}]
    (map function sequence))
  
  ;; You can call it like this:
  
  user=> (keyworded-map :sequence [1 2 3] :function #(+ % 2))
  (3 4 5)
  
  
  ;; The declaration can be shortened with ":keys" if your local variables 
  ;; should be named in the same way as your keys in the map:
  
  (defn keyworded-map [& {:keys [function sequence]}]
    (map function sequence))
  

  ;; You can use destructuring to have keyword arguments. This would be a ;; pretty verbose version of map (in an example a bit more verbose than ;; the first above): (defn keyworded-map [& {function :function sequence :sequence}] (map function sequence)) ;; You can call it like this: user=> (keyworded-map :sequence [1 2 3] :function #(+ % 2)) (3 4 5) ;; The declaration can be shortened with ":keys" if your local variables ;; should be named in the same way as your keys in the map: (defn keyworded-map [& {:keys [function sequence]}] (map function sequence))