@bbloom: I think that is inherited from Common Lisp, and perhaps inherited by choice because it is useful for having a final default value that can be an arbitrary value that is neither nil nor false.

andy.fingerhut: does common lisp even have a false boolean value? i thought it did not

I'd guess it's just consistency - if or returns the first truthy form, then in case no form is truthy returning last tested form seems sensible. (or whatever false) seems like a pretty neat trick though.

@bbloom: Having a final default value that is arbitrary is useful in both Common Lisp and CLojure.

fair enough

i guess i answered my own question then

thx

Hmm, I'm aware of http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/*data-readers*, but how about function to write a custom tagged literal?

Hi How do I tell clojure I want a local binding resolved at compile-time (or only once, at least)?

(defn f [] 1)

(defn g []
  (let [x (f)]         ; result of f is a constant, call it only once, not every time I call g
    x)

memoize?

Well, you need to close over it.

In that case you'e not closing over it

(let [x (f)]
  (def g []
    x))

I don't understand that code... where did my constant (1) go?

oh.... nvm

Makes sense

Yeah, I just rewrote the second function. First is left as-is.

it is defn g, right?

Yeah, I typo'd

Thank you very much, @jaen

No problem. Though it's rather unusual to use defn while closing something over. What's your use case?

The "constant" is a map of string to numbers. I could write the literal, but it is large and looks like magic. Instead I prefer to generate it programatically (clearer what it means that way), but it seems wasteful to do it everytime I call the function that uses it.

Oh

Then why not just (def string-to-number-mapping (make-string-to-number-mapping))

That polutes the namespace

Or is that not considered an issue?

Well, does it pollute the namespace?

It's a constant

If you don't want others to see it you could (def ^:private name ...) it, I suppose.

That would be an option as well (yeah, I don't want others to see it). Is that the idiomatic way? Your first solution seemed better at first glance, since it makes it clear that the binding is only used by that function.

Well, that depends on your taste, I suppose.

I would feel iffy to def not on the top level.

Even if that's just a let.

I'd rather def the constant at the toplevel before I use it

And then refer to it.

Not sure which is more idiomatic though.

Yeah, you are right. "`def` only at top level" is a good argument for the latter.

Thanks, again

Sure thing

Clojure records are more efficient than regular Clojure maps, especially when you have keys that stay the same So are transients of maps, especially when you have data that are private to one process and mutated very frequently. But Clojure currently does not support transients of records (http://dev.clojure.org/jira/browse/CLJ-1459). This means that people have to choose between records and transients; we cannot have both. If we need to store private state that both mutates very frequently (e.g., for the state of a stateful transducer) yet maintains the same keys, then should we, in general, use record volatiles or map transients?

cigitia: you can build a record via a transient map via (map->SomeRecord (persistent! m))

I guess it could make sense in some scenarios