Scala: Option, Some and the ArrowAssoc operator - scala

Question

I am trying to analyze the following piece of Scala code:
import java.nio.file._
import scala.Some
abstract class MyCustomDirectoryIterator[T](path:Path,someNumber:Int, anotherNum:Int) extends Iterator[T] {
def getCustomIterator(myPath:Path):Option[(DirectoryStream[Path],
Iterator[Path])] = try {
//we get the directory stream
val str = Files.newDirectoryStream(myPath)
//then we get the iterator out of the stream
val iter = str.iterator()
Some((str -> iter))
} catch {
case de:DirectoryIteratorException =>
printstacktrace(de.getMessage)
None
}
How do I interpert this piece of code: Some((str -> iter))
Yes, it is returning a value of type:
Option[(DirectoryStream[Path], Iterator[Path])]
The -> operator is, to the best of my understanding, ArrowAssoc from the scala.Predef package.
implicit final class ArrowAssoc[A] extends AnyVal
But I still do not understand what the -> thing is doing to give me a return value of type:
Option[(DirectoryStream[Path], Iterator[Path])]
Can the Scala experts out here throw more light on this? Is there any way to write the "Some(..)" thing in a more readable way? I do understand the role played by Some, though.

Answer 1

The -> operator just creates a tuple:
scala> 1 -> "one"
res0: (Int, String) = (1,one)
which is equivalent to
scala> (1, "one")
res1: (Int, String) = (1,one)
I was just going to add the source code, but Reactormonk has got there first ;-)
The -> method is made available on any object via the implicit ArrowAssoc class. Calling it on an object of type A, passing a parameter of type B, creates a Tuple2[A, B].

Answer 2

The usual case for the -> operator is
Map(1 -> "foo", 2 -> "bar")
which is the same as
Map((1, "foo"), (2, "bar"))
Which works because the signature for Map.apply is
def apply[A, B](elems: Tuple2[A, B]*): Map[A, B]
which means it takes tuples as arguments and constructs a Map from
it.
So
(1 -> "foo")
is equivalent to
(1, "foo")
From the compiler sources:
implicit final class ArrowAssoc[A](private val self: A) extends AnyVal {
#inline def -> [B](y: B): Tuple2[A, B] = Tuple2(self, y)
def →[B](y: B): Tuple2[A, B] = ->(y)
}
which tells you directly it's creating a tuple. And that 1 → "foo" works as well.