Why can I not filter or map a dictionary to another dictionary?

JetForMe · 2016-10-27T00:12:54.000Z

It seems fairly natural to want to do this:

let bigDictionary = ...
let smallerDictionary = bigDictionary.filter { key, value in <some test returning Bool> }

Similarly, it seems natural to want to map this way.

Am I overlooking something?

···

--
Rick Mann
rmann@latencyzero.com

hooman · 2016-10-27T04:53:08.000Z

The rational for returning Array is here: https://github.com/apple/swift/blob/master/docs/StdlibRationales.rst#high-order-functions-on-collections-return-arrays

I have this simple extension to dictionary:

extension Dictionary {

mutating func append(_ element: Element) {

        self[element.key] = element.value
    }

    mutating func append<S: Sequence>(contentsOf sequence: S) where S.Iterator.Element == Element {

        for element in sequence { append(element) }
    }

    init<S: Sequence>(_ sequence: S) where S.Iterator.Element == Element {

        self.init()
        self.append(contentsOf: sequence)
    }
}

Which enables doing this:

var d = ["A":1, "B":2, "C": 3, "D": 4, "E": 5]

d.append((key: "F", value: 6))

d.append(contentsOf: ["G": 7, "H": 8])

var e = Dictionary(d.filter { $0.key < "E" })

print(e)

You should note that the meaning of `append` here is different from ordinary (array-like) collections.

···

On Oct 26, 2016, at 5:12 PM, Rick Mann via swift-users <swift-users@swift.org> wrote:

It seems fairly natural to want to do this:

let bigDictionary = ...
let smallerDictionary = bigDictionary.filter { key, value in <some test returning Bool> }

Similarly, it seems natural to want to map this way.

Am I overlooking something?

--
Rick Mann
rmann@latencyzero.com

_______________________________________________
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users

dabrahams · 2016-10-27T05:23:23.000Z

It's reasonable for filter, but maybe not for map. Map follows certain
laws, and one of them is that you get the same number of elements out as
you put in. But you can easily map all keys to the same key, and the
law would be violated.

···

on Wed Oct 26 2016, Rick Mann <swift-users-AT-swift.org> wrote:

It seems fairly natural to want to do this:

let bigDictionary = ...
let smallerDictionary = bigDictionary.filter { key, value in <some test returning Bool> }

Similarly, it seems natural to want to map this way.

--
-Dave

vjosullivan · 2016-10-27T06:39:31.000Z

You can. You just need to get the syntax right:

let smallerDictionary = bigDictionary.filter { (key, value) in <some test returning Bool> }

let bd = [1:"A", 2:"B", 3:"C"]
let sd = bd.filter{(k, v) in
k > 1}
dump(sd)

···

On 27/10/2016, 01:12, "Rick Mann via swift-users" <swift-users-bounces@swift.org on behalf of swift-users@swift.org> wrote:

    It seems fairly natural to want to do this:

    let bigDictionary = ...
    let smallerDictionary = bigDictionary.filter { key, value in <some test returning Bool> }

    Similarly, it seems natural to want to map this way.

    Am I overlooking something?

    --
    Rick Mann
    rmann@latencyzero.com

    _______________________________________________
    swift-users mailing list
    swift-users@swift.org
    https://lists.swift.org/mailman/listinfo/swift-users

JetForMe · 2016-10-27T07:58:01.000Z

Sure map would produce a dictionary of the same number of entries. I didn't mean to imply map would also filter. But I'm basically transforming a JSON dictionary into a new version of that dictionary with fewer elements. I'd like to first filter it, then map it, and have the result be a dictionary.

···

On Oct 26, 2016, at 22:23 , Dave Abrahams via swift-users <swift-users@swift.org> wrote:

on Wed Oct 26 2016, Rick Mann <swift-users-AT-swift.org> wrote:

It seems fairly natural to want to do this:

let bigDictionary = ...
let smallerDictionary = bigDictionary.filter { key, value in <some test returning Bool> }

Similarly, it seems natural to want to map this way.

It's reasonable for filter, but maybe not for map. Map follows certain
laws, and one of them is that you get the same number of elements out as
you put in. But you can easily map all keys to the same key, and the
law would be violated.

--
Rick Mann
rmann@latencyzero.com

vjosullivan · 2016-10-27T06:43:53.000Z

Ah. Having seen the other answers, I can now see the implied question.

···

On 27/10/2016, 07:39, "Vincent O'Sullivan via swift-users" <swift-users-bounces@swift.org on behalf of swift-users@swift.org> wrote:

    You can. You just need to get the syntax right:

    let smallerDictionary = bigDictionary.filter { (key, value) in <some test returning Bool> }

    let bd = [1:"A", 2:"B", 3:"C"]
    let sd = bd.filter{(k, v) in
        k > 1}
    dump(sd)

    On 27/10/2016, 01:12, "Rick Mann via swift-users" <swift-users-bounces@swift.org on behalf of swift-users@swift.org> wrote:

        It seems fairly natural to want to do this:

        let bigDictionary = ...
        let smallerDictionary = bigDictionary.filter { key, value in <some test returning Bool> }

        Similarly, it seems natural to want to map this way.

        Am I overlooking something?

        --
        Rick Mann
        rmann@latencyzero.com

        _______________________________________________
        swift-users mailing list
        swift-users@swift.org
        https://lists.swift.org/mailman/listinfo/swift-users

    _______________________________________________
    swift-users mailing list
    swift-users@swift.org
    https://lists.swift.org/mailman/listinfo/swift-users

JetForMe · 2016-10-27T08:00:36.000Z

Ah. Having seen the other answers, I can now see the implied question.

   You can. You just need to get the syntax right:

   let smallerDictionary = bigDictionary.filter { (key, value) in <some test returning Bool> }

   let bd = [1:"A", 2:"B", 3:"C"]
   let sd = bd.filter{(k, v) in
       k > 1}
   dump(sd)

