Styjun

I would like to express a Swift protocol similar to the following two snippets which both fail to compile.

Attempt 1:

protocol AbstractFunction 
 associatedtype Domain
 associatedtype Codomain

 func apply(_ x: Domain) -> Codomain

 static var identity: Self where Domain == Codomain get 

Attempt 2:

protocol AbstractFunction 
 associatedtype Domain
 associatedtype Codomain

 func apply(_ x: Domain) -> Codomain

 static func identity() -> Self where Domain == Codomain get 

The first is not even valid within the Swift grammar while the second fails with
'where' clause cannot be attached to a non-generic declaration.

Both of these examples try to express a protocol which describes functions which are not instances of an actual function type (A) -> B. If one has types Vector2 and Vector3, one could imagine creating types Matrix2x2, Matrix2x3, and Matrix3x3 and conforming them to the AbstractFunction protocol. The domain of MatrixNxM would be VectorM and the codomain would be VectorN. Square matrices have an identity matrix, but the concept of an identity matrix (or really identity function) does not make sense when the domain and codomain differ.

Consequently, I would like the protocol AbstractFunction to require conforming types to provide an identity, but only in the case where Domain == Codomain. Is this possible?

You can achieve it by declaring second more strict protocol as:

protocol AbstractFunction 
 associatedtype Domain
 associatedtype Codomain

 func apply(_ x: Domain) -> Codomain


protocol AbstractEndofunction: AbstractFunction where Codomain == Domain 
 static var identity: Self get 

Example on Int -> Int function:

final class IntFunction: AbstractEndofunction 
 typealias Domain = Int

 static var identity = IntFunction $0 

 private let function: (Int) -> Int

 init(_ function: @escaping (Int) -> Int) 
 self.function = function
 

 func apply(_ x: Int) -> Int 
 return function(x)
 

I don't think you can do that. However, I can see two another ways that might help you out.

By using optional type to identity you indicate that a certain type that implements AbstractFunction may or may not have an identity. For instance:

final class ConcreteFunctionWithoutIdentity: AbstractFunction 
 typealias Domain = Int
 typealias Codomain = Int

 func apply(_ x: Int) -> Int 
 return 0
 

 static var identity: ConcreteFunctionWithoutIdentity?


// Using
if let identity = ConcreteFunctionWithoutIdentity.identity else 
 // It will not fall here, since ConcreteFunctionWithoutIdentity doesn't have identity
 ...


final class ConcreteFunctionWithIdentity: AbstractFunction 
 typealias Domain = Int
 typealias Codomain = Int

 func apply(_ x: Int) -> Int 
 return 0
 

 static var identity: ConcreteFunctionWithtIdentity? 
 // return something
 


if let identity = ConcreteFunctionWithtIdentity.identity else 
 // It will fall here, since ConcreteFunctionWithIdentity indeed have identity
 ...