Recently I started to learn Clojure, and usually, my first phase is to complete small programming exercises. To practice Clojure I decided to solve some CodingBat problems. A common task here is to check, if an array does contain some value. The expected result should be a boolean value. When I moved to practical implementations, I realized how tricky can be a simple thing in Clojure.

In this post I would like to share with you some thoughts on how to check, that a list contains an element in Clojure. As almost any beginner I have started with `contains?` method, however it may not be your best option. I will explain to you several solutions, including ones, that come from Java.

## What is wrong with contains? function?

This is an expected question. To explain it, let me take a simple exercise from CodingBat. For example, array-1/has23. The problem statement asks us to return a boolean value, which reflects if the given array contains 2 or 3. Pretty simple, isn’t it? Let start with `contains?` function. Take a look on the following code snippet below:

```(defn has23 [numbers]
(or (contains? numbers 2) (contains? numbers 3))
)

(println (has23 [2 5]))
(println (has23 [4 5]))
(println (has23 [1 3]))```

What is wrong with this code? When you will execute it you will receive an output, similar to this:

```false
false
false```

But there are values – the first list has 2 and the last one has 3, why it is false? The answer is in the purpose of this method. `contains?` returns a boolean value, which represents if a data structure contains a key. So, it works for associative data structures (like maps). For lists a key is an index of an element. Because we have an array of 2 elements, it can’t have an index 2 and moreover 3! As a result, this approach would not work. Hopefully, there are others.

## Using some

When you will search for the solution, most probably you will find recommendations to use `some`. It works fine with sequential data structures, like lists. This function takes two arguments: a predicate (logical condition) and a data structure itself. The return is a first matching element.

Let try it with an another exercise – warmup-2/arrayFront9. The task here demands us to return true, if there is 9 in first 4 elements. Note, that I use `take` function to get first 4 elements:

```(defn arrayFront9 [numbers]
(some #{9} (take 4 numbers))
)

(println (arrayFront9 [1 2 9 3 4]))```

The output of the code listing above is `9`.

Now we will check result with a list, which does not have 9 among first four elements:

```(defn arrayFront9 [numbers]
(some #{9} (take 4 numbers))
)

(println (arrayFront9 [1 2 3 4 9]))```

In this case, the output is `nil`. This may lead to an error, if another logic relies on this function, which can return a null value. Furthermore, we need to get a boolean result. Let refactor our solution:

```(defn arrayFront9 [numbers]
(not= (some #{9} (take 4 numbers)) nil)
)

(println (arrayFront9 [1 2 9 3 4]))
(println (arrayFront9 [1 2 3 4 9]))```

I added an assertion to check if the element is not null. In other words, if 9 does exist among first subsequence, it will be returned, otherwise the result will be null. So, I wrapped it around logical validation to return a boolean value. The output of this code is:

```true
false```

As expected!

## Go Java

In my previous post on Clojure exception handling, I stated that as Clojure runs on JVM it inherits a lot of from Java. That leads us to an another solution – using Java methods to work with collections. If you have read my article on Java collections, you may remember that we have two methods in our disposal:

• `contains` = returns true if an element is presented in a collection
• `indexOf` = returns an index of an element, or -1 in case of its absence

In this section we will observe, how to use them both.

### Contains

Let take the exercise called array-1/no23. It is a mirror to what we have already solved in `has23`, but now we need to assure, that the list does not contain 2 or 3. In order to call Java methods in Clojure we utilize a concept of dot notation:

```(defn no23 [numbers]
(not (or (.contains numbers 2) (.contains numbers 3)))
)

(println (no23 [5 4]))
(println (no23 [2 1]))
(println (no23 [4 3]))```

When you will run this code snippet, you will receive an output like that:

```true
false
false```

Remember, that we are expected to find an absence of 2 and 3 in a list. This means, we need to negate a result of calling `.contains` function.

### IndexOf

While looking for a solution, I have found an interesting approach. It is based on using `indexOf` method. As you remember, this function checks for an element and returns its index or -1 (when an element is not in a list).

To illustrate this point let take again `arrayFront9` exercise, but not we will refactor it to use `indexOf`. Take a look on my implementation below:

```(defn arrayFront9IndexOf [numbers]
(not= (.indexOf (take 4 numbers) 9) -1)
)

(println (arrayFront9IndexOf [1 2 9 3 4]))
(println (arrayFront9IndexOf [1 2 3 4 9]))```

The result of an execution will be following:

```true
false```

We use negation `not=` in a similar way, like with `some`. We need to validate, that a result from calling `indexOf` function is not equal to -1 (that means an absence of 9). Any other value corresponds to a presence.

## Do you want to increase your Java collections skills?

This topic is really huge, and a single post is not enough to cover all. That is why I wrote this Practical Guide. Everything you need in the one book. Do you want to become Java ninja?

That is all for this post. Hope, that it helped you in a some manner. If you have questions regarding a topic of how to check if a list contains a value in Clojure, you can ask them in comments below or contact me directly.