How to write this generic dotProduct function in Swift?

I don't believe there is any way to represent this in the current type system. Just thinking about the fixed-length issue alone, the only way to constrain types like this is to check for the equality or inequality of an associated type. So to emulate this currently requires a bunch of of dummy types to represent various lengths, that could be matched in a where clause, or similar.

protocol FixedLengthArray {
    typealias Length
}

struct FLA<T>: FixedLengthArray {
    typealias Length = T
}

struct Length1 { }
struct Length2 { }
struct Length3 { }
// …

func compatible<FLA0: FixedLengthArray, FLA1: FixedLengthArray where FLA0.Length == FLA1.Length>
               (fla0: FLA0, _ fla1: FLA1) { }

compatible(FLA<Length2>(), FLA<Length2>())

You would need generic types with integer parameters or similar to start implementing that part of your specification.

Thanks, I ended up with the same kind of representation, but I was thinking that maybe there was some other better way ...

I guess this (the lack of integer placeholders in Swift's generics) might be (part of) the reason for why Swift doesn't have anything like fixed length / static arrays?

AFAIK when importing a C struct that contains a static array of N bytes for example, the resulting stored property will be a tuple of N UInt8s, so if N is 10, it's type will be (UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8, UInt8), and when N is 1024 it will make a very long line.

I'd like to understand why we shouldn't be able to eg define a generic struct type with a stored property of some number of elements C of some type T, where C and T are generic placeholders. It seems like such a reasonable / useful / normal thing, yet it's impossible.

It would be like a heterogeneous tuple with subscript and (fixed) count. And I guess each (element type, count)-pair would make a different type, but they would all conform to a FixedLengthArrayType protocol (that has an Element typealias and a static/"constexpr" Count Int).

Also, as it actually is possible to implement this in current Swift (by brute force or using some preprocessor, treating each different count/length as special case), it seems like it should be possible to add some syntax to the language in order to support it.

Is there something in the philosophy of the language that prevents it and offers a better alternative?

Or perhaps fixed length arrays was something that had to be sacrificed in order to gain other (more important) advantages?

I would guess, and I think there was some discussion in the old developer forums that you could refer back to, that there's not a philosophical objection to some similar feature, but it just hasn't been a priority so far.

Ok, thanks, I revived the question about fixed-length arrays in the new forums here.

Here's a little prototype I whipped up in Swift 2; HTH:

/// Abstraction of numeric types that approximate real numbers
protocol ApproximateRealType {
  init() // zero
  func * (Self,Self) -> Self
  func + (Self,Self) -> Self
  func / (Self,Self) -> Self
  func - (Self,Self) -> Self
  prefix func + (Self) -> Self
  prefix func - (Self) -> Self
}


extension Double : ApproximateRealType {}
extension Float : ApproximateRealType {}


// Abstraction of a mathematical vector
protocol VectorType {
  typealias Scalar : ApproximateRealType
  func dotProduct(Self) -> Scalar

  // Parts not essential for answering the question
  init()
  var count: Int {get}
  subscript(Int) -> Scalar {get set}

  func + (Self,Self) -> Self
  func - (Self,Self) -> Self
  prefix func + (Self) -> Self
  prefix func - (Self) -> Self
  func * (Self, Scalar) -> Self
  func / (Self, Scalar) -> Self
}


struct EmptyVector<T: ApproximateRealType> : VectorType {
  init() {}
  typealias Scalar = T
  func dotProduct(other: EmptyVector) -> Scalar {
    return Scalar() // zero
  }
  var count: Int { return 0 }

  subscript(i: Int) -> Scalar {
    get { fatalError("subscript out-of-range") }
    set { fatalError("subscript out-of-range") }
  }
}


struct Vector<Tail: VectorType> : VectorType {
  typealias Scalar = Tail.Scalar

  init(_ scalar: Scalar, tail: Tail = Tail()) {
    self.scalar = scalar
    self.tail = tail
  }

  init() {
    self.scalar = Scalar()
    self.tail = Tail()
  }

  func dotProduct(other: Vector) -> Scalar {
    return scalar * other.scalar + tail.dotProduct(other.tail)
  }

  var count: Int { return tail.count + 1 }
  var scalar: Scalar
  var tail: Tail

  subscript(i: Int) -> Scalar {
    get { return i == 0 ? scalar : tail[i - 1] }
    set { if i == 0 { scalar = newValue } else { tail[i - 1] = newValue } }
  }
}


//===--- A nice operator for composing vectors ----------------------------===//
//===--- there's probably a more appropriate symbol -----------------------===//
infix operator ⋮ {
associativity right
precedence 1 // unsure of the best precedence here
}


func ⋮ <T: ApproximateRealType> (lhs: T, rhs: T) -> Vector<Vector<EmptyVector<T> > > {
  return Vector(lhs, tail: Vector(rhs))
}
func ⋮ <T: ApproximateRealType, U where U.Scalar == T> (lhs: T, rhs: Vector<U>) -> Vector<Vector<U> > {
  return Vector(lhs, tail: rhs)
}


extension Vector : CustomDebugStringConvertible {
  var debugDescription: String {
    if count == 1 {
      return "Vector(\(String(reflecting: scalar)), tail: EmptyVector())"
    }
    return "\(String(reflecting: scalar)) ⋮ " + (count == 2 ? String(reflecting: self[1]) : String(reflecting: tail))
  }
}


//===--- additive arithmetic ---------------------------------------------===//
func + <T> (EmptyVector<T>,EmptyVector<T>) -> EmptyVector<T> {
  return EmptyVector()
}
func - <T> (EmptyVector<T>,EmptyVector<T>) -> EmptyVector<T> {
  return EmptyVector()
}
prefix func + <T> (EmptyVector<T>) -> EmptyVector<T> {
  return EmptyVector()
}
prefix func - <T> (EmptyVector<T>) -> EmptyVector<T> {
  return EmptyVector()
}


func + <T> (lhs: Vector<T>, rhs: Vector<T>) -> Vector<T> {
  return Vector(lhs[0] + rhs[0], tail: lhs.tail + rhs.tail)
}
func - <T> (lhs: Vector<T>, rhs: Vector<T>) -> Vector<T> {
  return Vector(lhs[0] - rhs[0], tail: lhs.tail - rhs.tail)
}
prefix func + <T> (lhs: Vector<T>) -> Vector<T> {
  return lhs
}
prefix func - <T> (lhs: Vector<T>) -> Vector<T> {
  return Vector(-lhs[0], tail: -lhs.tail)
}


//===--- vector-scalar arithmetic -----------------------------------------===//
func * <V: VectorType> (lhs: V.Scalar, rhs: V) -> V {
  return rhs * lhs
}




func * <T> (EmptyVector<T>, T) -> EmptyVector<T> {
  return EmptyVector()
}


func / <T> (EmptyVector<T>, T) -> EmptyVector<T> {
  return EmptyVector()
}


func * <T> (lhs: Vector<T>, rhs: T.Scalar) -> Vector<T> {
  return Vector(lhs[0] * rhs, tail: lhs.tail * rhs)
}


func / <T> (lhs: Vector<T>, rhs: T.Scalar) -> Vector<T> {
  return Vector(lhs[0] / rhs, tail: lhs.tail / rhs)
}




//===--- CollectionType conformance ---------------------------------------===//
extension Vector : CollectionType {
  var startIndex: Int { return 0 }
  var endIndex: Int { return count }
}


//===--- Test -------------------------------------------------------------===//
print(Vector(3.0, tail: EmptyVector()))
print(3.0 ⋮ 4.0 ⋮ 5.0)
print( (3.0 ⋮ 4.0 ⋮ 5.0).dotProduct(6.0 ⋮ 7.0 ⋮ 8.0) ) // 86.0
print((3.0 ⋮ 4.0 ⋮ 5.0) + (6.0 ⋮ 7.0 ⋮ 8.0))
print(2 * (3.0 ⋮ 4.0 ⋮ 5.0))
print((3.0 ⋮ 4.0 ⋮ 5.0) / 2)

Wow, that is probably the most informative enlightening piece of Swift I've seen so far. I wish I had thought of that, ie this:

struct EmptyVector<T> : VectorType { … }
struct Vector<Tail: VectorType> : VectorType{ … }

Ah, of course. Great example.

Wow.

This took me ages to fully understand this code. In particular this statement had me confused for ages:

func ⋮ <T: ApproximateRealType> (lhs: T, rhs: T) -> Vector<Vector<EmptyVector<T> > > {
  return Vector(lhs, tail: Vector(rhs))
}

I couln't see how you could call Vector(rhs). When I typed it into the playground it returns the obvious error message:

Cannot find initializer for type 'Vector<Tail>' that accepts an argument of type '(Double)'

Of course what's actually happening is far more subtle. When using the function above to compose 2 ApproximateRealTypes, the return type of the function is giving the compiler all it needs to know to infer that the tail is an EmptyVector.