Type-check by array size?

I'm working on building a library for (effectively) permutations; the goal is to allow you to specify and compose permutations on n elements. So, for example, I'd like to be able to do something like the following:

let p1 = Permutation([4,3,2,1])
let p2 = Permutation([1,3,2,4])
p1 * p2 // -> Permutation([4,2,3,1])

In general, it only makes sense to compose permutations of the same size. So for example:

let p3 = Permutation([1,2,3])
p1 * p3 // Error

Obviously I can check the sizes when I do the composition and either throw an exception or return nil; but both of these options involve more boilerplate (either marking every composition with try or unpacking every result). Because it never makes sense to compose permutations of different lengths, I'd prefer to have a compile-time error — in essence, I want permutations of different lengths to be of different types.

I'm ok with having to specify a finite number of types — my ultimate use case probably only cares about a finite range of sizes. However, there will eventually be other types that I might want to compose with permutations (e.g. permutation sequences or semantically-typed subsets of permutations) for which the same restriction will apply — so I'd prefer the type-checking be done in some generic way.

(If it helps, essentially what I'm looking for is a way to approximate Julia's NTuple types, which are parameterized by the number of elements.)

What I've tried

My best attempt so far involves dummy length "types" (i.e. a separate uninstantiable type for each length):

protocol LengthProtocol { }
enum Three: LengthProtocol { }
enum Four: LengthProtocol { }

struct Permutation<Length: LengthProtocol> {
  // ...

  static func *<S: LengthProtocol>(lhs: Permutation<S>, rhs: Permutation<S>) -> Permutation<S> {
    // ...
  }
}

However, type inference seems to fail, here:

let p1 = Permutation<Three>([1,2,3])
let p2 = Permutation<Three>([1,3,2])
p1 * p2 // ERROR: Cannot infer generic paramter S

The operator should not be generic. It should use the existing Length type parameter, as declared in the struct.

static func *(lhs: Permutation<Length>, rhs: Permutation<Length>) -> Permutation<Length> {
    ...
}

The generic parameter S is only required, if you declare the operator outside of Permutation.

Also, I'd not allow public code to initialise Permutation with an array. Instead, expose initialisers with specific numbers of parameters, and constrain Length on each initialiser.

private init(_ array: [Int]) {
    // ...
}

init(_ a: Int, _ b: Int, _ c: Int, _ d: Int) where Length == Four {
    self.init([a, b, c, d])
}

init(_ a: Int, _ b: Int, _ c: Int) where Length == Three {
    self.init([a, b, c])
}