> On 9 Jun 2016, at 17:11, Dave Abrahams <[email protected]> wrote:
>
>
> on Thu Jun 09 2016, Haravikk <swift-evolution-AT-haravikk.me
> <http://swift-evolution-at-haravikk.me/>> wrote:
>
>>> On 8 Jun 2016, at 20:53, Dave Abrahams via swift-evolution
>> <[email protected] <mailto:[email protected]>> wrote:
>>>
>>>> on Wed Jun 08 2016, Haravikk <[email protected]
>>>> <mailto:[email protected]>
>> <mailto:[email protected] <mailto:[email protected]>>> wrote:
>>>>
>>>> But those shouldn't be the public names. Perhaps s/box/wrap/ ?
>>
>> True! So I’m thinking I’ll try to come up with a basic proposal soon,
>> I’m just thinking about how this would be implemented. For example, it
>> may make sense to do this as a protocol that AnyIndex (and other
>> suitable types) can just conform to like so:
>>
>> protocol Unwrappable {
>> associatedtype UnwrappedType
>> func unwrap<T:UnwrappedType>() -> T?
>> func unsafeUnwrap<T:UnwrappedType>() -> T
>> }
>>
>> I’ve kept the ability to specify a root type that unwrapping can
>> produce, i.e- Comparable in the case of AnyIndex. Not too happy with
>> the name of UnwrappedType, since it’s not intended to be the exact
>> type in most cases,
>
> Examples please?
Unfortunately I can’t actually seem to get the above protocol to work, Swift
won’t accept the associated type on the generic constraints for the methods, it
complains of it being a non-class/non-protocol type. These kinds of tricky
generics are very much not a strength of my Swift programming abilities =)
The advantage of being able to declare a base type however is that it helps to
disambiguate overloads. For example, consider unwrapping on AnyIndex using the
following method:
public struct AnyIndex : Comparable {
public func unsafeUnwrap<T:Comparable>() -> T
}
I then get myself an AnyIndex and decide I’d like to use it in a subscript like
so:
let value = myDictionary[myIndex.unsafeUnwrap()]
Since the unwrapped type is known to at least be of type Comparable, it’s
obvious to the compiler which subscript I mean. If however no minimum
conformance is provided (i.e- the above method is unsafeUnwrap<T>() -> T) then
there are three possibilities (Index, Range and Key, since it’s a dictionary)
so it produces an error.
It can still be used by assigning the unwrapped value to a variable with
explicit type, but that’s a bit more verbose than I was hoping for.
Of course it can still fail if my AnyIndex isn’t wrapping a DictionaryIndex,
but the extra type information at least prevents me from using the unwrapping
somewhere that a Comparable can’t possibly be used.
So in my code this so far means I’m having to stick with adding the methods
directly to my AnyIndex substitute rather than to a protocol, as I can put the
restriction on it this way.
Like I say though, complex generic conformance is something I’m still ropey on
(yet I seem to keep finding myself cases that need it) so it’s possible there’s
a way to do this that I just can’t think of, or perhaps there are some features
on their way that would enable this to work as I’m hoping?_______________________________________________
swift-evolution mailing list
[email protected]
https://lists.swift.org/mailman/listinfo/swift-evolution
