[swift-evolution] [Idea] Specialising based on function parameter values

[Karl]

I’ve had this idea floating around my head for a little while, and I’m not sure if it’s either really interesting or totally absurd.
Sorry if it’s not time for ideas like this yet. It’s not really a “proposal”, but it would be ABI-related I think.

So, the idea: The compiler can generate variations of functions where it statically substitutes a type for a placeholder name. Would it also be possible to statically generate a variation of a function if a parameter is a certain value?

I have some code which scans a sequence of bytes. The bytes may be in UTF-8, UTF-16 or UTF-32, and any endianness flavour thereof. Fortunately, the scanner is looking for a ASCII-compatible characters which have the same value (albeit a different size) in each encoding, so this can be implemented as a generic function based on the type of the CodeUnit (UInt8/16/32 respectively). Something roughly like this:

> @_specialize(UInt8)
> @_specialize(UInt16)
> @_specialize(UInt32)
> func scanCharacters<U:UnsignedInteger>(from bytes: [UInt8], hasMismatchedEndianness: Bool) -> ... {
> 
> 	var byteIterator = bytes.makeIterator()
> 	while let nextByte = byteIterator.next() {
> 
> 		var codeUnit : U
> 		// The compiler will statically optimise this branching away because generics.
> 		if size(of: U.self) == 1 { 
> 			codeUnit = numericCast(nextByte)
> 		}
> 		else {
> 			codeUnit = consumeCodeUnit(withInitialByte: nextByte, source: byteIterator)
> 			// Even when marking this _slowPath(), there is a significant overhead.
> 			if hasMismatchedEndianness {    
> 				codeUnit = codeUnit.byteSwapped
> 			}
> 		}
> 
> 		// Process the code-unit
> 	}
> }


However, we still have a problem with this endianness flag. All it requires is that after we consume an entire CodeUnit from the buffer, that we byte-swap it before checking its value. I don’t want to duplicate the entire function code to deal with this one variation in parameter value, but this is a very hot code-path and the branching overhead is significant.

So I would like to tell the compiler that we branch a lot on `hasMismatchedEndianness`, so it can generate and optimise variations of the function while keeping the abstraction level high and the maintenance burden low. There are lots of contexts where this could be useful - not just your typical Boolean switches, but Optionals, too. Even general value-types with specific values that are heavily branched against could benefit from these kinds of optimisations.


Thoughts? Would something like this be possible/valuable?