Vfrdtyky

I can create an iterator to create prefixes:

extension Array where Element == Int {

  func prefixesInt() -> AnyIterator<[Element]> {

    var length = 0

    return AnyIterator {

      guard length < self.count else { return nil }

      length += 1

      return Array(self.prefix(length))

    }

  }

}



for prefix in [1,10,5].prefixesInt() {

  print(prefix)  // Prints: [1]  then  [1, 10]  then [1, 10, 5]

}

Now I want to achieve the same with other types by:

1) Encoding the types to Ints

2) Using the same prefix function

3) Decoding back to the original type

[I know there might be other ways to achieve this but I want to follow this line for various reasons and also wanting to understand more.]

So I need:

extension Array where Element: Equatable {

  func encode() -> [Int] {

    return map { self.firstIndex(of: $0)! }

  }

}

print(["A", "B", "A", "C"].encode())  // Prints: [0, 1, 0, 3]



extension Array where Element == Int {

  func decode<Output>(_ original: [Output]) -> [Output] {

    return map { original[$0] }

  }

}

print([2,3,0].decode(["P", "Q", "R", "S"]))  // Prints: ["R", "S", "P"]

I can now do what I want with:

extension Array where Element: Equatable {

  func prefixes() -> LazyMapSequence<AnyIterator<[Int]>, [Element]> {

    return encode().prefixesInt().lazy.map { $0.decode(self) }

  }

}



for prefix in ["H","A","T"].prefixes() {

  print(prefix)

}

I now want to go a step further by making the transform (in this case prefixes) into a parameter and my attempt is:

extension Array where Element: Equatable {

  func encodeTransformDecode(transform: ([Int]) -> AnyIterator<[Int]> ) -> LazyMapSequence<AnyIterator<[Int]>, [Element]> {

    return transform(encode()).lazy.map { $0.decode(self) }

  }

}

which compiles fine but when I try:

extension Array where Element: Equatable {

  func prefixes2() -> LazyMapSequence<AnyIterator<[Element]>, [Element]> {

    return encodeTransformDecode(transform: prefixesInt) //ERROR: 'Array<Element>' is not convertible to 'Array<Int>'

  }

}



for prefix in ["A","B","C"].prefixes2() {

  print(prefix)

}

Then I get the error indicated

I'm stuck. Any help appreciated.

Whole code:

print("========== prefixesInt")

extension Array where Element == Int {

  func prefixesInt() -> AnyIterator<[Element]> {

    var length = 0

    return AnyIterator {

      guard length < self.count else { return nil }

      length += 1

      return Array(self.prefix(length))

    }

  }

}



for prefix in [1,10,5].prefixesInt() {

  print(prefix)  // Prints: [1]  then  [1, 10]  then [1, 10, 5]

}



print("============ encode")

extension Array where Element: Equatable {

  func encode() -> [Int] {

    return map { self.firstIndex(of: $0)! }

  }

}

print(["A", "B", "A", "C"].encode())  // Prints: [0, 1, 0, 3]



print("============ decode")

extension Array where Element == Int {

  func decode<Output>(_ original: [Output]) -> [Output] {

    return map { original[$0] }

  }

}

print([2,3,0].decode(["P", "Q", "R", "S"]))  // Prints: ["R", "S", "P"]



print("============ prefixes")

extension Array where Element: Equatable {

  func prefixes() -> LazyMapSequence<AnyIterator<[Int]>, [Element]> {

    return encode().prefixesInt().lazy.map { $0.decode(self) }

  }

}



for prefix in ["H","A","T"].prefixes() {

  print(prefix)

}



extension Array where Element: Equatable {

  func encodeTransformDecode(transform: ([Int]) -> AnyIterator<[Int]> ) -> LazyMapSequence<AnyIterator<[Int]>, [Element]> {

    return transform(encode()).lazy.map { $0.decode(self) }

  }

}



print("============ prefixes2")

extension Array where Element: Equatable {

  func prefixes2() -> LazyMapSequence<AnyIterator<[Element]>, [Element]> {

    return encodeTransformDecode(transform: prefixesInt)

  }

}



for prefix in ["A","B","C"].prefixes2() {

  print(prefix)

}

As indicated in my comment and you've explored in your own answer, the core problem in your code is that you had the type of prefixesInt incorrect. An instance method has a type of the form:

(<object type>) -> (<argument types>) -> <return type>

the value passed for <object type> is what is bound to self in the function. So the type prefixesInt is:

([Int]) -> () -> AnyIterator<[Int]>

To fix your code you only need to change prefixes2:

func prefixes2() -> LazyMapSequence<AnyIterator<[Int]>, [Element]>

{

   return encodeTransformDecode(transform: { $0.prefixesInt() } )

}

The type has changed to include AnyIterator<[Int]> rather than AnyIterator<[Element]> and a closure { $0.prefixesInt() } is passed rather than just prefixesInt (The former takes the array as argument while the compiler passes the latter, which is a shorthand for self.prefixesInt, as a closure with the current value of self pre-bound – that self being the Array<Equatable> prefixes2 was called on).

HTH

To see the connection with the code you produced consider that:

<value>.method(<args>)

is just a shorthand for:

<type of value>.method(<value>)(<args>)

Which in this case means that:

$0.prefixesInt()

is a shorthand for:

Array<Int>.prefixesInt($0)()

which is what you produced but distributed between prefixes() (Array<Int>.prefixesInt) and encodeTransformDecode (transform(encode())()). By using the shorthand and passing the closure no changes to encodeTransformDecode are required.

With the help of useful nudges from @Carpsen90 and @CRD (thanks both!) and some dipping into the excellent book "obj Functional Swift" (No personal connection) I worked out a solution.

The type of an instance method is different from a static method as shown by:

extension Int {

  static func doubleStatic(_ x: Int) -> Int { return x * 2 }

  func doubleInstance() -> Int { return self * 2 }

}

print( type(of: Int.doubleStatic) )    // Prints: (Int) -> Int

print( type(of: Int.doubleInstance) )  // Prints: (Int) -> () -> Int

In the question the type of prefixesInt is in fact: (Array<Int>) -> () -> AnyIterator<[Int]>.

With this in mind we can rewrite encodeTransformDecode as follows:

extension Array where Element: Equatable {

  func encodeTransformDecode(transform: (Array<Int>) -> () -> AnyIterator<[Int]> ) -> LazyMapSequence<AnyIterator<[Int]>, [Element]> {

    return transform(encode())().lazy.map { $0.decode(self) }

  }

}

Secondly we need to tell the Compiler a bit more about the type of prefixesInt when we use it in prefixes2 so:

extension Array where Element: Equatable {

  func prefixes2() -> LazyMapSequence<AnyIterator<[Int]>, [Element]> {

    return encodeTransformDecode(transform: Array<Int>.prefixesInt)

  }

}

and now as required:

for prefix in ["A","B","C"].prefixes2() {

  print(prefix)

}

gives us:

["A"]

["A", "B"]

["A", "B", "C"]

and now very easily we can extend with other function very succinctly:

extension Array where Element == Int {

  func suffixesInt() -> AnyIterator<[Element]> {

    var length = 0

    return AnyIterator {

      guard length < self.count else { return nil }

      length += 1

      return Array(self.suffix(length))

    }

  }

}



extension Array where Element: Equatable {

  func suffixes2() -> LazyMapSequence<AnyIterator<[Int]>, [Element]> {

    return encodeTransformDecode(transform: Array<Int>.suffixesInt)

  }

}



for suffix in ["A","B","C"].suffixes2() {

  print(suffix)

}