[swift-evolution] ed/ing, InPlace, Set/SetAlgebra naming resolution
Dave Abrahams
dabrahams at apple.com
Sun Feb 14 10:39:31 CST 2016
on Sun Feb 14 2016, David Hart <swift-evolution at swift.org> wrote:
> I don’t really agree with Dave’s comments about removing ‘with',
When one road merges with another, both are changed.
> but here’s one of mine – making the non-mutating difference an
> override of intersection because it sounds clearer to me and is
> consistent with the mutable versions being overrides:
I don't see any overrides around here. Care to clarify?
> Non-mutable
>
> let union = a.merged(with: b)
> let intersection = a.members(in: b)
> let difference = a.members(notIn: b)
> let symmetricDifference = a.merged(with: b, removingMembersInCommon: true)
>
> Mutable (In-Place)
>
> a.merge(with: b) // union in-place
> a.removeMembers(notIn: b) // intersect in-place
> a.removeMembers(in: b) // difference in-place
> a.merge(with: b, removingMembersInCommon: true) // symmetric difference in-place
>
>> On 14 Feb 2016, at 17:10, Dave Abrahams via swift-evolution
>> <swift-evolution at swift.org> wrote:
>>
>>
>> on Sat Feb 13 2016, Ricardo Parada <rparada-AT-mac.com> wrote:
>>
>>> Hi Dave,
>>>
>>> I would be okay with staying away from the mathematical terms similar
>>> to what you are suggesting except that the union can still be made
>>> more concise if you use merged / merge for the base name and shorten
>>> the labels to a bare minimum without loosing clarity. In addition,
>>> the merge can have a second parameter with a default to false in order
>>> to implement the symmetric difference (a.k.a. exclusive or). Recall
>>> that symmetric difference is the union of two sets and then removing
>>> the intersection (or members in common). I think it looks perfect
>>> (concise and clear). What does everybody else think?
>>>
>>> Non-mutable
>>>
>>> let union = a.merged(with: b)
>>> let intersection = a.members(in: b)
>>> let difference = a.removingMembers(in: b)
>>> let symmetricDifference = a.merged(with: b, removingMembersInCommon: true)
>>>
>>> Mutable (In-Place)
>>>
>>> a.merge(with: b) // union in-place
>>> a.removeMembers(notIn: b) // intersect in-place
>>> a.removeMembers(in: b) // difference in-place
>>> a.merge(with: b, removeMembersInCommon: true) // symmetric difference in-place
>>
>> I love your changes to my suggestion, Ricardo! The minor alterations I
>> would make are:
>>
>> 1. In both cases the Bool parameter ought to be called
>> “removingMembersInCommon”
>>
>> 2. I would remove “with” from the in-place merge operation. We're
>> really asking the receiver to merge b into itself. “With” gives it
>> the sense that it might almost be mutating b.
>>
>>> Ricardo Parada
>>>
>>>> On Feb 13, 2016, at 1:16 PM, Dave Abrahams via swift-evolution
>>>> <swift-evolution at swift.org> wrote:
>>>>
>>>>
>>>> on Fri Feb 12 2016, Ricardo Parada <swift-evolution at swift.org
>>>> <mailto:swift-evolution at swift.org>> wrote:
>>>>
>>>>> Hi all,
>>>>>
>>>>> I can’t make up my mind. Let me propose two different alternatives
>>>>> that I’m not sure if they have been considered:
>>>>>
>>>>> ALTERNATIVE 1
>>>>>
>>>>> Non-mutable (noun-based)
>>>>>
>>>>> - func union(other: Self) -> Self
>>>>> + func union(other: Self) -> Self Assumes union is a noun, i.e. not a verb
>>>>>
>>>>> - func intersect(other: Self) -> Self
>>>>> + func intersection(other: Self) -> Self
>>>>>
>>>>> - func subtract(other: Self) -> Self
>>>>> + func subtraction(other: Self) -> Self
>>>>>
>>>>> - func exclusiveOr(other: Self) -> Self
>>>>> + func symmetricSubtraction(other: Self) -> Self
>>>>>
>>>>> Mutable (verb-based)
>>>>>
>>>>> - mutating func unionInPlace(other: Self)
>>>>> + mutating func unite(other: Self)
>>>>>
>>>>> - mutating func intersectInPlace(other: Self)
>>>>> + mutating func intersect(other: Self)
>>>>>
>>>>> - mutating func subtractInPlace(other: Self)
>>>>> + mutating func subtract(other: Self)
>>>>>
>>>>> - mutating func exclusiveOrInPlace(other: Self)
>>>>> + mutating func symmetricSubtract(other: Self)
>>>>>
>>>>> Comments:
>>>>>
>>>>> With this alternative we keep the union name which I assume is
>>>>> popular. However, one has to accept unite as a verb (for the mutable
>>>>> version) as I wanted all the mutable methods use verbs for
>>>>> consistency. I think unite is acceptable because it can be found in
>>>>> the dictionary and it is a verb.
>>>>>
>>>>> Notice that all the non-mutable methods use nouns: union,
>>>>> intersection, subtraction and symmetricSubtraction.
>>>>>
>>>>> I understand some may oppose to symmetricSubtraction saying that
>>>>> symmetricSubraction is not as common as "exclusive or". However,
>>>>> using symmetricSubtraction is consistent with subtraction and it hints
>>>>> to a variation of the “subtraction" operation. We will get used to it
>>>>> quickly / easily.
>>>>>
>>>>> The mutable methods all use verbs: unite, intersect, subtract and symmetricSubtract.
>>>>>
>>>>> ALTERNATIVE 2
>>>>>
>>>>> Non-mutable
>>>>>
>>>>> - func union(other: Self) -> Self
>>>>> + func adding(other: Self) -> Self
>>>>>
>>>>> - func intersect(other: Self) -> Self
>>>>> + func intersecting(other: Self) -> Self
>>>>>
>>>>> - func exclusiveOr(other: Self) -> Self
>>>>> + func exclusiveOring(other: Self) -> Self
>>>>>
>>>>> - func subtract(other: Self) -> Self
>>>>> + func removing(other: Self) -> Self
>>>>>
>>>>> Mutable
>>>>>
>>>>> - mutating func unionInPlace(other: Self)
>>>>> + mutating func add(other: Self)
>>>>>
>>>>> - mutating func intersectInPlace(other: Self)
>>>>> + mutating func intersect(other: Self)
>>>>>
>>>>> - mutating func exclusiveOrInPlace(other: Self)
>>>>> + mutating func exclusiveOr(other: Self)
>>>>>
>>>>> - mutating func subtractInPlace(other: Self)
>>>>> + mutating func remove(other: Self)
>>>>>
>>>>> Comments: This alternative gives up on union in favor or add. Many
>>>>> may not like this, that is why I have it as the second alternative.
>>>>> It brings back exclusiveOr and treats it as a verb. Some may argue
>>>>> that exclusiveOr is a noun for the "exclusive or" operation.
>>>>
>>>> If we are going to force Set fit the naming guidelines, I would prefer
>>>> to stay away from the mathematical terms altogether.
>>>>
>>>> func insertingContentsOf(other: Self) -> Self // union
>>>> mutating func insertContentsOf(other)
>>>>
>>>> func members(in other: Self) -> Self // intersection
>>>> mutating func removeMembers(notIn: other)
>>>>
>>>> func removingMembersAndAddingNonMembers(in other: Self) -> Self // symmetric difference
>>>> mutating func removeMembersAndAddingNonMembers(in other: Self)
>>>>
>>>> func removingMembers(in other: Self) -> Self // subtract
>>>> mutating func removeMembers(in other: Self)
>>>>
>>>> If it would help with clarity, we could replace "in" with "foundIn"
>>>> above.
>>>>
>>>> --
>>>> -Dave
>>>>
>>>> _______________________________________________
>>>> swift-evolution mailing list
>>>> swift-evolution at swift.org
>>>> <mailto:swift-evolution at swift.org>
>>>> https://lists.swift.org/mailman/listinfo/swift-evolution
>>>> <https://lists.swift.org/mailman/listinfo/swift-evolution>
>>
>> --
>> -Dave
>> _______________________________________________
>> swift-evolution mailing list
>> swift-evolution at swift.org
>> https://lists.swift.org/mailman/listinfo/swift-evolution
>
> _______________________________________________
> swift-evolution mailing list
> swift-evolution at swift.org
> https://lists.swift.org/mailman/listinfo/swift-evolution
--
-Dave
More information about the swift-evolution
mailing list