函数定义 #

(defn greet [name]
  (str "Hello, " name "!"))

(greet "World")

(defn function-name
  "Documentation string"
  [parameters]
  (body))

(defn square
  "Returns the square of a number.
   Example: (square 5) => 25"
  [x]
  (* x x))

(doc square)

(defn pi []
  3.14159)

(pi)

(defn double-it [x]
  (* x 2))

(double-it 5)

(defn add [a b]
  (+ a b))

(defn greet [first-name last-name]
  (str "Hello, " first-name " " last-name))

(greet "John" "Doe")

(defn sum-all [& numbers]
  (apply + numbers))

(sum-all 1 2 3 4 5)

(defn greet-all [greeting & names]
  (str greeting ", " (clojure.string/join ", " names)))

(greet-all "Hello" "Alice" "Bob" "Carol")

(defn format-message [prefix & parts]
  (str prefix ": " (clojure.string/join " " parts)))

(format-message "ERROR" "File" "not" "found")

(defn greet
  ([name]
   (greet "Hello" name))
  ([greeting name]
   (str greeting ", " name "!")))

(greet "Alice")

(greet "Hi" "Bob")

(defn make-point
  ([x y] (make-point x y 0))
  ([x y z]
   {:x x :y y :z z}))

(make-point 1 2)

(make-point 1 2 3)

(defn calculate
  ([x] (* x x))
  ([x y] (+ x y))
  ([x y z] (+ x y z)))

(calculate 5)

(calculate 3 4)

(calculate 1 2 3)

(defn process [x]
  (println "Processing:" x)
  (let [result (* x 2)]
    (println "Result:" result)
    result))

(process 5)

(defn calculate-area [width height]
  (let [area (* width height)]
    (str "Area: " area " square units")))

(calculate-area 5 3)

(defn absolute [x]
  (if (neg? x)
    (- x)
    x))

(absolute -5)

(absolute 5)

(defn ^:private helper []
  "internal helper")

(defn ^String process [s]
  (str "Processed: " s))

(meta #'helper)

(defn ^:dynamic config []
  {:debug true})

(defn ^:const max-value []
  100)

(defn ^:deprecated old-function []
  "Use new-function instead")

(defn- internal-helper []
  "This is private")

(defn public-api []
  (internal-helper))

(defn ^:private another-helper []
  "Also private")

(defn divide [a b]
  {:pre [(not= b 0)]
   :post [(number? %)]}
  (/ a b))

(divide 10 2)

(divide 10 0)

(defn calculate-bmi [weight height]
  {:pre [(pos? weight) (pos? height)]
   :post [(<= 10 % 50)]}
  (/ weight (* height height)))

(calculate-bmi 70 1.75)

(defn apply-twice [f x]
  (f (f x)))

(apply-twice inc 5)

(apply-twice #(* % 2) 3)

(defn make-adder [n]
  (fn [x] (+ x n)))

(def add5 (make-adder 5))
(def add10 (make-adder 10))

(add5 3)

(add10 3)

(defn compose [f g]
  (fn [x]
    (f (g x))))

(def add1-then-double (compose #(* % 2) inc))

(add1-then-double 4)

(comp inc #(* % 2))

(apply + [1 2 3 4 5])

(apply + 1 2 [3 4 5])

(apply str ["a" "b" "c"])

(def add5 (partial + 5))

(add5 3)

(def greet-hello (partial str "Hello, "))

(greet-hello "World")

(def inc-then-double (comp #(* % 2) inc))

(inc-then-double 4)

(def process (comp str/upper-case str/reverse))

(process "hello")

(def not-empty? (complement empty?))

(not-empty? [])

(not-empty? [1 2 3])

(def always-5 (constantly 5))

(always-5)

(always-5 1 2 3)

(identity 42)

(filter identity [1 nil 2 nil 3])

(defn make-person
  ([name] (make-person name nil nil))
  ([name age] (make-person name age nil))
  ([name age email]
   (cond-> {:name name}
     age (assoc :age age)
     email (assoc :email email))))

(make-person "Alice")
(make-person "Bob" 30)
(make-person "Carol" 25 "carol@example.com")

(defn calculate [strategy a b]
  (strategy a b))

(defn add [a b] (+ a b))
(defn multiply [a b] (* a b))
(defn subtract [a b] (- a b))

(calculate add 5 3)
(calculate multiply 5 3)
(calculate subtract 5 3)

(defn with-logging [f]
  (fn [& args]
    (println "Calling with args:" args)
    (let [result (apply f args)]
      (println "Result:" result)
      result)))

(defn add [a b]
  (+ a b))

(def logged-add (with-logging add))

(logged-add 3 4)