Fixed-length Sequences in Swift 2.2
The Vector type is not related to graphics, so importing
CoreGraphics seems "unnatural" here. If you replace CGFloat
by Float or Double 

extension DigitType {
    static func value(place place: Int) -&gt; Int {
        return count * Int(pow(10, Double(place)))
    }
}


then it suffices to import Foundation (or Swift + Darwin).

But I would get rid of the floating point conversion and implement it as (taking the hundreds as an example): 

enum ___&lt;H: DigitType, T: DigitType, U: DigitType&gt; : CountType {
    static var count: Int {
        return H.count * 100 + T.count * 10  + U.count
    }
}


This is simple and straightforward, and easy to read. This makes the
value(place place:) with its floating point conversion, and the
the math library call to the pow() function obsolete.

As a consequence, the entire code compiles with a pure

import Swift


without additional imports.



(This is my major point.) The boxing of the array elements into
a class seems problematic to me.

First, struct Vector is a value type, but its elements are
mutable even for a constant:

let vecA = Vector&lt;_3, Int&gt;(0)
vecA[0].value = 111 // This should not compile!


Second, copying a vector copies references to the elements,
which is not to be expected for a value type:

let vecA = Vector&lt;_3, Int&gt;(0)
vecA[0].value = 111

let vecB = vecA
vecB[0].value = 222

print(vecA[0].value) // Output: 222. Expected output: 111.


Here, modifying the elements of vecB modifies the elements of
vecA as well.

I would simply omit the boxing and store the elements just as an
array. Modifying the elements is then done via a subscript setter:

struct Vector&lt;Dimension: CountType, Element&gt; {

    private var array: [Element]

    init(_ repeatedValue: Element) {
        array = [Element](count: Dimension.count, repeatedValue: repeatedValue)
    }

    var elements: [Element] {
        return array
    }

    subscript(index: Int) -&gt; Element {
        get {
            return array[index]
        }
        set(newValue) {
            array[index] = newValue
        }
    }

    func generate() -&gt; Array&lt;Element&gt;.Generator {
        return array.generate()
    }
}


Using a private var array for the element storage and a 
computed elements property still makes sense for encapsulation.

Now Vector behaves like a proper value type:

var vecA = Vector&lt;_3, Int&gt;(0)
vecA[0] = 111

var vecB = vecA
vecB[0] = 222

print(vecA[0]) // Output: 111




By adopting the CustomStringConvertible protocol, 

extension Vector : CustomStringConvertible {
    var description: String {
        return "&lt;" + (array.map { String($0) }).joinWithSeparator(", ") + "&gt;"
    }
}


printing a vector produces nicer output (the angle brackets are just
an example to disambiguate the output from an array):

print(vecA)
// Output: &lt;111, 0, 0&gt;
// instead of Vector&lt;_3, Int&gt;(array: [111, 0, 0])




To create (constant) vectors, an init method taking a "index to
element mapping" might be useful:

extension Vector {
    init(elementForIndex: Int -&gt; Element) {
        array = (0 ..&lt; Dimension.count).map(elementForIndex)
    }
}


Example:

let vecC = Vector&lt;_5, Int&gt;(elementForIndex: { 2 * $0 })
print(vecC) // &lt;0, 2, 4, 6, 8&gt;


This would also come in handy when you start to define operations
on the vector type, e.g. an addition of integer vectors:

func + &lt;Dimension, Element: IntegerArithmeticType&gt;
    (lhs: Vector&lt;Dimension, Element&gt;, rhs: Vector&lt;Dimension, Element&gt;)
    -&gt; Vector&lt;Dimension, Element&gt; {
        return Vector(elementForIndex: { lhs[$0] + rhs[$0]})
}




Initialization from an array or array literal might also be
convenient:

extension Vector {
    init(elements: [Element]) {
        precondition(elements.count == Dimension.count)
        array = elements
    }
}

extension Vector: ArrayLiteralConvertible {
    init(arrayLiteral elements: Element...) {
        self.init(elements: elements)
    }
}


Example:

let vecD: Vector&lt;_5, Double&gt; = [ 1.0, 2.0, 3.0, 4.0, 5.0 ]
print(vecD) // &lt;1.0, 2.0, 3.0, 4.0, 5.0&gt;


The disadvantage here is that the compiler cannot check the
dimension.