Clojure operators in higher-order functions

Question

I've put together a higher order function that in certain cases calls a function parameter, but it seems to have different effects depending on the function. I was able to reproduce the same behaviour just with a simple function:

(defn foo [f a b] (f a b))

For "normal" functions it works fine:

user=> (foo list 2 3)
(2 3)
user=> (foo cons 1 '(2 3))
(1 2 3)
user=> (foo println 2 3)
2 3
nil

But for operators, it does not, it just seems to return the last element:

user=> (foo '+ 2 3)
3
user=> (foo '* 2 3)
3
user=> (foo '- 2 3)
3

Why is this the case?

Just as a fun fact of why "it just seems to return the last element", see here (the second arg given is a default, which it's defaulting to). I don't know why you'd need to do this, but it lets you do something like ('+ {'+ 2}) returns 2. — Carcigenicate
– Carcigenicate, Commented Sep 7, 2019 at 0:03
@Carcigenicate For the same reason you'd want to do it for keywords, of course. Sometimes you might just have a map keyed by symbol for whatever reason (e.g., the lexical environment when implementing an interpreter), and it's not crazy to want to be able to use symbols as functions to look themselves up. — amalloy
– amalloy, Commented Sep 7, 2019 at 1:55
@amalloy That's true. I just don't think I've ever had the need to do a lookup like that. — Carcigenicate
– Carcigenicate, Commented Sep 7, 2019 at 1:59

Taylor Wood · Accepted Answer · 2019-09-07 00:12:16Z

6

user=> (foo '+ 2 3)
3

Why is this the case?

' (or quote) is creating a symbol of + when you want the + function value itself: https://clojure.org/guides/weird_characters#_quote

(quote foo) => foo ;; symbol
'foo => foo ;; symbol

So the behavior of always returning the second argument comes from the fact that symbols (like keywords) also act as functions, typically used as a shorthand for get on associative structures (like maps), so these are functionally equivalent:

('foo 1 2) => 2
(get 1 'foo 2) => 2

The 2 happens to be in the position used for default values when the key isn't found in the associative structure.

This would be useful if you had a map with symbol keys, just like keywords:

('foo {'foo 1}) => 1
({'foo 1} 'foo) => 1
('foo {'bar 1} 2) => 2

answered Sep 7, 2019 at 0:12

Taylor Wood

16.2k1 gold badge24 silver badges38 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Alan Thompson Over a year ago

Crazy! I have never heard of this. I would consider it a "gotcha" instead of a "feature".

Alan Thompson · Accepted Answer · 2019-09-06 22:51:02Z

1

In clojure, "operators" like + are just normal functions. Don't use the single-quote and it'll work fine.

(ns tst.demo.core
  (:use tupelo.core tupelo.test))

(defn foo [f a b] (f a b))

(dotest
  (spyx (foo list 2 3))
  (spyx (foo println 2 3))
  (spyx (foo + 2 3))
  (spyx (foo * 2 3))
  (spyx (foo - 2 3)) )

with results:

(foo list 2 3) => (2 3)

2 3                        ; result of (println 2 3)
(foo println 2 3) => nil   ; println always returns `nil`

(foo + 2 3) => 5
(foo * 2 3) => 6
(foo - 2 3) => -1

The helper function spyx just prints an expression, then its value.

answered Sep 6, 2019 at 22:51

Alan Thompson

30k7 gold badges46 silver badges51 bronze badges

Collectives™ on Stack Overflow

Clojure operators in higher-order functions

2 Answers 2

1 Comment

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related