`clojure.core/letfn`¶

Type: macro Added: Clojure 1.0 Examples: 5 Runnable: 1

([fnspecs & body])

fnspec ==> (fname [params*] exprs) or (fname ([params*] exprs)+)

Takes a vector of function specs and a body, and generates a set of bindings of functions to their names. All of the names are available in all of the definitions of the functions, as well as the body.

Examples¶

by nipra on 2010-07-15 . May have evaluation errors.

by miner on 2015-09-11

by sleyzerzon on 2016-06-07 . May have evaluation errors.

by green-coder on 2021-05-18 . May have evaluation errors.

by claj on 2025-11-21 . May have evaluation errors.

(defn clj->php
  "Serializes a subset of Clojure data types to the PHP serialization format.

To avoid intermediary allocations of strings, a StringBuilder is sent around
  as an aggregate. The StringBuilder is realized to a string before returned."
  [clj-data]
  (letfn
      ;; primitive encoder for string
      [(encode-string*
         [^StringBuilder sb ^String clj-data]
         (let [string-length-in-bytes (count (.getBytes clj-data))]
           (-> sb
               (.append "s:")
               (.append string-length-in-bytes)
               (.append ":\"")
               (.append clj-data)
               (.append "\";"))))
       ;; primitive encoders for numbers
       (encode-float*
         [^StringBuilder sb clj-data]
         (-> sb
             (.append "d:")
             (.append clj-data)
             (.append ";")))

(encode-int*
         [^StringBuilder sb ^Long clj-data]
         (-> sb
             (.append "i:")
             (.append clj-data)
             (.append ";")))
       ;; encoders for collections
       ;; PHP associative collections.
       ;; Arrays/vectors uses only integer keys from 0 to n-1 (ordered).
       ;; Associative maps can have objects of any type as key.
       (encode-map*
         ;; used for both hash-maps and vectors
         [^StringBuilder sb clj-data]
         (let [sb (-> sb
                      (.append "a:")
                      (.append (count clj-data))
                      (.append ":{"))
               sb (reduce-kv (fn [^StringBuilder sb k v]
                               (-> sb
                                   (clj->php* k)
                                   (clj->php* v)))
                             sb
                             clj-data)
               sb (.append ^StringBuilder sb "}")]
           sb))
       ;; given a seqable but not indexed collection, we serialize
       ;; it with a synthetic index key using map-indexed.
       (encode-collection*
         [^StringBuilder sb clj-data]
         (let [sb (-> sb
                      (.append "a:")
                      (.append (count clj-data))
                      (.append ":{"))
               sb (reduce (fn [sb [syntethic-k v]]
                               (-> sb
                                   ;; in this case k is always an int!.
                                   (encode-int* syntethic-k)
                                   (clj->php* v)))
                             sb
                             (map-indexed (fn [a b] [a b]) clj-data))
               sb (.append ^StringBuilder sb "}")]
           sb))

;; the general dispatch function, used recursively in 
       ;; the collection encoders:

(clj->php* [^StringBuilder sb clj-data]
         (cond
           ;; sorted in some decently performant order
           (integer? clj-data) (encode-int* sb clj-data)
           (string? clj-data)  (encode-string* sb clj-data)
           (map? clj-data)     (encode-map* sb clj-data)
           (vector? clj-data)  (encode-map* sb clj-data)           
           (coll? clj-data)    (encode-collection* sb clj-data)
           (nil? clj-data)     (.append sb "N;")
           (true? clj-data)    (.append sb "b:1;")
           (false? clj-data)   (.append sb "b:0;")
           (float? clj-data)   (encode-float* sb clj-data)
           :else (throw (ex-info "cannot encode" 
                                 {:val clj-data
                                  :class (class clj-data)}))))]

;; str realizes the StringBuilder.
    (str (clj->php* (StringBuilder.) clj-data))))

;;;; example:

(clj->php {"a-vector" [42 "hello"]
           "this is a FLOAT:" 505.3
           "inner-map" {"submap" 1}
           "boolean value" false})
;; =>
;;ordered map with four kv pairs, unescaped and line breaked for some readability:

a:4:
{s:8:"a-vector";
 a:2:{i:0;i:42;
      i:1;s:5:"hello";}

s:16:"this is a FLOAT:";d:505.3;

s:9:"inner-map";
 a:1:{s:6:"submap";i:1;}

s:13:\"boolean value";b:0;
}

Note by Justinus¶

Using letfn allows you to create local functions that reference each other whereas (let myfunc #(...)]...) wouldn't because it executes its bindings serially.

Note by reborg¶

To be more precise (about the note above), letfn allows ahead-of-definition use of functions. The following is ok:

(defn testme [] 
  (let [twice (fn [x] (* x 2))
        six-times (fn [y] (* (twice y) 3))] 
  (println "15x6=" (six-times 15))))

But this one for instance doesn't compile (and would be ok with letfn):

(defn testme [] 
  (let [twelve-times (fn [x] (* (six-times x) 2)) 
        six-times (fn [y] (* y 6))] 
  (println "2x12=" (twelve-times 2))))

Note by muhuk¶

(letfn [(six-times [y]
           (* (twice y) 3))
        (twice [x]
           (* x 2))]
  (println "Twice 15 =" (twice 15))
  (println "Six times 15 =" (six-times 15)))
;; Twice 15 = 30
;; Six times 15 = 90
;;=> nil

Note by mars0i¶

And just to clarify further what is already implicit in other remarks, letfn allows a definition to refer to itself recursively:

(letfn [(my-range [n]
          (when (pos? n)
            (cons n (my-range (dec n)))))]
  (my-range 5))
;;=> (5 4 3 2 1)

but let doesn't:

(let [my-range (fn [n]
                   (when (pos? n)
                     (cons n (my-range (dec n)))))]
  (my-range 5))
Syntax error compiling at ...
Unable to resolve symbol: my-range in this context

Note by miner¶

This is a bit of tangent, but the fn form optionally takes a name, which allows recursive calls. You still need leftn for mutually recursive functions.

(let [my-range (fn my-range [n]
                   (when (pos? n)
                     (cons n (my-range (dec n)))))]
  (my-range 5))
;;=> (5 4 3 2 1)

clojure.core/letfn¶