Semergence

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.

This entry was posted on Wednesday, June 20th, 2007 at 9:43 pm and is filed under scala. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.