[swift-evolution] [Proposal] mapValues

Andrew Bennett cacoyi at gmail.com
Fri Apr 15 19:58:34 CDT 2016

Thanks Brent for your in-depth response - I've responded in another thread
so we don't pollute this one (sorry Jonathan):

I think mapValues is great, and really needed in Swift.

I'm a definite +1 on a version of map that only maps the values.

On Sat, Apr 16, 2016 at 7:56 AM, Brent Royal-Gordon <brent at architechies.com>

> > This is a clarification on what I meant (I haven't had much time to test
> it, but I think it's representative):
> >
> > https://gist.github.com/therealbnut/c223d90a34bb14448b65fc6cc0ec70ac
> There are a number of problems with this:
> * Given just an `Index`, you need to be able to calculate the next
> `Index`, and check if it lies before the `endIndex`. The complexity of this
> is hidden in your example because you're relying on a traditional
> `DictionaryIndex` to perform these tasks. Thus, the `Index` type in your
> dictionary design would be some sort of wrapper-around-the-key, not the key
> itself. That's the source of the `subscript(_: Index) -> Value` which
> apparently confused you.
> * Generic `SequenceType` and `CollectionType` operations now use only the
> values, not the keys and values. That means that `Array(newDictionary)`
> gets you an array of values, `filter` returns an array of values, `reduce`
> operates only on the values, etc; all of these operations throw away the
> keys. That's not necessarily wrong, but I'm not sure that you're aware of
> it.
> * Your `map` is overloading `SequenceType.map` merely by return type. That
> means you can no longer assign it directly to a newly-declared variable, or
> use it in many other contexts where the type has to be inferred.
> * Your `enumerate` is similarly overloading by return type. It's also
> further confusing an already confused semantic. `enumerate` does not pair
> elements with their indices; it pairs them with integers starting at zero.
> This *happens* to correspond to their array indices, but that's not
> necessarily true of any other Collection. (I'm going to start another
> thread about this.)
> Basically, in this conception of Dictionary:
> * The keys are disposable and the values are the important part—most
> operations on a Dictionary would throw away the keys and use only the
> values.
> * Index still would not be a Key—it would be some kind of instance which
> wrapped or converted into a Key.
> * You still would need to name Dictionary-creating `map` and similar
> functions differently from their Array-generating cousins.
> * Iterating over keys and values together would require some kind of
> Dictionary-specific API, not something that was available on other
> collections or sequences.
> Maybe that would be an improvement, but I'm skeptical.
> --
> Brent Royal-Gordon
> Architechies
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20160416/9d42c42b/attachment.html>

More information about the swift-evolution mailing list