or something like that. (this is from memory, hope it's right) You can then let it take a variable number of arguments to make it even more concise. (yes, I've stolen the assoc semantics from Clojure, minus the pure functional aspect)
Well, a macro but yes. Still, if you have to write a macro for something as trivial as that, that in itself is a problem. Especially when other people start reading your code.
Last project I worked on had 9154 lines of lisp code out of which 4800 lines are utilities, that I've accumulated and written.
The utilities cover everything from hash, list, string, files, function, a simple version of prolog, some algorithms like bloomfilter, suffix-tree, a simple bayesian filter implementation and a lot of stuff makes writing code easier.
So it's pretty normal to have a large set of utilities that you prefer. It sort of ensures that the code doesn't become to large.
I use (hput hash key value) and (hget hash key) a couple of functions, which I have. So it's a bit verbose than hash[key] = value or hash[key]. But it lets me write stuff like...
I wrote the code that reads that defexample macro and generates the data from it in 2 days. When I started I had no idea what the grammar was going to look like and how I was going to accomplish any of the details.
"Last project I worked on had 9154 lines of lisp code out of which 4800 lines are utilities, that I've accumulated and written."
"The utilities cover everything from hash, list, string, files, function, a simple version of prolog, some algorithms like bloomfilter, suffix-tree, a simple bayesian filter implementation and a lot of stuff makes writing code easier."
It is wonderful that you can write all that in 4800 lines in CL, and I know that's not hyperbole or exaggeration.
The problem is the parts covering hashes, lists, strings, files etc. are also being implemented by every other CL programmer, slightly differently. This makes it just that little bit harder to share and understand other people's code, which in turn makes it that little bit harder to build commonly agreed upon libraries for common things, and that little bit harder for people new to the language to get started.
This is all cumulative, and adds up to an actual shortcoming in my opinion. Clojure does a little better job here. For example, by having a common Seq interface shared by lists, arrays, sets, and hashes.
I didn't write a lot of the libraries. Maybe 50% of the code is mine, most the algorithm implementations, the rest of the stuff is picked up from previous projects or existing utilities that lisp programmer's have written.
The reason one uses lisp is because the team is small. Very small like 1 person. So sharing isn't really that much of a concern.
I agree that it makes it harder to start. Which means that very few people stick with it.
Why would you need a macro? Surely a function will suffice.
Whether or not this is acceptable is a matter of taste I guess. I couldn't get on with CL either and was glad to find Clojure, which is now my language of choice.
