Q:

Generic T.Type for a parameter not even used and comma separated constraints

Three questions about this code:
func register<T: UICollectionViewCell where T: ReusableView, T: NibLoadableView>(_: T.Type) {
    let bundle = NSBundle(forClass: T.self)
    let nib = UINib(nibName: T.nibName, bundle: bundle)

    registerNib(nib, forCellWithReuseIdentifier: T.defaultReuseIdentifier)
}

(_: T.Type). The block of code in this func doesn't even use this parameter. So why is T.Type even necessary and what the heck does it do to add .Type to the generic?
This line T: UICollectionViewCell where T: ReusableView, T: NibLoadableView, does it mean that:
(a) T is constrained to type UICollectionViewCell that conforms to the protocols ReusableView and NibLoadableView? 
(b) Or does it mean that it conforms to ReusableView or NibLoadableView?
The third question arises from the above example but its not directly related. I can appreciate a generic that is constrained to specific types; but when a generic is constrained to one type, I don't see the difference between that and just a normal type declaration for an input variable. See code below

What's the difference between this:
func register<T: UICollectionViewCell>(whatever: T) {
  // whatever
}

and this:
func register(whatever: UICollectionViewCell) {
  // whatever
}

Don't both of the above declarations claim that register only expects a type constrained to UICollectionViewCell? How or in what case do they differ?

(Context the example code was extracted from: https://gist.github.com/gonzalezreal/92507b53d2b1e267d49a)

A:

It means that the parameter is a metatype. The parameter is given a type, (a metatype), rather than an instance of that type. Here's an example:
func f<T>(_: T.Type) {
    print(T.self) //Prints "String"
}

f(String.self) // A metatype, not an instance of String

It means and.
On its own like that, there's not much of a difference. The first example is using generics, and the second example is using polymorphism. Here's an example in which they differ:
protocol Repairable {
    var broken: Bool { get set}
}

class Vehicle: Repairable {
    var broken = true
}

class CheapRepairableTrinket: Repairable {
    var broken = true
}

func repair<T: Repairable>(_ object: T) -> T {
    var object = object
    object.broken = false

    // The return type *must* be the same as the type of the parameter
    return object
}

func scamRepair(_ object: Repairable) -> Repairable {
    // the parameter type and the return type can be any Repairable
    // type, but there's no enforced relationship between them
    return CheapRepairableTrinket()
}

// I gave them a car to fix, and they gave me back some other crap!
print(type(of: scamRepair(Vehicle())))

