CODEWITHSUNDEEP
lispclojureletfunction
Jason Baker
Jason Baker

Reputation: 198577

let vs def in clojure

I want to make a local instance of a Java Scanner class in a clojure program. Why does this not work:

; gives me:  count not supported on this type: Symbol 
(let s (new Scanner "a b c"))

but it will let me create a global instance like this:

(def s (new Scanner "a b c"))

I was under the impression that the only difference was scope, but apparently not. What is the difference between let and def?

Upvotes: 41

Views: 13107

Answers (6)

Rayne
Rayne

Reputation: 32625

The problem is that your use of let is wrong.

let works like this:

(let [identifier (expr)])

So your example should be something like this:

(let [s (Scanner. "a b c")]
  (exprs))

You can only use the lexical bindings made with let within the scope of let (the opening and closing parens). Let just creates a set of lexical bindings. I use def for making a global binding and lets for binding something I want only in the scope of the let as it keeps things clean. They both have their uses.

NOTE: (Class.) is the same as (new Class), it's just syntactic sugar.

Upvotes: 59

d11wtq
d11wtq

Reputation: 35308

You could think of let as syntactic sugar for creating a new lexical scope with fn then applying it immediately:

(let [a 3 b 7] (* a b))  ; 21
; vs.
((fn [a b] (* a b)) 3 7) ; 21

So you could implement let with a simple macro and fn:

(defmacro fnlet [bindings & body]
  ((fn [pairs]
    `((fn [~@(map first pairs)] ~@body) ~@(map last pairs)))
   (partition 2 bindings)))

(fnlet [a 3 b 7] (* a b)) ; 21

Upvotes: 4

Marko
Marko

Reputation: 31385

Simplified: def is for global constants, let is for local variables.

Upvotes: 14

Svante
Svante

Reputation: 51501

LET is not "make a lexical binding in the current scope", but "make a new lexical scope with the following bindings".

(let [s (foo whatever)]
  ;; s is bound here
  )
;; but not here

(def s (foo whatever))
;; s is bound here

Upvotes: 35

MarkusQ
MarkusQ

Reputation: 21950

The syntax for them is different, even if the meanings are related.

let takes a list of bindings (name value pairs) followed by expressions to evaluate in the context of those binding.

def just takes one binding, not a list, and adds it to the global context.

Upvotes: 5

ayrnieu
ayrnieu

Reputation: 1899

Correct syntax:

(let [s (Scanner. "a b c")] ...)

Upvotes: 13

Related Questions