Swift - insert into array of characters, functional solution - arrays

Question

I'm trying to write a function that will take as its argument an array of characters (call it a word) and a single character, and return an array of "words" with the character inserted at all positions:
Example
typealias Word = [Character]
func insert(letter: Character, into word: Word) -> [Word] {
}
So calling:
insert("c", into: ["a", "b"])
will return:
[["c", "a", "b"], ["a", "c", "b"], ["a", "b", "c"]]
The simplest I've come up with so far is:
func insert(letter: Character, into word: Word) -> [Word] {
return Array<Int>(0...word.count).map() {
var newWord = word
newWord.insert(letter, atIndex: $0)
return newWord
}
}
from which I got the generic version:
extension Array
{
func insert(element: T) -> [[T]] {
return (0...self.count).map() {
var newArray = self
newArray.insert(element, atIndex: $0)
return newArray
}
}
}
However, this involves making a mutable copy of the input word. It there a better / more elegant / simpler (functional) way to achieve this?

Answer 1

I would move the "non-mutating array insert" to a separate method:
extension Array
{
func arrayByInserting(element: T, atIndex: Int) -> [T] {
var result = self
result.insert(element, atIndex: atIndex)
return result
}
func insert(element: T) -> [[T]] {
return (0 ... self.count).map() { self.arrayByInserting(element, atIndex: $0) }
}
}
Then your question (as I understand it) if there is a better way for the
the arrayByInserting method. Actually your method looks fine to me. You need
to return a new array, so you can just as well start with a copy of self.
It could be written slightly shorter using slices:
func arrayByInserting(element: T, atIndex: Int) -> [T] {
return self[0 ..< atIndex] + [element] + self[atIndex ..< self.count]
}
However, a quick test showed that this method is about 10 times slower than your method.

Answer 2

You can find very interesting functional examples in Swift here:
objc.io Functional Snippets
The "permutations" snippets is what you're looking for.
Here a simplified example for you. But I strongly recommend the objc.io snippets.
The Array Extension:
extension Array {
var decompose : (head: T, tail: [T])? {
return (count > 0) ? (self[0], Array(self[1..<count])) : nil
}
}
And here the generic function:
func between<T>(x: T, ys: [T]) -> [[T]] {
if let (head, tail) = ys.decompose {
return [[x] + ys] + between(x, tail).map { [head] + $0 }
} else {
return [[x]]
}
}
This should solve your problem:
let char: Character = "c"
let charArray = ["a", "b"] as [Character]
let r = between(char, charArray)