How can one construct an object from a type alias in scala?
type MyType = List[Int]
println(List[Int]())
println(MyType()) // error: not found: value MyType
This is problematic in a function that must return a new instance of that type. Basic Example:
def foo(x: MyType): MyType = {
if (x.head == 0) MyType() // Should Nil be used?
else if (x.head == -1) new MyType(1,2,3,4)
else x
}
How can foo become unaware of the actual type of MyType?
Scala (like Java) has different namespaces for types and values, and a type alias only introduces the alias into the type namespace. In some cases you can pair the alias with a val referring to the companion object to get the effect you're looking for:
scala> case class Foo(i: Int)
defined class Foo
scala> type MyType = Foo
defined type alias MyType
scala> val MyType = Foo
MyType: Foo.type = Foo
scala> MyType(1)
res0: Foo = Foo(1)
This won't work with List[Int], though, since while both the List type and the List companion object's apply method have a type parameter, the List companion object itself doesn't.
Your best bet is to use something like Nil: MyType, but you'll find that in general using type aliases like this (i.e. just as a kind of abbreviation) often isn't the best solution.
It looks to me you're trying to achieve something with the wrong set of tools. But in any case there is no way to instantiate a type alias.
Is your goal to make the function work on a set of different collection types as opposed to only Lists? In that case you need more than just nominal decoupling; currently the function still relies on the method signatures of List.
You can decouple your function from the interface of List by using type classes, but you'll have to wrap every method call you'll ever want to make in MyOps:
import scala.language.higherKinds
import scala.reflect.ClassTag
trait MyOps[L[_], T] {
def head(xs: L[T]): T
def tail(xs: L[T]): L[T]
def fromList(xs: List[T])(implicit ev: ClassTag[T]): L[T]
}
implicit def listMyOps[T] = new MyOps[List, T] {
def head(xs: List[T]) = xs.head
def tail(xs: List[T]) = xs.tail
def fromList(xs: List[T])(implicit ev: ClassTag[T]) = xs
}
implicit def arrayMyOps[T] = new MyOps[Array, T] {
def head(xs: Array[T]) = xs(0)
def tail(xs: Array[T]) = xs.slice(1, xs.size)
def fromList(xs: List[T])(implicit ev: ClassTag[T]) = xs.toArray
}
def foo[L[_]](xs: L[Int])(implicit ev: MyOps[L, Int]) = {
ev.fromList(xs = if (ev.head(xs) == -1) List(1, 2, 3) else Nil)
}
println(foo(List(0, 1, 2, 6)))
println(foo(Array(-1, 6, 8)))
outputs:
List()
[I@54b63af0
— the first foo call takes a List and returns a List; the 2nd one Array and Array respectively.
A type is just a type, not any information about how to create instances of that.
You would have to provide it with a function that constructs an instance of the alias.
So for example
def foo(x: MyType)(create: List[Int] => MyType) =
if (x.head == 0) create(Nil) // Should Nil be used?
else if (x.head == -1) create(List(1,2,3,4))
else x
But as Erik says, it sounds like you are doing something a bit backwards.
In the world of Scala Collections for every collection type there exists a companion object that helps make it easier to construct instances of the collection.
For simplicity consider this class and object of the same name:
object Numeric {
def apply(s: String): Numeric = new Numeric(s.toDouble)
}
case class Numeric(v: Double)
If you only had the case class then writing Numeric("5.1") would be erroneous. With the object you can actually now call Numeric.apply("5.1") or (because apply is a special method) you can simply write Numeric("5.1"). object in Scala is analogous to holding all static methods that you would write in Java.
Back to your example, MyType is only the type alias to List[Int] and does not bring the List companion object into scope with the name MyType. Your example is the equivalent of my Numeric example without the companion object.
Thus, my answer, is to create a simple and generic way to construct your companion object that hides the fact that 1) MyType is an alias and 2) that it restricts the collection type to Int. If you have lots of type aliases like this one in your code then you'll probably want the more generic version here:
import scala.collection.GenTraversable
import scala.collection.generic.GenericCompanion
class TypeCompanion[CC[X] <: GenTraversable[X], T](companion: GenericCompanion[CC]) {
type InnerType = CC[T]
def apply(elems: T*): InnerType = companion.apply(elems: _*)
def empty(): InnerType = companion.empty[T]
}
object MyType extends TypeCompanion[List, Int](List)
type MyType = MyType.InnerType
If you want to reduce the number of times that you write List, and will not mind the extra typing if you need to change from Int to some other type, then you may prefer this variation:
class TypeCompanion[CC[X] <: GenTraversable[X]](companion: GenericCompanion[CC]) {
type InnerType = CC[Int]
def apply(elems: Int*): InnerType = companion.apply(elems: _*)
...
}
object MyType extends TypeCompanion(List)
type MyType = MyType.InnerType
Both implementations give your foo method this implementation:
def foo(x: MyType): MyType = {
if (x.head == 0) MyType()
else if (x.head == -1) MyType(1,2,3,4)
else x
}
Note that the type restrictions on GenTraversable and GenericCompanion are just a clever way of restricting to companion objects that match scala collection's conventions.
