Clojure functions to implement the Map interface. Why or Why not?

Question

From a theoretical standpoint, there really isn't a difference between a Map and a 1-arity function

What do you think of having a Function implement the Map interface? Will it be useful? If this was thought and you guys decided not to go with it, why not? Would love to learn the thinking

Answer 1

There is a lot of utility in making things functions, because that is the main abstraction for "things you invoke". There's a lot less utility in turning functions into maps (data). You can't easily read/print them like data, you can't generally compose them with other data, etc. Additionally, while all maps can be invoked as a lookup function, not all functions can be invoked as maps so it could only apply to a narrow set of functions. So, I'd say it's not useful and I don't see any benefit that would be gained from it.

Answer 2

What problem are you trying to solve?

Comments

Not really trying to solve a problem
I was just going through how symbols and keywords can act as functions that  do a lookup on the 2nd  parameter that  gets  passed to them (a map)

So just wondered a function is sort of a map too so (:key some-fn) should've worked but  that's ok because we can always write it as (some-fn :key)

I think the keyword/symbol as function was just a convenience?

---

but i'll definitely think if it will be helpful in anyway

---

Also, consider that you can say (some-map "a-key") but you can't say ("a-key" some-map) and you can say (some-vector 42) but you can't say (42 some-vector) -- it's not symmetric (and there's no reason for it to be). There are lots of things that can be a key/index on an associative thing that could not be used in the first position as if they were functions.

---

totally makes sense :) Not a language designer, so was just trying to understand the thought process

Answer 3

Semantically speaking, some properties of a Map are impossible to project to functions. Maps have count of elements, maps allow enumerating all elements they contain, this is not possible to do with functions.

Another downside I see is unpredictable complexity of get. Currently when calling get on a map, you can expect operation to be reasonbly fast. In case of (get itentity 1000) it holds, in case of (get #(do (Thread/sleep %) %) 1000) it doesn't. I like Clojure's predictable execution times, such as with conj, that is guaranteed to be O(1), while not guaranteeing item will be inserted into an end of a coll.

Comments

Wow the  first point  @vlaaad makes so much sense. Almost forgot  about that :) Thanks both of you