In this example, sd is an array of tuples of (key, value), not a dictionary.

···

On Oct 26, 2016, at 23:43 , Vincent O'Sullivan via swift-users <swift-users@swift.org> wrote:
On 27/10/2016, 07:39, "Vincent O'Sullivan via swift-users" <swift-users-bounces@swift.org on behalf of swift-users@swift.org> wrote:

   On 27/10/2016, 01:12, "Rick Mann via swift-users" <swift-users-bounces@swift.org on behalf of swift-users@swift.org> wrote:

       It seems fairly natural to want to do this:

       let bigDictionary = ...
       let smallerDictionary = bigDictionary.filter { key, value in <some test returning Bool> }

       Similarly, it seems natural to want to map this way.

       Am I overlooking something?

       --
       Rick Mann
       rmann@latencyzero.com

       _______________________________________________
       swift-users mailing list
       swift-users@swift.org
       https://lists.swift.org/mailman/listinfo/swift-users

   _______________________________________________
   swift-users mailing list
   swift-users@swift.org
   https://lists.swift.org/mailman/listinfo/swift-users

_______________________________________________
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users

--
Rick Mann
rmann@latencyzero.com

dabrahams · 2016-10-27T17:29:54.000Z

It seems fairly natural to want to do this:

let bigDictionary = ...
let smallerDictionary = bigDictionary.filter { key, value in <some test returning Bool> }

Similarly, it seems natural to want to map this way.

It's reasonable for filter, but maybe not for map. Map follows certain
laws, and one of them is that you get the same number of elements out as
you put in. But you can easily map all keys to the same key, and the
law would be violated.

Sure map would produce a dictionary of the same number of entries. I
didn't mean to imply map would also filter.

I think you're missing my point. What result do you expect from

{1:2, 3:4}.map { _ in (1, 1) }

? How many elements does it have? Note that you can't have the same key
twice in a Dictionary.

But I'm basically transforming a JSON dictionary into a new version of
that dictionary with fewer elements. I'd like to first filter it, then
map it, and have the result be a dictionary.

What we need are Dictionary initializers that operate on Sequences, per

github.com

apple/swift-evolution/blob/main/proposals/0100-add-sequence-based-init-and-merge-to-dictionary.md

# Add sequence-based initializers and merge methods to Dictionary

* Proposal: [SE-0100](0100-add-sequence-based-init-and-merge-to-dictionary.md)
* Author: [Nate Cook](https://github.com/natecook1000)
* Review Manager: TBD
* Status: **Withdrawn**

## Introduction

The `Dictionary` type should allow initialization from a sequence of `(Key, Value)` tuples and offer methods that merge a sequence of `(Key, Value)` tuples into a new or existing dictionary, using a closure to combine values for duplicate keys.

Swift-evolution thread: [First message of thread](https://forums.swift.org/t/map-like-operation-that-returns-a-dictionary/999), [Initial proposal draft](https://forums.swift.org/t/map-like-operation-that-returns-a-dictionary/999/18)


## Motivation

`Array` and `Set` both have initializers that create a new instance from a sequence of elements. The `Array` initializer is useful for converting other sequences and collections to the "standard" collection type, while the `Set` initializer is essential for recovering set operations after performing any functional operations on a set. For example, filtering a set produces a collection without any kind of set operations available.

```swift
let numberSet = Set(1 ... 100)

This file has been truncated. show original

Dictionary(merging: d.lazy.filter {... }.map {...})

That would get you the result you're looking for in a principled way,
without creating an intermediate Array.

···

on Thu Oct 27 2016, Rick Mann <rmann-AT-latencyzero.com> wrote:

On Oct 26, 2016, at 22:23 , Dave Abrahams via swift-users <swift-users@swift.org> wrote:
on Wed Oct 26 2016, Rick Mann <swift-users-AT-swift.org> wrote:

--
-Dave

JetForMe · 2016-10-31T08:55:55.000Z

It seems fairly natural to want to do this:

let bigDictionary = ...
let smallerDictionary = bigDictionary.filter { key, value in <some test returning Bool> }

Similarly, it seems natural to want to map this way.

It's reasonable for filter, but maybe not for map. Map follows certain
laws, and one of them is that you get the same number of elements out as
you put in. But you can easily map all keys to the same key, and the
law would be violated.

Sure map would produce a dictionary of the same number of entries. I
didn't mean to imply map would also filter.

I think you're missing my point. What result do you expect from

{1:2, 3:4}.map { _ in (1, 1) }

Fair point. I suppose I'd be okay with unpredictable results, or an exception, if possible.

? How many elements does it have? Note that you can't have the same key
twice in a Dictionary.

But I'm basically transforming a JSON dictionary into a new version of
that dictionary with fewer elements. I'd like to first filter it, then
map it, and have the result be a dictionary.

What we need are Dictionary initializers that operate on Sequences, per
https://github.com/apple/swift-evolution/blob/master/proposals/0100-add-sequence-based-init-and-merge-to-dictionary.md

Dictionary(merging: d.lazy.filter {... }.map {...})

That would get you the result you're looking for in a principled way,
without creating an intermediate Array.

I guess for now I write it in a clunky way.

···

On Oct 27, 2016, at 10:29 , Dave Abrahams <dabrahams@apple.com> wrote:
on Thu Oct 27 2016, Rick Mann <rmann-AT-latencyzero.com> wrote:

On Oct 26, 2016, at 22:23 , Dave Abrahams via swift-users <swift-users@swift.org> wrote:
on Wed Oct 26 2016, Rick Mann <swift-users-AT-swift.org> wrote:

--
Rick Mann
rmann@latencyzero.com