Question: Lets say i have a variable

```
val allF = (Some(1), "some string", 2.99, "another string", 1, Some(30))

```

Now i want to declare a few more variables of type same as `allF` i.e. `(Some[Int], String, Double, String, Int, Some[Int])`. I can do

```
var a1: (Some[Int], String, Double, String, Int, Some[Int]) = _
var a2: (Some[Int], String, Double, String, Int, Some[Int]) = _
... and so on

```

or i can do

```
type T = (Some[Int], String, Double, String, Int, Some[Int])
var a1: T = _
var a2: T = _
.. and do on

```

Is there some way i can use the variable `allF` to get its type and declare variables `a1`, `a2`, `a3`, ... like this

```
val allF = (Some(1), "some string", 2.99, "another string", 1, Some(30))
var a1: typeof(allF) = _
var a2: typeof(allF) = _
...

```

**UPDATE -**
Also for situations like this

```
val allF = (Some(1), "some string", 2.99, "another string", 1, Some(30))
 xyz match {
   case y: (???)\\ if y is of the same type as allF
}

```

Answer: 
It depends on what you mean.

If you literally want to declare all of the variables in the same scope, as per your example, you can do that:

```
  var a, b, c = (5,4,3,2,1) // All have the same type and value

```

But if you are saying that you want to create a variable which has the same type as a variable whose type you don't know at compile time (maybe an `AnyRef` passed as a parameter), then you are subject to the same restrictions as in Java (or any other statically-typed language). You can create the variable via reflection, but you can only act on it as an object.
You can definitely proceed in the second manner you proposed. To address your update on case matching you can do something as such:

```
  object MyTypes {
    type F = (Some[Int], String, Double, String, Int, Some[Int])
    type G = (Some[Int], Long, Double, Long, Int, Some[Int])

  }
  val allF: MyTypes.F  = (Some(1), "some string", 2.99, "another string", 1, Some(30))
  val allG: MyTypes.G = (Some(1), 101, 2.99, 9999999, 1, Some(30))

  import scala.reflect.runtime.universe._ //This allows typeOf[] and etc
  val tuple = allF
  typeOf[tuple.type] match {
    case fType if fType =:= typeOf[MyTypes.F] => "do something 1"
    case gType if gType =:= typeOf[MyTypes.G] => "do something 2"
  }

```

That or you just do something more standard and not quite as advanced in the type system:

```
  val allF = (Some(1), "some string", 2.99, "another string", 1, Some(30))
  val allG = (Some(1), 101, 2.99, 9999999, 1, Some(30))

  val tuple: (_, _, _, _, _, _) = allF
  tuple match {
    case (x1: Some[Int], x2: String, x3: Double, x4: String, x5: Int, x6: Some[Int]) => "do something 1"
    case (x1: Some[Int], x2: Long, x3: Double, x4: Long, x5: Int, x6: Some[Int]) => "do something 2"
    case _ => "Handle not found"
  }

```