Clojure Q&A - Recent questions tagged function

Evaluating forms using eval can create a valid undesirable recursion point

Mon, 16 Mar 2026 23:17:54 +0000

When the eval function in Clojure is called with an argument that is an instance of IPersistentCollection which likely isn't a special def-like form (the first element isn't a symbol at all or it does not start with "def"), the form is first wrapped in an anonymous function which then gets compiled and invoked, which indirectly evaluates the original form.

There aren't any extra checks performed and it makes forms like these 2 valid, which should normally be rejected and a compiler exception should be thrown:

(recur)

(let []
  (print "Hello")
  (Thread/sleep 1000)
  (recur))

where the 2nd form keeps printing "Hello" and loops infinitely over the outer wrapper function.

Somewhat confusing sorted-set behavior

Thu, 23 Dec 2021 12:22:35 +0000

Just ran into some interesting behavior with sorted-set. Namely, the contract to the user for a normal set is nil when the element doesn't exist. However, with sorted-set, the call will throw if the comparator doesn't gracefully handle the type. The reason makes sense (the comparator requires the ability to sanely compare elements), but the interface is somewhat confusing in the "no membership" case since we know that the element doesn't exist in the set if its type can't be compared by default.

In other words, I guess I'm proposing that a sane default behavior for a sorted-set using the default comparator should be nil rather than throw when the type cannot be compared, in order to allow nil-punning.

As an example, this case was encountered when the form was passed to a keyword function (:foobar form), which allows nil-punning on a lot of other collections. Here's a small snippet:

`
user> (def normal #{"0000"})

;; => #'user/normal

user> (def sorted-version (sorted-set "0000"))

;; => #'user/sorted-version

user> normal

;; => #{"0000"}

user> sorted-version

;; => #{"0000"}

user> (:foobar normal)

;; => nil

user> (:foobar sorted-version)

Execution error (ClassCastException) at user/eval246355 (form-init59552761865518221.clj:8123).
class java.lang.String cannot be cast to class clojure.lang.Keyword (java.lang.String is in module java.base of loader 'bootstrap'; clojure.lang.Keyword is in unnamed module of loader 'app')
`

I think my options for handling this are either try/catch or write a custom comparator, and both seem a little wonky :)

I'm probably missing something, but thought it was interesting anyway :)

Does the `any?` function have the correct behavior?

Tue, 09 Nov 2021 22:30:57 +0000

Clojure's any? function seems to just return true always.
(defn any? "Returns true given any argument." {:tag Boolean :added "1.9"} [x] true)

Contrast this with not-any?.
(def ^{:tag Boolean :doc "Returns false if (pred x) is logical true for any x in coll, else true." :arglists '([pred coll]) :added "1.0"} not-any? (comp not some))

I believe any? should take two arguments and return true if any predicate is true.
(def ^{:tag Boolean :doc "Returns true if (pred x) is logical true for any x in coll, else false." :arglists '([pred coll]) :added "1.9"} any? (comp boolean some))
Credit to Kofrasa on ClojureDocs.

Here are some tests to run:

`
(ns user
(:require [clojure.test :refer [are deftest]]

        [clojure.test.check.clojure-test :refer [defspec]]
        [clojure.test.check.generators :as gen]
        [clojure.test.check.properties :as prop])

(:refer-clojure :exclude [any?]))

(deftest clojure-any
(are [x y] (= ((comp boolean some) true? x) (clojure.core/any? y))

[true] true
[false] false ;; this fails
[true true] true
[false true] true
[false false] false ;; so does this
))

(def
^{:tag Boolean
:doc "Returns true if (pred x) is logical true for any x in coll,
else false."
:arglists '([pred coll])
:added "1.9"}
any? (comp boolean some))

(defspec correct-any 1000
(prop/for-all [v (gen/such-that not-empty (gen/vector gen/boolean))]

            (= ((comp boolean some) true? v)
               (any? true? v)
               (not (not-any? true? v)))))

Apologies for the messed-up formatting.
https://gist.github.com/wildwestrom/9568e9c659d30a2a663a9a0a8235a6b9

function spec challenge

Wed, 07 Oct 2020 03:38:56 +0000

What is the simplest way to spec this function? Specifically, the :fn portion

(s/def ::edges #{0.149 0.150 0.050})
(s/def ::result #{:correct :incorrect})

(s/fdef foo
        :args (s/cat :student-response ::edges :authoritative-answer ::edges)
        :ret ::result
:fn ? )

Basically, if the student-response rounded to the tenths place matches the authoritative-answer rounded to the tenths place, the function returns :correct, otherwise :incorrect.

I selected edges that would hit the rounding boundaries rather than hoping the generative process for numbers would stumble on those edges.

Retrieving the domain/range of finite functions

Sun, 19 Apr 2020 18:32:29 +0000

One of the great features of Clojure is that it considers collections as functions which means that it is possible to invoke them

({:a 1, :b 2} :a) => 1
(#{:a :b} :a) => :a
([:a :b :c] 1) => :b

However it would be nice to be able to query the domain and range of those functions independently of their specific type.

The keys and vals functions currently implement this but only for Maps. I think it would be a good idea to make those functions more generic by accepting sets and vectors like in the following examples:

(keys  #{:a :b}) => (:a :b)
(vals #{:a :b}) => (:a :b)
(keys [:a :b :c]) => (0 1 2)
(vals [:a :b :c]) => (:a :b :c)

The specific use case I have in mind where this feature could be useful is to define a shorter syntax for explicit foreign key mapping in a data oriented DSL for relational data modeling, where #{:attr1 :attr2} could be used as a shortcut for {:attr1 :attr1, :attr2 :attr2}.

Functions in clojure

Sat, 22 Feb 2020 18:30:39 +0000

I have a task to create a function which gives powerset of a list.

Output of the list (1 2 3) should be this:

1
2
3
1 2
1 3
2 3
1 2 3
I tried this helper function

(defn print-powerset-helper [lst] (if(not(empty? lst)) (do (println(first lst)) (print-lst (rest lst)))))
which gives me

1
2
3
nil
this output.

I also tired this fucntion:

(defn print-powerset [lst] (if (not (empty? lst)) (do (apply println lst (print-lst lst)))))
output:

1
2
3
(1 2 3)
nil
I want to get rid of parenthesis and also don't understand how to print the middle part of the output. 1 2 1 3 2 3 , this part.

Please any kind of help will be good. Thank you!

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

Thu, 31 Oct 2019 17:13:37 +0000

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

Why does Transit not allow serialization of clojure(script) functions ? What is the inherent difficulty there ?

Mon, 29 Jul 2019 23:10:55 +0000

I am trying to serialize my datascript database to JSON for storage on a filesystem.
Some of the data inside my database includes functions. For reasons that are not interesting, I need to store them in the database for now with other session info for the application. But I get an exception that transit "cannot write Function"

I looked at the code and it simply tries to handle data structures only - maps, vectors, etc. But there is no handler for functions. So I KNOW WHY I get the error, but the gist of my question is why it was not implemented to be able to serialize functions as well ?

Is it just too novel an thought ?

thanks