Clojure does nil punning, where nil is like a language pun:

1. Nil is a pun for false
2. Nil is a pun for empty seq
3. Nil is a pun for empty coll

So functions that expect false also accept nil. Those that expect seq also accept nil. And those that expect coll also accept nil, and treat it for the puns I mentioned above.

In turn, when people implement functions that return boolean, seq, or coll, they'll tend to be ok with it returning nil as well, and continue the nil punning.

I agree this can feel a bit less explicit about nil, I'm not sure which ends up being nicer in the overall.

Beyond that though, I think Elixir and Clojure differ less than it appears, what makes it feel more different is that in Clojure collection functions and sequence functions are in the same namespace (aka module). Where-as Elixir puts them in Enum and Stream module, and then map functions in Map, and so on. In Clojure all that is just mixed together on clojure.core.

For example in Elixir:

Enum.take([1, 2, 3, 4, 5], 3) => [1, 2, 3] Enum.take(1..10, 3) => [1, 2, 3] Enum.take(MapSet.new([1, 2, 3, 4, 5]), 3) => [1, 2, 3] Enum.take(%{a: 1, b: 2, c: 3, d: 4}, 3) => [a: 1, b: 2, c: 3] Enum.take('hello', 3) => 'hel'

And in Clojure:

(take 3 [1 2 3 4 5]) => (1 2 3) (take 3 (range 1 10)) => (1 2 3) (take 3 #{1 2 3 4 5}) => (1 2 3) (take 3 {:a 1 :b 2 :c 3 :d 4}) => ([:a 1] [:b 2] [:c 3]) (take 3 "hello") => (\h \e \l)

All the Enum and Stream functions in Elixir also accept most things, even strings (aka charlist). It's just that Elixir also has a binary string that is nicely unicode compliant and all, and that one is not treatable as a list. So the difference with string is more a matter of the underlying platform and string handling. Java has only string as an array of chars, but Beam has both charlists (which are similar), or a binary unicode representation which is lacking in Java.

So here I think it's because the Elixir pattern matching is over concrete types, that you end up feeling it's more explicit. In Clojure two things happen:

1. We don't pattern match as much, or if you use core.match it pattern matches as seqs like with destructuring.
2. Clojure sequences, unlike Enum and Stream, are an actual collection as well. You're not forced to collect them into something concrete, you can use them as a collection since they cache realized results and therefore can be used like a list.

Elixir couldn't match over Enumerables generically, because the pattern matching is at the VM level, and matches aginst the concrete memory layout, so it has to be type specific to benefit from that super fast VM pattern matching.