StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
primarykey
Id
2021343
data
AcceptedAnswerId
0
AnswerCount
0
ClosedDate
CommentCount
8
CommunityOwnedDate
2010-01-07T19:15:49.320
CreationDate
2010-01-07T15:24:58.777
FavoriteCount
0
LastActivityDate
2014-08-01T01:48:19.977
LastEditDate
2014-08-01T01:48:19.977
LastEditorUserId
606355
OwnerUserId
70288
ParentId
2020570
PostTypeId
2
Score
71
ViewCount
0
LastEditorDisplayName
text
Body
Literal Octals At one point I was reading in a matrix which used leading zeros to maintain proper rows and columns. Mathematically this is correct, since leading zero obviously don't alter the underlying value. Attempts to define a var with this matrix, however, would fail mysteriously with: <pre><code>java.lang.NumberFormatException: Invalid number: 08 </code></pre> which totally baffled me. The reason is that Clojure treats literal integer values with leading zeros as octals, and there is no number 08 in octal. I should also mention that Clojure supports traditional Java hexadecimal values via the 0x prefix. You can also use any base between 2 and 36 by using the "base+r+value" notation, such as 2r101010 or 36r16 which are 42 base ten. <hr> Trying to return literals in an <a href="http://clojure.org/reader#toc2" rel="noreferrer">anonymous function literal</a> This works: <pre><code>user> (defn foo [key val] {key val}) #'user/foo user> (foo :a 1) {:a 1} </code></pre> so I believed this would also work: <pre><code>(#({%1 %2}) :a 1) </code></pre> but it fails with: <pre><code>java.lang.IllegalArgumentException: Wrong number of args passed to: PersistentArrayMap </code></pre> because the #() reader macro gets expanded to <pre><code>(fn [%1 %2] ({%1 %2})) </code></pre> with the map literal wrapped in parenthesis. Since it's the first element, it's treated as a function (which a literal map actually is), but no required arguments (such as a key) are provided. In summary, the anonymous function literal does not expand to <pre><code>(fn [%1 %2] {%1 %2}) ; notice the lack of parenthesis </code></pre> and so you can't have any literal value ([], :a, 4, %) as the body of the anonymous function. Two solutions have been given in the comments. Brian Carper suggests using sequence implementation constructors (array-map, hash-set, vector) like so: <pre><code>(#(array-map %1 %2) :a 1) </code></pre> while Dan shows that you can use the <a href="http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/identity" rel="noreferrer">identity</a> function to unwrap the outer parenthesis: <pre><code>(#(identity {%1 %2}) :a 1) </code></pre> Brian's suggestion actually brings me to my next mistake... <hr> Thinking that <a href="http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/hash-map" rel="noreferrer">hash-map</a> or <a href="http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/array-map" rel="noreferrer">array-map</a> determine the unchanging concrete map implementation Consider the following: <pre><code>user> (class (hash-map)) clojure.lang.PersistentArrayMap user> (class (hash-map :a 1)) clojure.lang.PersistentHashMap user> (class (assoc (apply array-map (range 2000)) :a :1)) clojure.lang.PersistentHashMap </code></pre> While you generally won't have to worry about the concrete implementation of a Clojure map, you should know that functions which grow a map - like assoc or conj - can take a PersistentArrayMap and return a PersistentHashMap, which performs faster for larger maps. <hr> Using a function as the recursion point rather than a <a href="http://clojure.org/special_forms#toc11" rel="noreferrer">loop</a> to provide initial bindings When I started out, I wrote a lot of functions like this: <pre><code>; Project Euler #3 (defn p3 ([] (p3 775147 600851475143 3)) ([i n times] (if (and (divides? i n) (fast-prime? i times)) i (recur (dec i) n times)))) </code></pre> When in fact <a href="http://clojure.org/special_forms#toc11" rel="noreferrer">loop</a> would have been more concise and idiomatic for this particular function: <pre><code>; Elapsed time: 387 msecs (defn p3 [] {:post [(= % 6857)]} (loop [i 775147 n 600851475143 times 3] (if (and (divides? i n) (fast-prime? i times)) i (recur (dec i) n times)))) </code></pre> Notice that I replaced the empty argument, "default constructor" function body (p3 775147 600851475143 3) with a loop + initial binding. The recur now rebinds the loop bindings (instead of the fn parameters) and jumps back to the recursion point (loop, instead of fn). <hr> Referencing "phantom" vars I'm speaking about the type of var you might define using the REPL - during your exploratory programming - then unknowingly reference in your source. Everything works fine until you reload the namespace (perhaps by closing your editor) and later discover a bunch of unbound symbols referenced throughout your code. This also happens frequently when you're refactoring, moving a var from one namespace to another. <hr> Treating the for <a href="http://en.wikipedia.org/wiki/List_comprehension" rel="noreferrer">list comprehension</a> like an imperative for loop Essentially you're creating a lazy list based on existing lists rather than simply performing a controlled loop. Clojure's <a href="http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/doseq" rel="noreferrer">doseq</a> is actually more analogous to imperative foreach looping constructs. One example of how they're different is the ability to filter which elements they iterate over using arbitrary predicates: <pre><code>user> (for [n '(1 2 3 4) :when (even? n)] n) (2 4) user> (for [n '(4 3 2 1) :while (even? n)] n) (4) </code></pre> Another way they're different is that they can operate on infinite lazy sequences: <pre><code>user> (take 5 (for [x (iterate inc 0) :when (> (* x x) 3)] (* 2 x))) (4 6 8 10 12) </code></pre> They also can handle more than one binding expression, iterating over the rightmost expression first and working its way left: <pre><code>user> (for [x '(1 2 3) y '(\a \b \c)] (str x y)) ("1a" "1b" "1c" "2a" "2b" "2c" "3a" "3b" "3c") </code></pre> There's also no break or continue to exit prematurely. <hr> Overuse of structs I come from an OOPish background so when I started Clojure my brain was still thinking in terms of objects. I found myself modeling everything as a struct because its grouping of "members", however loose, made me feel comfortable. In reality, structs should mostly be considered an optimization; Clojure will share the keys and some lookup information to conserve memory. You can further optimize them by defining <a href="http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/accessor" rel="noreferrer">accessors</a> to speed up the key lookup process. Overall you don't gain anything from using a struct over a map except for performance, so the added complexity might not be worth it. <hr> Using unsugared BigDecimal constructors I needed a lot of <a href="http://java.sun.com/j2se/1.5.0/docs/api/java/math/BigDecimal.html" rel="noreferrer">BigDecimals</a> and was writing ugly code like this: <pre><code>(let [foo (BigDecimal. "1") bar (BigDecimal. "42.42") baz (BigDecimal. "24.24")] </code></pre> when in fact Clojure supports BigDecimal literals by appending M to the number: <pre><code>(= (BigDecimal. "42.42") 42.42M) ; true </code></pre> Using the sugared version cuts out a lot of the bloat. In the comments, twils mentioned that you can also use the <a href="http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/bigdec" rel="noreferrer">bigdec</a> and <a href="http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/bigint" rel="noreferrer">bigint</a> functions to be more explicit, yet remain concise. <hr> Using the Java package naming conversions for namespaces This isn't actually a mistake per se, but rather something that goes against the idiomatic structure and naming of a typical Clojure project. My first substantial Clojure project had namespace declarations - and corresponding folder structures - like this: <pre><code>(ns com.14clouds.myapp.repository) </code></pre> which bloated up my fully-qualified function references: <pre><code>(com.14clouds.myapp.repository/load-by-name "foo") </code></pre> To complicate things even more, I used a standard <a href="http://maven.apache.org/" rel="noreferrer">Maven</a> directory structure: <pre><code>|-- src/ | |-- main/ | | |-- java/ | | |-- clojure/ | | |-- resources/ | |-- test/ ... </code></pre> which is more complex than the "standard" Clojure structure of: <pre><code>|-- src/ |-- test/ |-- resources/ </code></pre> which is the default of <a href="http://github.com/technomancy/leiningen" rel="noreferrer">Leiningen</a> projects and <a href="http://github.com/richhickey/clojure/" rel="noreferrer">Clojure</a> itself. <hr> Maps utilize Java's equals() rather than Clojure's = for key matching Originally reported by chouser on <a href="http://irc.freenode.net/#clojure" rel="noreferrer">IRC</a>, this usage of Java's equals() leads to some unintuitive results: <pre><code>user> (= (int 1) (long 1)) true user> ({(int 1) :found} (int 1) :not-found) :found user> ({(int 1) :found} (long 1) :not-found) :not-found </code></pre> Since both Integer and Long instances of 1 are printed the same by default, it can be difficult to detect why your map isn't returning any values. This is especially true when you pass your key through a function which, perhaps unbeknownst to you, returns a long. It should be noted that using Java's equals() instead of Clojure's = is essential for maps to conform to the java.util.Map interface. <hr> I'm using <a href="http://pragprog.com/titles/shcloj/programming-clojure" rel="noreferrer">Programming Clojure</a> by Stuart Halloway, <a href="http://www.apress.com/book/view/1430272317" rel="noreferrer">Practical Clojure</a> by Luke VanderHart, and the help of countless Clojure hackers on <a href="http://irc.freenode.net/#clojure" rel="noreferrer">IRC</a> and the mailing list to help along my answers. 
Tags
Title
singulars
PostAcceptedAnswerId
1. This table or related slice is empty.
PostParentId
1. POCommon programming mistakes for Clojure developers to avoid
 singulars
 PostTypePostTypeId
 PTQuestion
PostTypePostTypeId
1. PTAnswer
UserLastEditorUserId
1. USattomos
UserOwnerUserId
1. USrcampbell
plurals
PostLinksPostIdRelatedPostId
1. This table or related slice is empty.
PostLinksRelatedPostIdPostId
1. This table or related slice is empty.
PostsAcceptedAnswerId
1. This table or related slice is empty.
PostsParentIdCreationDate
1. This table or related slice is empty.
VotesPostIdCreationDate
1. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
2. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
3. VO
 singulars
 PostPostId
 PO
 UserUserId
 This table or related slice is empty.
 VoteTypeVoteTypeId
 VTUpMod
CommentsPostId

Querying!

Guidance

A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.