Converting Array to List in Scala

Now, this has to have a built-in somewhere in Scala, because it just seems too common. So, how to convert an Array to a List in Scala?

Why do I need this? I needed to drop to Java for some functionality, which in this case returns an Array. I wanted to get that Array into a List to practice my functional programming skillz.

**Update**: I figured out how to convert Arrays to Lists the Scala way. Turns out it's a piece of cake.

val myList = List.fromArray(Array("one", "two", "three"))

or

val myList = Array("one","two","three").elements.toList

The call to elements returns an Iterator, and from there you can convert to a List via toList. Nice.

Because my first version wasn't actually tail recursive, what follows is a true tail recursive solution, if I were to implement this by hand. The above, built in mechanism is much better, though.

object ArrayUtil {
  def toList[a](array: Array[a]): List[a] = {
    def convert(arr: Array[a], aggregator: List[a]): List[a] = {
      if (arr == null || arr.length == 0) aggregator
      else convert(arr.slice(0, arr.length-1), arr(arr.length-1) :: aggregator)
    }
	convert(array, Nil)
  }
}

The above code is interesting because it demonstrates a nested function. The convert function is nested inside toList. Scala encourages the decomposition of your problem into smaller and smaller functions.

*What follows is my original attempt.* Left here for a historical, "what not to do" perspective.

Here's my implementation of it, but if you know if there's a built-in function already implemented, please let me know.

object ArrayUtil {
  def toList[a](array: Array[a]): List[a] = {
    if (array == null || array.length == 0) Nil
    else if (array.length == 1) List(array(0))
    else array(0) :: toList(array.slice(1, array.length))
  }
}

To quickly explain this, an object in Scala is a singleton instance of its class. The method toList is parameterized with type a. This is similar to generics in Java. Lastly, the :: operator (pronouned cons in Scala) creates a new List from a single item (the head, on the left) and another List (the tail, on the right). Oh, and Nil represents an empty List.