Is there a CollectionType function that transforms a collection to a dictionary?

Question

In Swift, is there a Collection function that, similar to map(), transforms a collection not into an array but into a dictionary?

An example that I would like to write:

let collection = [1, 2, 3, 4, 5] // Could also be a dictionary itself
let dictionary: [Int : String] = collection.map{
    $0 : "Number: \($0)"
}

As I suppose that there isn't such a function, how would something similar but elegant look like?

Grimxn · Accepted Answer · 2015-10-16T14:13:36.237

Here's a sketch of how it might be done. It uses a tuple return from the element closure, rather than your f1($0) : f2($0) pseudo-code. Note that the tuple elements can be any type, so long as the first (which will be used as the key) is hashable.

let collection = [1, 2, 3, 4, 5] 

/* OP's requested form:
let dictionary: [Int : String] = collection.map{
    $0 : "Number: \($0)"
}
*/

// Return a tuple of (key, value) from the closure...
extension CollectionType {
    func mapd<Tk: Hashable, Tv>(elementClosure: (Self.Generator.Element) -> (Tk, Tv) ) -> [Tk : Tv] {
        var returnDict = [Tk : Tv]()
        for i in self {
            let (k, v) = elementClosure(i)
            returnDict[k] = v
        }
        return returnDict
    }
}

let dictionary: [Int : String] = collection.mapd{ ($0, "Number: \($0)") }
print("\(dictionary)") // "[5: "Number: 5", 2: "Number: 2", 3: "Number: 3", 1: "Number:1]"

// Neither of the dictionary's elements need be the type of the collection,
// it's entirely up to what the closure returns.

let dictionary2: [Double : String] = collection.mapd{ (Double($0), "Number: \($0)") }
print("\(dictionary)") // "[5: "Number: 5", 2: "Number: 2", 3: "Number: 3", 1: "Number:1]"

Looks great. In Swift, is it a typical naming convention for generics to use `Tk` and `Tv` instead of `K` and `V`? — Lars Blumberg, Oct 16 '15 at 14:23
No - not as far as I've seen - I just made it up. K & V would probably have been a better choice... — Grimxn, Oct 16 '15 at 14:47

score 2 · Answer 2 · edited May 23 '17 at 12:29

2

You can use

extension Dictionary {
    init<S: SequenceType where S.Generator.Element == Element>(_ seq: S) {
        self.init()
        for (k,v) in seq {
            self[k] = v
        }
    }
}

from this answer to What's the cleanest way of applying map() to a dictionary in Swift?, which is a quite general way to create a dictionary from a sequence of key-value pairs.

Then your transformation can be done as

let collection = [1, 2, 3, 4, 5]
let dictionary = Dictionary(collection.lazy.map { ($0 , "Number: \($0)") })

print(dictionary)
// [5: "Number: 5", 2: "Number: 2", 3: "Number: 3", 1: "Number: 1", 4: "Number: 4"]

where .lazy – a suggested by @Kametrixom – avoids the creation of an intermediate array.

edited May 23 '17 at 12:29

Community

1
1

answered Oct 16 '15 at 13:59

Martin R

529,903
94
1,240
1,382

1

`lazy` before `map` would avoid the creation of an intermediate array – Kametrixom Oct 16 '15 at 15:56
@Kametrixom: Great suggestion! – Martin R Oct 16 '15 at 16:05

score 0 · Answer 3 · answered Oct 16 '15 at 13:54

I think you could solve this using a generic function

func toDictionary<T:Equatable>(collection:[T]) -> [T:String] {
  var dict = [T:String]()
  for item in collection{
    print(item)
    dict[item] = "\(item.dynamicType) \(item)"
  }
  return dict
}


let collection = [1,2,3,4,5]


let p = toDictionary(collection)

Is there a CollectionType function that transforms a collection to a dictionary?

3 Answers3