7

What techniques can I use in Scala to deal with long type parameter lists?

I am working on a little framework for running various types of games with different simulated environments. I am trying to keep certain parts of the framework relatively generic, so I am introducing various types as type parameters, such as the state of the environment, the game result, etc.

It all works quite well functionally and I do get the desired benefits of a type-safe yet generic framework. But the type signatures have grown to the point where it makes the code rather hard to read and refactoring it has become quite cumbersome. The signature of the top-level Simulator has eight type parameters and many of the primary types have three to five. Individual compiler type errors, since they list out the types of class or function parameters (which of course are also type-parameterized) seem to regularly run to a hundred lines.

Occasionally, but very rarely, I can omit the type parameters, e.g. on constructors. But in most cases at least one of the types wont be inferred so I end up having to insert the entire type signature.

Obviously this is not ideal and I am looking for ways to solve this problem. Any advice would be appreciated!

Improve this question
2
  • 6
    Few lines of sample code are always appreciated ;) Commented Feb 12, 2012 at 7:19
  • It is a very general problem. I am not sure sample code would add a lot of value. It's just the usual things: traits, classes, functions, each with type parameters, and fields/members also with type parameters. Commented Feb 12, 2012 at 8:53

2 Answers 2

Reset to default
10

Two solutions come to mind.

  1. Use type aliases. 

    scala> class Foo[A, B, C, D, E]
defined class Foo

scala> type Bar[A] = Foo[A, Int, Int, Int, Float]
defined type alias Bar

scala> new Bar[String]
res23: Foo[String,Int,Int,Int,Float] = Foo@f590c6

  2. Use abstract type members instead of type parameters.

    scala> class Bar {
     |   type A
     |   type B <: AnyVal
     |   type C
     | }
defined class Bar

scala> new Bar {
     |   type A = String
     |   type B = Int
     |   type C = Int
     | }
res24: Bar{type A = String; type B = Int; type C = Int} = $anon$1@ee1793

scala> trait Baz {
     |   type A = String
     | }
defined trait Baz

scala> new Bar with Baz {
     |   type B = Int
     |   type C = String
     | }
res25: Bar with Baz{type B = Int; type C = String} = $anon$1@177c306

scala> null.asInstanceOf[res25.A]
res26: res25.A = null

scala> implicitly[res25.A =:= String]
res27: =:=[res25.A,String] = <function1>

You might want to share some code with us so that we can give some more specific advice.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

The first answer I already use; it would be even nicer if somehow you could then use the defined type alias to access the underlying type's constructor.. The second one is interesting; I will explore this.
7

Consider the case when you have a group of type parameters that are closely related; you pass them together as type arguments. In this example, this group is A and B.

trait X[A, B, C] {
  new Y[A, B, Int] {}
}

trait Y[A, B, D] {
  def a: A = sys.error("")
}

You can package these two types into a single type parameter with a type alias containing type members:

type AB = { type A; type B }
trait Y[ab <: AB, D] {
  def a: ab#A = sys.error("")
}
trait X[ab <: AB, C] {
  new Y[ab, C] {}
}
new X[{ type A=Int; type B=Int}, String] {}
Improve this answer

8 Comments

Oooh, that is neat! I will try that out asap!
You also retain the ability to use variance with this approach.
How do I specify variance? In your example, e.g. if Y was originally trait Y[+A,-B]?
Thank you. This is really extremely valuable. Using this approach, I was able to shed about 15-20% overall code size and made the code more easily refactorable. The compiler now crashes a lot but at least that's fixable. ;-) Where can I read more about this kind of type-level coding? I could not find anything on it in the Odersky/Spoon/Venners book.
Hmmm, not sure if you can make A covariant and B contravariant; I was only thinking of the case when all related type parameters have the same variance. Then, trait Y[+ab <: AB, D].
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.