How may I functionally transform array of objects into a different structure

Question

I've got an array of fonts which each have a familyName and a fontName.

I would like to transform them into an array of tuples in the form (familyName: String, fontNames: [String]).

I feel like there should be an easy functional way to do this, but can't work it out. The closest I've got is two calls to reduce: First into a dictionary and then into an array.

let dictionary = fonts.reduce(into [String : [String]]() ) { result, font in
    let array = result[font.fontFamily] ?? []
    result[fontFamily] = array + [font.fontName]
}

let array = dictionary(into: [(String, [String])]() ) { result, element in
    result.append( (element.key, element.value.sorted()) )
}.sorted { $0.0 < $1.0 }

I'm also sorting the array of tuples and the array of fontNames in the array of tuples.

Is there a way I can avoid the intermediary dictionary?

Many thanks.

Update I created a playground to show sanjaykmwt the results of their suggestions:

struct Font {
    let family: String
    let name: String
}

let fonts = [
    Font(family: "ABC", name: "abc"),
    Font(family: "ABC", name: "def"),
    Font(family: "ABC", name: "ghi"),
    Font(family: "XYZ", name: "xyz"),
    Font(family: "XYZ", name: "uvw")
]

let sortedFamily = fonts.sorted(by: { (lhs, rhs) -> Bool in
    return lhs.family < rhs.family
})

let dict = sortedFamily.map({["family":$0.family,
                              "fonts":$0.name]})

print("dict: \(dict)")

Output:

dict: [["family": "ABC", "fonts": "abc"], ["family": "ABC", "fonts": "def"], ["family": "ABC", "fonts": "ghi"], ["family": "XYZ", "fonts": "xyz"], ["family": "XYZ", "fonts": "uvw"]]

you fonts is struct and you have an array of struct

Abdelahad Darwish
– Abdelahad Darwish

2018-05-24 09:40:52 +00:00
Commented May 24, 2018 at 9:40 — Abdelahad Darwish
– Abdelahad Darwish, Commented May 24, 2018 at 9:40
I have given the shortest possible answer

sanjaykmwt
– sanjaykmwt

2018-05-24 10:05:09 +00:00
Commented May 24, 2018 at 10:05 — sanjaykmwt
– sanjaykmwt, Commented May 24, 2018 at 10:05

Abdelahad Darwish · Accepted Answer · 2018-05-24 09:49:00Z

2

if You have an array of Fonts with fontFamily, fontName

you can make grouping then map

 // Array Of Fonts Example

        let array = [Font.init(fontFamily: "Cago", fontName: "AA"),
                                     Font.init(fontFamily: "Cago", fontName: "CCCC"),
                                     Font.init(fontFamily: "Mango", fontName: "AAsss"),
                                      Font.init(fontFamily: "Mango", fontName: "mngoo")]

         // Grouping

        let groupedByFamilayName = Dictionary.init(grouping: array) {$0.fontFamily}

        // Map
        let arrayOfTuple =  groupedByFamilayName.map { (key,array) -> (String,[String]) in
                            return (key,array.map({$0.fontName}))
                        }

     print(arrayOfTuple)

answered May 24, 2018 at 9:49

Abdelahad Darwish

6,0771 gold badge19 silver badges35 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

Josh Paradroid Over a year ago

Thanks. I didn't know about Dictionary.init(grouping: array)

Ashley Mills · Accepted Answer · 2018-05-25 14:49:38Z

2

Expanding (or contracting!) on Abdelahad Darwish's answer…

let tuples = Dictionary(grouping: fonts) { $0.family }
    .map { (familyName: $0.key, fontNames: $0.value.map { $0.name }) }

print(tuples)

[(familyName: "XYZ", fontNames: ["xyz", "uvw"]), (familyName: "ABC", fontNames: ["abc", "def", "ghi"])]

answered May 25, 2018 at 14:49

Ashley Mills

53.6k17 gold badges138 silver badges175 bronze badges

2 Comments

Josh Paradroid Over a year ago

Thanks, this is approximately what I have now, plus a bit of dealing with optionals that I forgot to mention.

Abdelahad Darwish Over a year ago

Nice coding Ashley

sanjaykmwt · Accepted Answer · 2018-05-24 10:03:38Z

-2

    let sortedFamily = fonts.sorted(by: { (lhs, rhs) -> Bool in
        return lhs.family < rhs.family
    })

    let dict = sortedFamily.map({["family":$0.family,"fonts":$0.fonts.sorted()]})

try and print the dict you will get everything sorted

if you want even shorter it can be:

  let dict = fonts.sorted(by: { (lhs, rhs) -> Bool in
        return lhs.family < rhs.family
    }).map({["family":$0.family,"fonts":$0.fonts.sorted()]})

answered May 24, 2018 at 10:03

sanjaykmwt

6044 silver badges19 bronze badges

6 Comments

Josh Paradroid Over a year ago

I think you have misunderstood the question. The question is about the transform of the data structure, not the sorting.

sanjaykmwt Over a year ago

this gives you both the things you want if you only want to transform then you can use this instead: let dict = fonts.map({["family":$0.family,"fonts":$0.fonts]})

Josh Paradroid Over a year ago

You refer to this $0.fonts which doesn't exist.

sanjaykmwt Over a year ago

for you it is $0.fontFamily and $0.fontName

Josh Paradroid Over a year ago

That just produces an array of dictionaries, each with one "family" and one "fonts" (which is a single font). At no point in the code are you merging the fontNames into one array (per familyName).

|

Collectives™ on Stack Overflow

How may I functionally transform array of objects into a different structure

3 Answers 3

1 Comment

2 Comments

6 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

1 Comment

2 Comments

6 Comments

Your Answer

Sign up or log in

Post as a guest

Related