Found: String / Required: List[Any]?

[Hugh Angle]

The following prints "now" and "is":

	val any=List[Any]("now", 1, "is", 2)
	for(a<-any)
		a match {
			case s:String=> println(s) 
			case _=>
			}
}

I wanted to recursively collect any's strings into a list, so i
generalized from the above and wrote:

	def recurs(a:List[Any]):List[Any]={
		a match {
			case Nil=>Nil
			case s:String=> s :: recurs(a.tail)
			case _=>             recurs(a.tail)
			}
		}
	recurs(List("now", 1, "is", 2))
}

The following compile error occurred:
found : String
required: List[Any]
case s:String=> s :: recurs(a.tail)
^
I am not sure what this error message is telling me. It is the
basic question I am putting forward to this forum.

I corrected the compilation problem with the following; but I am unsure
as to why this worked:

	def recurs(a:List[Any]):List[Any]={
		a.head match {			//changed code
			case Nil=>Nil
			case s:String=> s :: recurs(a.tail)
			case _=>             recurs(a.tail)
			}
		}
	recurs(List("now", 1, "is", 2))
}

Of course, I now get a runtime exception 'ExceptionInInitializerError'.
When the 'any' list is empty, then the execution of 'a.head'
throws the exception. Easily fixed.

[Raymond Tong]

Hugh Angle wrote:

	def recurs(a:List[Any]):List[Any]={ // a is of type List[Any]
		a match {
			case Nil=>Nil
			case s:String=> s :: recurs(a.tail) // a can NOT be a String 's'
			case _=>             recurs(a.tail)
			}
		}
	recurs(List("now", 1, "is", 2))
}

The following compile error occurred:
found : String
required: List[Any]
case s:String=> s :: recurs(a.tail)
^

a is of type List[Any] and it is no way becomes String
a.head would work because Any is a super type of String

would the following code simpler?

List("now", 1, "is", 2).filter{_.isInstanceOf[String]}

if you prefer to use match

      def recurs2(a:List[Any]) : List[String] = {
        a match {
          case Nil => Nil
          case x :: xs => x match {
            				case s:String => s :: recurs2(xs)
            				case _ => recurs2(xs)
          				  }
        }
      }
      println(recurs2(List("now", 1, "is", 2)))

[Hugh Angle]

Your code help to clear up the problem I was having:

  def recurs2(a:List[Any]);List[String]={
        a match {
          case Nil => Nil
          case x :: xs => x match {
                            case s:String => s :: recurs2(xs)
                            case _ => recurs2(xs)
                          }
        }
      }

The problem I was having was in the difference between
the two sets of codes. Why did the error occur in one
and not the other?

val any=List[Ang]("now", 1, "is", 2)
        for(a <-any)
                a match {case s:String=>...

        def recurs(a:List[Any]):List[Any]={
                a match {case s:String=>...

I have to believe that the comprehension made the
difference. In you code example, the expression:

case x :: xs => x match {...

was probably doing what the comprehension was
accomplishing.

I hope I am on the right track



-- INSERT --
1,15 Top

[Raymond Tong]

Hugh Angle wrote:
The problem I was having was in the difference between
the two sets of codes. Why did the error occur in one
and not the other?

Check again the beginning part of my previous post. (comment in code)
The problem due to List[Any] can't match to a String.

[Garrett Rowe]

An alternate way to do what you're attempting:

scala> val as = List[Any]("now", 1, "is", 2)
as: List[Any] = List(now, 1, is, 2)

scala> as collect { case x: String => x }
res0: List[String] = List(now, is)

A side benefit of doing it this way, besides being idiomatic, is that the resulting collection is correctly typed as a List[String]

[Luigi Plinge]

Garrett's way is definitely the best, but in answer to the original question:

You get the error because you're trying to get the head of an empty List. You can tackle this firstly by explicitly checking for an empty List, viz:

def recurs(a: List[Any]): List[Any] = {
  if (a.isEmpty) Nil
  else a.head match {
    case Nil => Nil
    case s: String => s :: recurs(a.tail)
    case _ => recurs(a.tail)
  }
}

or, more idiomatically, matching on the list itself:

def recurs(a: List[Any]): List[String] = {
  a match {
    case Nil => Nil
    case (s: String) :: xs => s :: recurs(xs)
    case _ => recurs(a.tail)
  }
}

Notice I've put the return type as List[String]. You could leave it as List[Any], but why not make it a List of Strings since you can.

Contrary to what Raymond Tong says, there is no problem in matching a String by type in a List[Any]. This is the point of matching by type.

BTW I highly recommend 99 Scala Problems for practice with this kind of construct.