Re: [swift-users] Weird protocol behaviour.
When you call foo(_: A) with a concrete type C, the type checker
performs a conformance check of C to P. If C is a protocol type, the
conformance check fails. Ie, unlike the subtype relation (roughly, “I can
assign a value of this type to that”), the conformance relation (“I can
substitute this for a generic parameter conforming to”) is not reflexive.
Swift compiles generic code in a way where values of generic type have the most
efficient representation in memory — you pay a CPU cost because they’re still
manipulated indirectly (unlike C++ templates, which are cloned and inlined at
compile time), but there’s no representational cost as in Java’s erased
generics for example.
What this means is that all types that you can substitute for a generic
parameter have to be interchangeable in some basic sense.
The main problem is with class-bound protocols:
protocol CP : class {
func foo()
func bar()
}
And a function taking an array of CP’s:
func foo(t: [T]) {}
All concrete types that conform to a class-bound protocol have a single
retainable-pointer representation, so the function takes an array of pointers.
However, a value of protocol type ‘CP’ is represented as the underlying
concrete value — a pointer to a class instance conforming to CP — together with
the conformance table that stores the function pointers for the implementations
of ‘foo’ and ‘bar’.
So unlike in Java, where method implementations for an interface are stored
“inside” the instance, in Swift protocol requirement implementations are always
passed ‘on the side’.
With opaque protocols, a type parameter has variable size, so there’s no
representational issue. Instead you just get a double indirection.
Say you have
protocol P {}
func foo(t: [T]) {}
If you call foo with the substitution P := P, then you’re passing in an array
of values *where each value has its own conformance to P*. But foo() itself
wants the conformance P : P. So when you call a protocol requirement on an
element of ’t’. you will first call a method in the ‘dummy’ conformance P : P,
which will unpack the “real” concrete type from the value of type P and call
the right method on that.
So we could implement self-conformance for non-class-bound protocols. For
class-bound protocols, I’m not sure how to do it efficiently.
Slava
> On Dec 30, 2016, at 8:26 AM, Mikhail Seriukov wrote:
>
> So as the foo(_ x:A) function is generic, when we call foo(x) compiler
> needs to determine what type is A to be able to create concrete function. But
> x defined as let x = X() as P so we only know about it that it conforms to P
> but not its real type to put instead of A. Right?
> But where is the "Protocols do not conform to themselves" limitation is
> coming out?
>
> 2016-12-30 18:25 GMT+07:00 Rien >:
>
> > On 30 Dec 2016, at 12:14, Mikhail Seriukov via swift-users
> > mailto:swift-users@swift.org>> wrote:
> >
> > Ok,
> > But I think I still do not get it.
> > What does really happen when we write this?
> >> let x = X() as P
> >>
>
> 'X()' creates a value.
> 'as P’ constrains the value such that the only things we know about it is
> that the value will conform to the protocol P
> ‘let x =‘ assigns the value to a constant, and the only thing we know about
> that constant is that we can call an operation of protocol P on it.
>
> Rien.
>
> > As I said, I expect x to be Any after that. If it is, then it should be
> > ok IMO.
> > But if it is not then what is the actual type of x?
> >
> > So the real question is how the type checker works here?
> >
> >
> > 2016-12-25 22:13 GMT+07:00 Slava Pestov > >:
> >
> >> On Dec 22, 2016, at 4:43 PM, Howard Lovatt via swift-users
> >> mailto:swift-users@swift.org>> wrote:
> >>
> >> The following variation works:
> >>
> >> protocol P {}
> >>
> >> class P1:P {}
> >>
> >> class X:P1 {}
> >>
> >> func foo(_ x:A) {}
> >>
> >> func bar() {
> >> //let x = X() // this compiles
> >> let x = X() as P1 // this does not compile. Why?
> >> foo(x)
> >> }
> >>
> >> Which adds credence to the bug theory.
> >
> > It’s an intentional limitation. Protocols do not conform to themselves.
> > Lifting the restriction would be difficult to do efficiently given our
> > representation of generics and protocols at runtime.
> >
> > Slava
> >
> >>
> >> Note two changes: 1. two levels of inheritance and 2. change to classes.
> >> If you do two levels using protocols it doesn't work if you use either
> >> classes or structs.
> >>
> >>
> >> -- Howard.
> >>
> >> On 23 December 2016 at 07:29, Kevin Nattinger >> > wrote:
> >> I recall seeing a request on the -evolution list for something like `T :=
> >> X` to indicate it could be X itself or anything inheriting / implementing
> >> it, so it’s certainly known behavior, if not desired. IMO it’s a bug and
> >> `:` should be fixed to include the root type, whether or not that requires
> >> a
Re: [swift-users] Weird protocol behaviour.
> On 30 Dec 2016, at 17:26, Mikhail Seriukov wrote:
>
> So as the foo(_ x:A) function is generic, when we call foo(x) compiler
> needs to determine what type is A to be able to create concrete function. But
> x defined as let x = X() as P so we only know about it that it conforms to P
> but not its real type to put instead of A. Right?
I believe so.
> But where is the "Protocols do not conform to themselves" limitation is
> coming out?
I think it was a reference to earlier in the discussion where a protocol was
passed as a parameter.
Rien.
>
> 2016-12-30 18:25 GMT+07:00 Rien :
>
> > On 30 Dec 2016, at 12:14, Mikhail Seriukov via swift-users
> > wrote:
> >
> > Ok,
> > But I think I still do not get it.
> > What does really happen when we write this?
> >> let x = X() as P
> >>
>
> 'X()' creates a value.
> 'as P’ constrains the value such that the only things we know about it is
> that the value will conform to the protocol P
> ‘let x =‘ assigns the value to a constant, and the only thing we know about
> that constant is that we can call an operation of protocol P on it.
>
> Rien.
>
> > As I said, I expect x to be Any after that. If it is, then it should be
> > ok IMO.
> > But if it is not then what is the actual type of x?
> >
> > So the real question is how the type checker works here?
> >
> >
> > 2016-12-25 22:13 GMT+07:00 Slava Pestov :
> >
> >> On Dec 22, 2016, at 4:43 PM, Howard Lovatt via swift-users
> >> wrote:
> >>
> >> The following variation works:
> >>
> >> protocol P {}
> >>
> >> class P1:P {}
> >>
> >> class X:P1 {}
> >>
> >> func foo(_ x:A) {}
> >>
> >> func bar() {
> >> //let x = X() // this compiles
> >> let x = X() as P1 // this does not compile. Why?
> >> foo(x)
> >> }
> >>
> >> Which adds credence to the bug theory.
> >
> > It’s an intentional limitation. Protocols do not conform to themselves.
> > Lifting the restriction would be difficult to do efficiently given our
> > representation of generics and protocols at runtime.
> >
> > Slava
> >
> >>
> >> Note two changes: 1. two levels of inheritance and 2. change to classes.
> >> If you do two levels using protocols it doesn't work if you use either
> >> classes or structs.
> >>
> >>
> >> -- Howard.
> >>
> >> On 23 December 2016 at 07:29, Kevin Nattinger wrote:
> >> I recall seeing a request on the -evolution list for something like `T :=
> >> X` to indicate it could be X itself or anything inheriting / implementing
> >> it, so it’s certainly known behavior, if not desired. IMO it’s a bug and
> >> `:` should be fixed to include the root type, whether or not that requires
> >> a discussion on -evolution.
> >>
> >>> On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users
> >>> wrote:
> >>>
> >>> I suspect a compiler bug since A is a P. The equivalent in Java works:
> >>>
> >>> interface P {}
> >>> class X implements P {}
> >>>
> >>> void foo(A x) {}
> >>>
> >>> void bar() {
> >>> final P x = new X();
> >>> foo(x);
> >>> }
> >>>
> >>> -- Howard.
> >>>
> >>> On 23 Dec 2016, at 3:19 am, Rien via swift-users
> >>> wrote:
> >>>
> IMO the error message says it all:
>
> Playground execution failed: error: MyPlayground8.playground:9:5: error:
> cannot invoke 'foo' with an argument list of type '(P)'
> foo(x)
> ^
>
> MyPlayground8.playground:9:5: note: expected an argument list of type
> '(A)'
> foo(x)
> ^
>
> I.e. you are passing in a protocol while the function is specified for a
> type.
> Said other way: On which data do you expect the protocol to operate?
>
> Regards,
> Rien
>
> Site: http://balancingrock.nl
> Blog: http://swiftrien.blogspot.com
> Github: http://github.com/Swiftrien
> Project: http://swiftfire.nl
>
>
>
>
> > On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users
> > wrote:
> >
> > Hello community! I' wondering if somebody can explain this to me.
> > Please take look at the snippet.
> >
> > protocol P {}
> > struct X:P {}
> >
> > func foo(_ x:A) {}
> >
> > func bar() {
> >//let x = X() // this compiles
> >let x = X() as P // this does not compile. Why?
> >foo(x)
> > }
> >
> > I expect the both cases to work though. But only first works? And I do
> > not understand why.
> > My coworkers said that it is a compiler bug, but I'm not shure it is.
> > Thanks for the help.
> > ___
> > 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-user
Re: [swift-users] Weird protocol behaviour.
So as the *foo(_ x:A) *function is generic, when we call *foo(x) *compiler
needs to determine what type is *A *to be able to create concrete function.
But x defined as *let x = X() as P *so we only know about it that it
conforms to *P *but not its real type to put instead of *A*. Right?
But where is the "Protocols do not conform to themselves" limitation is
coming out?
2016-12-30 18:25 GMT+07:00 Rien :
>
> > On 30 Dec 2016, at 12:14, Mikhail Seriukov via swift-users <
> swift-users@swift.org> wrote:
> >
> > Ok,
> > But I think I still do not get it.
> > What does really happen when we write this?
> >> let x = X() as P
> >>
>
> 'X()' creates a value.
> 'as P’ constrains the value such that the only things we know about it is
> that the value will conform to the protocol P
> ‘let x =‘ assigns the value to a constant, and the only thing we know
> about that constant is that we can call an operation of protocol P on it.
>
> Rien.
>
> > As I said, I expect x to be Any after that. If it is, then it should
> be ok IMO.
> > But if it is not then what is the actual type of x?
> >
> > So the real question is how the type checker works here?
> >
> >
> > 2016-12-25 22:13 GMT+07:00 Slava Pestov :
> >
> >> On Dec 22, 2016, at 4:43 PM, Howard Lovatt via swift-users <
> swift-users@swift.org> wrote:
> >>
> >> The following variation works:
> >>
> >> protocol P {}
> >>
> >> class P1:P {}
> >>
> >> class X:P1 {}
> >>
> >> func foo(_ x:A) {}
> >>
> >> func bar() {
> >> //let x = X() // this compiles
> >> let x = X() as P1 // this does not compile. Why?
> >> foo(x)
> >> }
> >>
> >> Which adds credence to the bug theory.
> >
> > It’s an intentional limitation. Protocols do not conform to themselves.
> Lifting the restriction would be difficult to do efficiently given our
> representation of generics and protocols at runtime.
> >
> > Slava
> >
> >>
> >> Note two changes: 1. two levels of inheritance and 2. change to
> classes. If you do two levels using protocols it doesn't work if you use
> either classes or structs.
> >>
> >>
> >> -- Howard.
> >>
> >> On 23 December 2016 at 07:29, Kevin Nattinger
> wrote:
> >> I recall seeing a request on the -evolution list for something like `T
> := X` to indicate it could be X itself or anything inheriting /
> implementing it, so it’s certainly known behavior, if not desired. IMO it’s
> a bug and `:` should be fixed to include the root type, whether or not that
> requires a discussion on -evolution.
> >>
> >>> On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users <
> swift-users@swift.org> wrote:
> >>>
> >>> I suspect a compiler bug since A is a P. The equivalent in Java works:
> >>>
> >>> interface P {}
> >>> class X implements P {}
> >>>
> >>> void foo(A x) {}
> >>>
> >>> void bar() {
> >>> final P x = new X();
> >>> foo(x);
> >>> }
> >>>
> >>> -- Howard.
> >>>
> >>> On 23 Dec 2016, at 3:19 am, Rien via swift-users <
> swift-users@swift.org> wrote:
> >>>
> IMO the error message says it all:
>
> Playground execution failed: error: MyPlayground8.playground:9:5:
> error: cannot invoke 'foo' with an argument list of type '(P)'
> foo(x)
> ^
>
> MyPlayground8.playground:9:5: note: expected an argument list of type
> '(A)'
> foo(x)
> ^
>
> I.e. you are passing in a protocol while the function is specified
> for a type.
> Said other way: On which data do you expect the protocol to operate?
>
> Regards,
> Rien
>
> Site: http://balancingrock.nl
> Blog: http://swiftrien.blogspot.com
> Github: http://github.com/Swiftrien
> Project: http://swiftfire.nl
>
>
>
>
> > On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users <
> swift-users@swift.org> wrote:
> >
> > Hello community! I' wondering if somebody can explain this to me.
> > Please take look at the snippet.
> >
> > protocol P {}
> > struct X:P {}
> >
> > func foo(_ x:A) {}
> >
> > func bar() {
> >//let x = X() // this compiles
> >let x = X() as P // this does not compile. Why?
> >foo(x)
> > }
> >
> > I expect the both cases to work though. But only first works? And I
> do not understand why.
> > My coworkers said that it is a compiler bug, but I'm not shure it is.
> > Thanks for the help.
> > ___
> > 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
> >>
> >>
> >> ___
> >> swift-users maili
Re: [swift-users] Weird protocol behaviour.
> On 30 Dec 2016, at 12:14, Mikhail Seriukov via swift-users
> wrote:
>
> Ok,
> But I think I still do not get it.
> What does really happen when we write this?
>> let x = X() as P
>>
'X()' creates a value.
'as P’ constrains the value such that the only things we know about it is that
the value will conform to the protocol P
‘let x =‘ assigns the value to a constant, and the only thing we know about
that constant is that we can call an operation of protocol P on it.
Rien.
> As I said, I expect x to be Any after that. If it is, then it should be ok
> IMO.
> But if it is not then what is the actual type of x?
>
> So the real question is how the type checker works here?
>
>
> 2016-12-25 22:13 GMT+07:00 Slava Pestov :
>
>> On Dec 22, 2016, at 4:43 PM, Howard Lovatt via swift-users
>> wrote:
>>
>> The following variation works:
>>
>> protocol P {}
>>
>> class P1:P {}
>>
>> class X:P1 {}
>>
>> func foo(_ x:A) {}
>>
>> func bar() {
>> //let x = X() // this compiles
>> let x = X() as P1 // this does not compile. Why?
>> foo(x)
>> }
>>
>> Which adds credence to the bug theory.
>
> It’s an intentional limitation. Protocols do not conform to themselves.
> Lifting the restriction would be difficult to do efficiently given our
> representation of generics and protocols at runtime.
>
> Slava
>
>>
>> Note two changes: 1. two levels of inheritance and 2. change to classes. If
>> you do two levels using protocols it doesn't work if you use either classes
>> or structs.
>>
>>
>> -- Howard.
>>
>> On 23 December 2016 at 07:29, Kevin Nattinger wrote:
>> I recall seeing a request on the -evolution list for something like `T := X`
>> to indicate it could be X itself or anything inheriting / implementing it,
>> so it’s certainly known behavior, if not desired. IMO it’s a bug and `:`
>> should be fixed to include the root type, whether or not that requires a
>> discussion on -evolution.
>>
>>> On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users
>>> wrote:
>>>
>>> I suspect a compiler bug since A is a P. The equivalent in Java works:
>>>
>>> interface P {}
>>> class X implements P {}
>>>
>>> void foo(A x) {}
>>>
>>> void bar() {
>>> final P x = new X();
>>> foo(x);
>>> }
>>>
>>> -- Howard.
>>>
>>> On 23 Dec 2016, at 3:19 am, Rien via swift-users
>>> wrote:
>>>
IMO the error message says it all:
Playground execution failed: error: MyPlayground8.playground:9:5: error:
cannot invoke 'foo' with an argument list of type '(P)'
foo(x)
^
MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
foo(x)
^
I.e. you are passing in a protocol while the function is specified for a
type.
Said other way: On which data do you expect the protocol to operate?
Regards,
Rien
Site: http://balancingrock.nl
Blog: http://swiftrien.blogspot.com
Github: http://github.com/Swiftrien
Project: http://swiftfire.nl
> On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users
> wrote:
>
> Hello community! I' wondering if somebody can explain this to me.
> Please take look at the snippet.
>
> protocol P {}
> struct X:P {}
>
> func foo(_ x:A) {}
>
> func bar() {
>//let x = X() // this compiles
>let x = X() as P // this does not compile. Why?
>foo(x)
> }
>
> I expect the both cases to work though. But only first works? And I do
> not understand why.
> My coworkers said that it is a compiler bug, but I'm not shure it is.
> Thanks for the help.
> ___
> 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
>>
>>
>> ___
>> 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
Re: [swift-users] Weird protocol behaviour.
Ok,
But I think I still do not get it.
What does really happen when we write this?
let x = X() as P
As I said, I expect x to be Any after that. If it is, then it should be
ok IMO.
But if it is not then what is the actual type of x?
So the real question is how the type checker works here?
2016-12-25 22:13 GMT+07:00 Slava Pestov :
>
> On Dec 22, 2016, at 4:43 PM, Howard Lovatt via swift-users <
> swift-users@swift.org> wrote:
>
> The following variation works:
>
> protocol P {}
>
> class P1:P {}
>
> class X:P1 {}
>
> func foo(_ x:A) {}
>
> func bar() {
> //let x = X() // this compiles
> let x = X() as P1 // this does not compile. Why?
> foo(x)
> }
>
> Which adds credence to the bug theory.
>
>
> It’s an intentional limitation. Protocols do not conform to themselves.
> Lifting the restriction would be difficult to do efficiently given our
> representation of generics and protocols at runtime.
>
> Slava
>
>
> Note two changes: 1. two levels of inheritance and 2. change to classes.
> If you do two levels using protocols it doesn't work if you use either
> classes or structs.
>
>
> -- Howard.
>
> On 23 December 2016 at 07:29, Kevin Nattinger wrote:
>
>> I recall seeing a request on the -evolution list for something like `T :=
>> X` to indicate it could be X itself or anything inheriting / implementing
>> it, so it’s certainly known behavior, if not desired. IMO it’s a bug and
>> `:` should be fixed to include the root type, whether or not that requires
>> a discussion on -evolution.
>>
>> On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users <
>> swift-users@swift.org> wrote:
>>
>> I suspect a compiler bug since A is a P. The equivalent in Java works:
>>
>> interface P {}
>> class X implements P {}
>>
>> void foo(A x) {}
>>
>> void bar() {
>> final P x = new X();
>> foo(x);
>> }
>>
>> -- Howard.
>>
>> On 23 Dec 2016, at 3:19 am, Rien via swift-users
>> wrote:
>>
>> IMO the error message says it all:
>>
>> Playground execution failed: error: MyPlayground8.playground:9:5: error:
>> cannot invoke 'foo' with an argument list of type '(P)'
>>foo(x)
>>^
>>
>> MyPlayground8.playground:9:5: note: expected an argument list of type
>> '(A)'
>>foo(x)
>>^
>>
>> I.e. you are passing in a protocol while the function is specified for a
>> type.
>> Said other way: On which data do you expect the protocol to operate?
>>
>> Regards,
>> Rien
>>
>> Site: http://balancingrock.nl
>> Blog: http://swiftrien.blogspot.com
>> Github: http://github.com/Swiftrien
>> Project: http://swiftfire.nl
>>
>>
>>
>>
>> On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users <
>> swift-users@swift.org> wrote:
>>
>>
>> Hello community! I' wondering if somebody can explain this to me.
>>
>> Please take look at the snippet.
>>
>>
>> protocol P {}
>>
>> struct X:P {}
>>
>>
>> func foo(_ x:A) {}
>>
>>
>> func bar() {
>>
>>//let x = X() // this compiles
>>
>>let x = X() as P // this does not compile. Why?
>>
>>foo(x)
>>
>> }
>>
>>
>> I expect the both cases to work though. But only first works? And I do
>> not understand why.
>>
>> My coworkers said that it is a compiler bug, but I'm not shure it is.
>>
>> Thanks for the help.
>>
>> ___
>>
>> 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
>>
>>
>>
> ___
> 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
Re: [swift-users] Weird protocol behaviour.
> On Dec 22, 2016, at 4:43 PM, Howard Lovatt via swift-users
> wrote:
>
> The following variation works:
>
> protocol P {}
>
> class P1:P {}
>
> class X:P1 {}
>
> func foo(_ x:A) {}
>
> func bar() {
> //let x = X() // this compiles
> let x = X() as P1 // this does not compile. Why?
> foo(x)
> }
>
> Which adds credence to the bug theory.
It’s an intentional limitation. Protocols do not conform to themselves. Lifting
the restriction would be difficult to do efficiently given our representation
of generics and protocols at runtime.
Slava
>
> Note two changes: 1. two levels of inheritance and 2. change to classes. If
> you do two levels using protocols it doesn't work if you use either classes
> or structs.
>
>
> -- Howard.
>
> On 23 December 2016 at 07:29, Kevin Nattinger > wrote:
> I recall seeing a request on the -evolution list for something like `T := X`
> to indicate it could be X itself or anything inheriting / implementing it, so
> it’s certainly known behavior, if not desired. IMO it’s a bug and `:` should
> be fixed to include the root type, whether or not that requires a discussion
> on -evolution.
>
>> On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users
>> mailto:swift-users@swift.org>> wrote:
>>
>> I suspect a compiler bug since A is a P. The equivalent in Java works:
>>
>> interface P {}
>> class X implements P {}
>>
>> void foo(A x) {}
>>
>> void bar() {
>> final P x = new X();
>> foo(x);
>> }
>>
>> -- Howard.
>>
>> On 23 Dec 2016, at 3:19 am, Rien via swift-users > > wrote:
>>
>>> IMO the error message says it all:
>>>
>>> Playground execution failed: error: MyPlayground8.playground:9:5: error:
>>> cannot invoke 'foo' with an argument list of type '(P)'
>>>foo(x)
>>>^
>>>
>>> MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
>>>foo(x)
>>>^
>>>
>>> I.e. you are passing in a protocol while the function is specified for a
>>> type.
>>> Said other way: On which data do you expect the protocol to operate?
>>>
>>> Regards,
>>> Rien
>>>
>>> Site: http://balancingrock.nl
>>> Project: http://swiftfire.nl
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
>>
>
>
> ___
> 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
Re: [swift-users] Weird protocol behaviour.
My previous theory was wrong.
> P is an existential for x: P = … where it is upgraded to the static P in foo
Why it needs to be upgraded? Why not just use `P` as a protocol instead of
a `type`? Xcode error message calls `P` as a type.
Zhaoxin
On Fri, Dec 23, 2016 at 9:03 PM, Adrian Zubarev <
adrian.zuba...@devandartist.com> wrote:
> I’m not sure what you mean. P is an existential for x: P = … where it is
> upgraded to the static P in foo, but the static P does not conform
> to the existential P, which results in an error described by the OP.
>
> x: P = … here it’s Any any type that conforms to P. Any is a type
> of it’s own, and when existentials will be implemented I’d assume that
> there won’t be any upgrade to P from generic context.
>
> let x: Any = …
>
> foo(x)
> // A == Any which should make foo equivalent to
> // `func foo(_ x: Any)` or the current `func foo(_ x: P)`
>
> Right now we just cannot be explicit about existentials.
>
> Please correct me if I’m wrong. ;)
>
>
>
> --
> Adrian Zubarev
> Sent with Airmail
>
> Am 23. Dezember 2016 um 13:47:18, Zhao Xin (owe...@gmail.com) schrieb:
>
> You mis-labelled you problem in your original email.
>
> let x = X() as P // this does not compile. Why?
> foo(x)
>
> The issue is not in line ` let x = X() as P`. It is in line ` foo(x)`,
> `x's type is P`, but `foo(:)` request a parameter type of `A`, not `P`.
>
> `func foo(_ x:A) {}` means, `x` must be `A`, and `A` conforms `P`.
> But not all `P`s are `A`.
>
> Zhaoxin
>
> On Fri, Dec 23, 2016 at 5:26 PM, Adrian Zubarev via swift-users <
> swift-users@swift.org> wrote:
>
>> Whoops, wait a second. Correcting my self here. Copied the wrong url.
>>
>> Here is the proposal I meant. LINK
>>
>>
>>
>> --
>> Adrian Zubarev
>> Sent with Airmail
>>
>> Am 23. Dezember 2016 um 09:57:49, Adrian Zubarev (
>> adrian.zuba...@devandartist.com) schrieb:
>>
>>
>>-
>>
>>What are you trying to solve here?
>>-
>>
>>Do you heavily rely on what A can be?
>>-
>>
>>Can’t you just write func foo(_ x: P) {} (here P is an *existential*
>>like [in some future] Any)?!
>>-
>>
>>AnyObject is for classes, but you’d get the same result changing X to
>>a class ;)
>>
>> If you want scratch the surface of what happens to protocols in a generic
>> context, you could read our proposal about meta types here
>>
>> .
>>
>>
>> --
>> Adrian Zubarev
>> Sent with Airmail
>>
>> Am 23. Dezember 2016 um 09:43:34, Mikhail Seriukov via swift-users (
>> swift-users@swift.org) schrieb:
>>
>> No it does not.
>>> You have made a type out of the parameter. It’s no longer a protocol.
>>> IMO the failure here is to understand the difference between a type and
>>> a protocol.
>>> A type (even if empty) is always a combination of storage with functions
>>> (that are assumed to work on the data in storage)
>>> A protocol is just a definition of functions without the accompanying
>>> data.
>>>
>>
>> I see your point.
>> But actually when I write it as `let x = X() as P` I really mean that I
>> want `x` to be `AnyObject` but conforming to P, not just protocol itself.
>> Is it even possible to downcast it this way?
>>
>> 2016-12-23 14:51 GMT+07:00 Marinus van der Lugt :
>>
>>>
>>> On 22 Dec 2016, at 22:43, Howard Lovatt wrote:
>>>
>>> The following variation works:
>>>
>>> protocol P {}
>>>
>>> class P1:P {}
>>>
>>> class X:P1 {}
>>>
>>> func foo(_ x:A) {}
>>>
>>> func bar() {
>>> //let x = X() // this compiles
>>> let x = X() as P1 // this does not compile. Why?
>>> foo(x)
>>> }
>>>
>>> Which adds credence to the bug theory.
>>>
>>>
>>>
>>> No it does not.
>>> You have made a type out of the parameter. It’s no longer a protocol.
>>> IMO the failure here is to understand the difference between a type and
>>> a protocol.
>>> A type (even if empty) is always a combination of storage with functions
>>> (that are assumed to work on the data in storage)
>>> A protocol is just a definition of functions without the accompanying
>>> data.
>>>
>>> Rien.
>>>
>>>
>>>
>>>
>>> Note two changes: 1. two levels of inheritance and 2. change to classes.
>>> If you do two levels using protocols it doesn't work if you use either
>>> classes or structs.
>>>
>>>
>>> -- Howard.
>>>
>>> On 23 December 2016 at 07:29, Kevin Nattinger
>>> wrote:
>>>
I recall seeing a request on the -evolution list for something like `T
:= X` to indicate it could be X itself or anything inheriting /
implementing it, so it’s certainly known behavior, if not desired. IMO it’s
a bug and `:` should be fixed to include the root type, whether or not that
requires a discussion on -evolution.
On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-
Re: [swift-users] Weird protocol behaviour.
I’m not sure what you mean. P is an existential for x: P = … where it is
upgraded to the static P in foo, but the static P does not conform to
the existential P, which results in an error described by the OP.
x: P = … here it’s Any any type that conforms to P. Any is a type of it’s
own, and when existentials will be implemented I’d assume that there won’t be
any upgrade to P from generic context.
let x: Any = …
foo(x)
// A == Any which should make foo equivalent to
// `func foo(_ x: Any)` or the current `func foo(_ x: P)`
Right now we just cannot be explicit about existentials.
Please correct me if I’m wrong. ;)
--
Adrian Zubarev
Sent with Airmail
Am 23. Dezember 2016 um 13:47:18, Zhao Xin (owe...@gmail.com) schrieb:
You mis-labelled you problem in your original email.
let x = X() as P // this does not compile. Why?
foo(x)
The issue is not in line ` let x = X() as P`. It is in line ` foo(x)`, `x's
type is P`, but `foo(:)` request a parameter type of `A`, not `P`.
`func foo(_ x:A) {}` means, `x` must be `A`, and `A` conforms `P`. But not
all `P`s are `A`.
Zhaoxin
On Fri, Dec 23, 2016 at 5:26 PM, Adrian Zubarev via swift-users
wrote:
Whoops, wait a second. Correcting my self here. Copied the wrong url.
Here is the proposal I meant. LINK
--
Adrian Zubarev
Sent with Airmail
Am 23. Dezember 2016 um 09:57:49, Adrian Zubarev
(adrian.zuba...@devandartist.com) schrieb:
What are you trying to solve here?
Do you heavily rely on what A can be?
Can’t you just write func foo(_ x: P) {} (here P is an existential like [in
some future] Any)?!
AnyObject is for classes, but you’d get the same result changing X to a class ;)
If you want scratch the surface of what happens to protocols in a generic
context, you could read our proposal about meta types here.
--
Adrian Zubarev
Sent with Airmail
Am 23. Dezember 2016 um 09:43:34, Mikhail Seriukov via swift-users
(swift-users@swift.org) schrieb:
No it does not.
You have made a type out of the parameter. It’s no longer a protocol.
IMO the failure here is to understand the difference between a type and a
protocol.
A type (even if empty) is always a combination of storage with functions (that
are assumed to work on the data in storage)
A protocol is just a definition of functions without the accompanying data.
I see your point.
But actually when I write it as `let x = X() as P` I really mean that I want
`x` to be `AnyObject` but conforming to P, not just protocol itself.
Is it even possible to downcast it this way?
2016-12-23 14:51 GMT+07:00 Marinus van der Lugt :
On 22 Dec 2016, at 22:43, Howard Lovatt wrote:
The following variation works:
protocol P {}
class P1:P {}
class X:P1 {}
func foo(_ x:A) {}
func bar() {
//let x = X() // this compiles
let x = X() as P1 // this does not compile. Why?
foo(x)
}
Which adds credence to the bug theory.
No it does not.
You have made a type out of the parameter. It’s no longer a protocol.
IMO the failure here is to understand the difference between a type and a
protocol.
A type (even if empty) is always a combination of storage with functions (that
are assumed to work on the data in storage)
A protocol is just a definition of functions without the accompanying data.
Rien.
Note two changes: 1. two levels of inheritance and 2. change to classes. If you
do two levels using protocols it doesn't work if you use either classes or
structs.
-- Howard.
On 23 December 2016 at 07:29, Kevin Nattinger wrote:
I recall seeing a request on the -evolution list for something like `T := X` to
indicate it could be X itself or anything inheriting / implementing it, so it’s
certainly known behavior, if not desired. IMO it’s a bug and `:` should be
fixed to include the root type, whether or not that requires a discussion on
-evolution.
On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users
wrote:
I suspect a compiler bug since A is a P. The equivalent in Java works:
interface P {}
class X implements P {}
void foo(A x) {}
void bar() {
final P x = new X();
foo(x);
}
-- Howard.
On 23 Dec 2016, at 3:19 am, Rien via swift-users wrote:
IMO the error message says it all:
Playground execution failed: error: MyPlayground8.playground:9:5: error: cannot
invoke 'foo' with an argument list of type '(P)'
foo(x)
^
MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
foo(x)
^
I.e. you are passing in a protocol while the function is specified for a type.
Said other way: On which data do you expect the protocol to operate?
Regards,
Rien
Site: http://balancingrock.nl
Blog: http://swiftrien.blogspot.com
Github: http://github.com/Swiftrien
Project: http://swiftfire.nl
On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users
wrote:
Hello community! I' wondering if somebody can explain this to me.
Please take look at the snippet.
protocol P {}
struct X:P {}
func foo(_ x:A) {}
func bar() {
//let x = X() // this
Re: [swift-users] Weird protocol behaviour.
You mis-labelled you problem in your original email.
let x = X() as P // this does not compile. Why?
foo(x)
The issue is not in line ` let x = X() as P`. It is in line ` foo(x)`, `x's
type is P`, but `foo(:)` request a parameter type of `A`, not `P`.
`func foo(_ x:A) {}` means, `x` must be `A`, and `A` conforms `P`. But
not all `P`s are `A`.
Zhaoxin
On Fri, Dec 23, 2016 at 5:26 PM, Adrian Zubarev via swift-users <
swift-users@swift.org> wrote:
> Whoops, wait a second. Correcting my self here. Copied the wrong url.
>
> Here is the proposal I meant. LINK
>
>
>
>
> --
> Adrian Zubarev
> Sent with Airmail
>
> Am 23. Dezember 2016 um 09:57:49, Adrian Zubarev (
> adrian.zuba...@devandartist.com) schrieb:
>
>
>-
>
>What are you trying to solve here?
>-
>
>Do you heavily rely on what A can be?
>-
>
>Can’t you just write func foo(_ x: P) {} (here P is an *existential*
>like [in some future] Any)?!
>-
>
>AnyObject is for classes, but you’d get the same result changing X to
>a class ;)
>
> If you want scratch the surface of what happens to protocols in a generic
> context, you could read our proposal about meta types here
>
> .
>
>
> --
> Adrian Zubarev
> Sent with Airmail
>
> Am 23. Dezember 2016 um 09:43:34, Mikhail Seriukov via swift-users (
> swift-users@swift.org) schrieb:
>
> No it does not.
>> You have made a type out of the parameter. It’s no longer a protocol.
>> IMO the failure here is to understand the difference between a type and a
>> protocol.
>> A type (even if empty) is always a combination of storage with functions
>> (that are assumed to work on the data in storage)
>> A protocol is just a definition of functions without the accompanying
>> data.
>>
>
> I see your point.
> But actually when I write it as `let x = X() as P` I really mean that I
> want `x` to be `AnyObject` but conforming to P, not just protocol itself.
> Is it even possible to downcast it this way?
>
> 2016-12-23 14:51 GMT+07:00 Marinus van der Lugt :
>
>>
>> On 22 Dec 2016, at 22:43, Howard Lovatt wrote:
>>
>> The following variation works:
>>
>> protocol P {}
>>
>> class P1:P {}
>>
>> class X:P1 {}
>>
>> func foo(_ x:A) {}
>>
>> func bar() {
>> //let x = X() // this compiles
>> let x = X() as P1 // this does not compile. Why?
>> foo(x)
>> }
>>
>> Which adds credence to the bug theory.
>>
>>
>>
>> No it does not.
>> You have made a type out of the parameter. It’s no longer a protocol.
>> IMO the failure here is to understand the difference between a type and a
>> protocol.
>> A type (even if empty) is always a combination of storage with functions
>> (that are assumed to work on the data in storage)
>> A protocol is just a definition of functions without the accompanying
>> data.
>>
>> Rien.
>>
>>
>>
>>
>> Note two changes: 1. two levels of inheritance and 2. change to classes.
>> If you do two levels using protocols it doesn't work if you use either
>> classes or structs.
>>
>>
>> -- Howard.
>>
>> On 23 December 2016 at 07:29, Kevin Nattinger
>> wrote:
>>
>>> I recall seeing a request on the -evolution list for something like `T
>>> := X` to indicate it could be X itself or anything inheriting /
>>> implementing it, so it’s certainly known behavior, if not desired. IMO it’s
>>> a bug and `:` should be fixed to include the root type, whether or not that
>>> requires a discussion on -evolution.
>>>
>>> On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users <
>>> swift-users@swift.org> wrote:
>>>
>>> I suspect a compiler bug since A is a P. The equivalent in Java works:
>>>
>>> interface P {}
>>> class X implements P {}
>>>
>>> void foo(A x) {}
>>>
>>> void bar() {
>>> final P x = new X();
>>> foo(x);
>>> }
>>>
>>> -- Howard.
>>>
>>> On 23 Dec 2016, at 3:19 am, Rien via swift-users
>>> wrote:
>>>
>>> IMO the error message says it all:
>>>
>>> Playground execution failed: error: MyPlayground8.playground:9:5: error:
>>> cannot invoke 'foo' with an argument list of type '(P)'
>>>foo(x)
>>>^
>>>
>>> MyPlayground8.playground:9:5: note: expected an argument list of type
>>> '(A)'
>>>foo(x)
>>>^
>>>
>>> I.e. you are passing in a protocol while the function is specified for a
>>> type.
>>> Said other way: On which data do you expect the protocol to operate?
>>>
>>> Regards,
>>> Rien
>>>
>>> Site: http://balancingrock.nl
>>> Blog: http://swiftrien.blogspot.com
>>> Github: http://github.com/Swiftrien
>>> Project: http://swiftfire.nl
>>>
>>>
>>>
>>>
>>> On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users <
>>> swift-users@swift.org> wrote:
>>>
>>>
>>> Hello community! I' wondering if somebody can explain this to me.
>>>
>>> Please take look at the snippet.
>>>
Re: [swift-users] Weird protocol behaviour.
Whoops, wait a second. Correcting my self here. Copied the wrong url.
Here is the proposal I meant. LINK
--
Adrian Zubarev
Sent with Airmail
Am 23. Dezember 2016 um 09:57:49, Adrian Zubarev
(adrian.zuba...@devandartist.com) schrieb:
What are you trying to solve here?
Do you heavily rely on what A can be?
Can’t you just write func foo(_ x: P) {} (here P is an existential like [in
some future] Any)?!
AnyObject is for classes, but you’d get the same result changing X to a class ;)
If you want scratch the surface of what happens to protocols in a generic
context, you could read our proposal about meta types here.
--
Adrian Zubarev
Sent with Airmail
Am 23. Dezember 2016 um 09:43:34, Mikhail Seriukov via swift-users
(swift-users@swift.org) schrieb:
No it does not.
You have made a type out of the parameter. It’s no longer a protocol.
IMO the failure here is to understand the difference between a type and a
protocol.
A type (even if empty) is always a combination of storage with functions (that
are assumed to work on the data in storage)
A protocol is just a definition of functions without the accompanying data.
I see your point.
But actually when I write it as `let x = X() as P` I really mean that I want
`x` to be `AnyObject` but conforming to P, not just protocol itself.
Is it even possible to downcast it this way?
2016-12-23 14:51 GMT+07:00 Marinus van der Lugt :
On 22 Dec 2016, at 22:43, Howard Lovatt wrote:
The following variation works:
protocol P {}
class P1:P {}
class X:P1 {}
func foo(_ x:A) {}
func bar() {
//let x = X() // this compiles
let x = X() as P1 // this does not compile. Why?
foo(x)
}
Which adds credence to the bug theory.
No it does not.
You have made a type out of the parameter. It’s no longer a protocol.
IMO the failure here is to understand the difference between a type and a
protocol.
A type (even if empty) is always a combination of storage with functions (that
are assumed to work on the data in storage)
A protocol is just a definition of functions without the accompanying data.
Rien.
Note two changes: 1. two levels of inheritance and 2. change to classes. If you
do two levels using protocols it doesn't work if you use either classes or
structs.
-- Howard.
On 23 December 2016 at 07:29, Kevin Nattinger wrote:
I recall seeing a request on the -evolution list for something like `T := X` to
indicate it could be X itself or anything inheriting / implementing it, so it’s
certainly known behavior, if not desired. IMO it’s a bug and `:` should be
fixed to include the root type, whether or not that requires a discussion on
-evolution.
On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users
wrote:
I suspect a compiler bug since A is a P. The equivalent in Java works:
interface P {}
class X implements P {}
void foo(A x) {}
void bar() {
final P x = new X();
foo(x);
}
-- Howard.
On 23 Dec 2016, at 3:19 am, Rien via swift-users wrote:
IMO the error message says it all:
Playground execution failed: error: MyPlayground8.playground:9:5: error: cannot
invoke 'foo' with an argument list of type '(P)'
foo(x)
^
MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
foo(x)
^
I.e. you are passing in a protocol while the function is specified for a type.
Said other way: On which data do you expect the protocol to operate?
Regards,
Rien
Site: http://balancingrock.nl
Blog: http://swiftrien.blogspot.com
Github: http://github.com/Swiftrien
Project: http://swiftfire.nl
On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users
wrote:
Hello community! I' wondering if somebody can explain this to me.
Please take look at the snippet.
protocol P {}
struct X:P {}
func foo(_ x:A) {}
func bar() {
//let x = X() // this compiles
let x = X() as P // this does not compile. Why?
foo(x)
}
I expect the both cases to work though. But only first works? And I do not
understand why.
My coworkers said that it is a compiler bug, but I'm not shure it is.
Thanks for the help.
___
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
___
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
Re: [swift-users] Weird protocol behaviour.
I assume when we get existentials, your problem could be solved like this:
protocol P {}
class X: P {}
func foo(_ x:A) {}
func bar() {
let x = X() as Any
foo(x)
}
Here A will be Any which conforms to P and makes the compiler happy.
let c: P = … here is P and existential like (future) Any.
x as P here is P used as a type.
It’s weird that the latter is a type but the first example is an existential. I
think this is a design choice, because we almost never need the protocol as a
type.
--
Adrian Zubarev
Sent with Airmail
Am 23. Dezember 2016 um 09:57:49, Adrian Zubarev
(adrian.zuba...@devandartist.com) schrieb:
What are you trying to solve here?
Do you heavily rely on what A can be?
Can’t you just write func foo(_ x: P) {} (here P is an existential like [in
some future] Any)?!
AnyObject is for classes, but you’d get the same result changing X to a class ;)
If you want scratch the surface of what happens to protocols in a generic
context, you could read our proposal about meta types here.
--
Adrian Zubarev
Sent with Airmail
Am 23. Dezember 2016 um 09:43:34, Mikhail Seriukov via swift-users
(swift-users@swift.org) schrieb:
No it does not.
You have made a type out of the parameter. It’s no longer a protocol.
IMO the failure here is to understand the difference between a type and a
protocol.
A type (even if empty) is always a combination of storage with functions (that
are assumed to work on the data in storage)
A protocol is just a definition of functions without the accompanying data.
I see your point.
But actually when I write it as `let x = X() as P` I really mean that I want
`x` to be `AnyObject` but conforming to P, not just protocol itself.
Is it even possible to downcast it this way?
2016-12-23 14:51 GMT+07:00 Marinus van der Lugt :
On 22 Dec 2016, at 22:43, Howard Lovatt wrote:
The following variation works:
protocol P {}
class P1:P {}
class X:P1 {}
func foo(_ x:A) {}
func bar() {
//let x = X() // this compiles
let x = X() as P1 // this does not compile. Why?
foo(x)
}
Which adds credence to the bug theory.
No it does not.
You have made a type out of the parameter. It’s no longer a protocol.
IMO the failure here is to understand the difference between a type and a
protocol.
A type (even if empty) is always a combination of storage with functions (that
are assumed to work on the data in storage)
A protocol is just a definition of functions without the accompanying data.
Rien.
Note two changes: 1. two levels of inheritance and 2. change to classes. If you
do two levels using protocols it doesn't work if you use either classes or
structs.
-- Howard.
On 23 December 2016 at 07:29, Kevin Nattinger wrote:
I recall seeing a request on the -evolution list for something like `T := X` to
indicate it could be X itself or anything inheriting / implementing it, so it’s
certainly known behavior, if not desired. IMO it’s a bug and `:` should be
fixed to include the root type, whether or not that requires a discussion on
-evolution.
On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users
wrote:
I suspect a compiler bug since A is a P. The equivalent in Java works:
interface P {}
class X implements P {}
void foo(A x) {}
void bar() {
final P x = new X();
foo(x);
}
-- Howard.
On 23 Dec 2016, at 3:19 am, Rien via swift-users wrote:
IMO the error message says it all:
Playground execution failed: error: MyPlayground8.playground:9:5: error: cannot
invoke 'foo' with an argument list of type '(P)'
foo(x)
^
MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
foo(x)
^
I.e. you are passing in a protocol while the function is specified for a type.
Said other way: On which data do you expect the protocol to operate?
Regards,
Rien
Site: http://balancingrock.nl
Blog: http://swiftrien.blogspot.com
Github: http://github.com/Swiftrien
Project: http://swiftfire.nl
On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users
wrote:
Hello community! I' wondering if somebody can explain this to me.
Please take look at the snippet.
protocol P {}
struct X:P {}
func foo(_ x:A) {}
func bar() {
//let x = X() // this compiles
let x = X() as P // this does not compile. Why?
foo(x)
}
I expect the both cases to work though. But only first works? And I do not
understand why.
My coworkers said that it is a compiler bug, but I'm not shure it is.
Thanks for the help.
___
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
___
swift-users mailing list
swift-users@
Re: [swift-users] Weird protocol behaviour.
Sorry, should have taken the comments out of the example, they obviously have
no meaning anymore.
Regards,
Rien
Site: http://balancingrock.nl
Blog: http://swiftrien.blogspot.com
Github: http://github.com/Swiftrien
Project: http://swiftfire.nl
> On 23 Dec 2016, at 10:03, Rien wrote:
>
>
>> On 23 Dec 2016, at 09:43, Mikhail Seriukov wrote:
>>
>> No it does not.
>> You have made a type out of the parameter. It’s no longer a protocol.
>> IMO the failure here is to understand the difference between a type and a
>> protocol.
>> A type (even if empty) is always a combination of storage with functions
>> (that are assumed to work on the data in storage)
>> A protocol is just a definition of functions without the accompanying data.
>>
>> I see your point.
>> But actually when I write it as `let x = X() as P` I really mean that I
>> want `x` to be `AnyObject` but conforming to P, not just protocol itself.
>> Is it even possible to downcast it this way?
>
> Yes, but only for a destination that needs a protocol. Not for a destination
> that needs a type.
>
> I.e. in the example
>
> protocol P {}
> struct X:P {}
>
> func foo(_ x:A) {}
>
> func bar(_ x:P) {}
>
> func bar() {
>var p: P
>//let x = X() // this compiles
>let x = X() as P // this does not compile. Why?
>p = x
>bar(p)
> }
>
> Regards,
> Rien.
>
>>
>> 2016-12-23 14:51 GMT+07:00 Marinus van der Lugt :
>>
>>> On 22 Dec 2016, at 22:43, Howard Lovatt wrote:
>>>
>>> The following variation works:
>>>
>>> protocol P {}
>>>
>>> class P1:P {}
>>>
>>> class X:P1 {}
>>>
>>> func foo(_ x:A) {}
>>>
>>> func bar() {
>>>//let x = X() // this compiles
>>>let x = X() as P1 // this does not compile. Why?
>>>foo(x)
>>> }
>>>
>>> Which adds credence to the bug theory.
>>
>>
>> No it does not.
>> You have made a type out of the parameter. It’s no longer a protocol.
>> IMO the failure here is to understand the difference between a type and a
>> protocol.
>> A type (even if empty) is always a combination of storage with functions
>> (that are assumed to work on the data in storage)
>> A protocol is just a definition of functions without the accompanying data.
>>
>> Rien.
>>
>>
>>
>>>
>>> Note two changes: 1. two levels of inheritance and 2. change to classes. If
>>> you do two levels using protocols it doesn't work if you use either classes
>>> or structs.
>>>
>>>
>>> -- Howard.
>>>
>>> On 23 December 2016 at 07:29, Kevin Nattinger wrote:
>>> I recall seeing a request on the -evolution list for something like `T :=
>>> X` to indicate it could be X itself or anything inheriting / implementing
>>> it, so it’s certainly known behavior, if not desired. IMO it’s a bug and
>>> `:` should be fixed to include the root type, whether or not that requires
>>> a discussion on -evolution.
>>>
On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users
wrote:
I suspect a compiler bug since A is a P. The equivalent in Java works:
interface P {}
class X implements P {}
void foo(A x) {}
void bar() {
final P x = new X();
foo(x);
}
-- Howard.
On 23 Dec 2016, at 3:19 am, Rien via swift-users
wrote:
> IMO the error message says it all:
>
> Playground execution failed: error: MyPlayground8.playground:9:5: error:
> cannot invoke 'foo' with an argument list of type '(P)'
> foo(x)
> ^
>
> MyPlayground8.playground:9:5: note: expected an argument list of type
> '(A)'
> foo(x)
> ^
>
> I.e. you are passing in a protocol while the function is specified for a
> type.
> Said other way: On which data do you expect the protocol to operate?
>
> Regards,
> Rien
>
> Site: http://balancingrock.nl
> Blog: http://swiftrien.blogspot.com
> Github: http://github.com/Swiftrien
> Project: http://swiftfire.nl
>
>
>
>
>> On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users
>> wrote:
>>
>> Hello community! I' wondering if somebody can explain this to me.
>> Please take look at the snippet.
>>
>> protocol P {}
>> struct X:P {}
>>
>> func foo(_ x:A) {}
>>
>> func bar() {
>> //let x = X() // this compiles
>> let x = X() as P // this does not compile. Why?
>> foo(x)
>> }
>>
>> I expect the both cases to work though. But only first works? And I do
>> not understand why.
>> My coworkers said that it is a compiler bug, but I'm not shure it is.
>> Thanks for the help.
>> ___
>> 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/
Re: [swift-users] Weird protocol behaviour.
> On 23 Dec 2016, at 09:43, Mikhail Seriukov wrote:
>
> No it does not.
> You have made a type out of the parameter. It’s no longer a protocol.
> IMO the failure here is to understand the difference between a type and a
> protocol.
> A type (even if empty) is always a combination of storage with functions
> (that are assumed to work on the data in storage)
> A protocol is just a definition of functions without the accompanying data.
>
> I see your point.
> But actually when I write it as `let x = X() as P` I really mean that I want
> `x` to be `AnyObject` but conforming to P, not just protocol itself.
> Is it even possible to downcast it this way?
Yes, but only for a destination that needs a protocol. Not for a destination
that needs a type.
I.e. in the example
protocol P {}
struct X:P {}
func foo(_ x:A) {}
func bar(_ x:P) {}
func bar() {
var p: P
//let x = X() // this compiles
let x = X() as P // this does not compile. Why?
p = x
bar(p)
}
Regards,
Rien.
>
> 2016-12-23 14:51 GMT+07:00 Marinus van der Lugt :
>
>> On 22 Dec 2016, at 22:43, Howard Lovatt wrote:
>>
>> The following variation works:
>>
>> protocol P {}
>>
>> class P1:P {}
>>
>> class X:P1 {}
>>
>> func foo(_ x:A) {}
>>
>> func bar() {
>> //let x = X() // this compiles
>> let x = X() as P1 // this does not compile. Why?
>> foo(x)
>> }
>>
>> Which adds credence to the bug theory.
>
>
> No it does not.
> You have made a type out of the parameter. It’s no longer a protocol.
> IMO the failure here is to understand the difference between a type and a
> protocol.
> A type (even if empty) is always a combination of storage with functions
> (that are assumed to work on the data in storage)
> A protocol is just a definition of functions without the accompanying data.
>
> Rien.
>
>
>
>>
>> Note two changes: 1. two levels of inheritance and 2. change to classes. If
>> you do two levels using protocols it doesn't work if you use either classes
>> or structs.
>>
>>
>> -- Howard.
>>
>> On 23 December 2016 at 07:29, Kevin Nattinger wrote:
>> I recall seeing a request on the -evolution list for something like `T := X`
>> to indicate it could be X itself or anything inheriting / implementing it,
>> so it’s certainly known behavior, if not desired. IMO it’s a bug and `:`
>> should be fixed to include the root type, whether or not that requires a
>> discussion on -evolution.
>>
>>> On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users
>>> wrote:
>>>
>>> I suspect a compiler bug since A is a P. The equivalent in Java works:
>>>
>>> interface P {}
>>> class X implements P {}
>>>
>>> void foo(A x) {}
>>>
>>> void bar() {
>>> final P x = new X();
>>> foo(x);
>>> }
>>>
>>> -- Howard.
>>>
>>> On 23 Dec 2016, at 3:19 am, Rien via swift-users
>>> wrote:
>>>
IMO the error message says it all:
Playground execution failed: error: MyPlayground8.playground:9:5: error:
cannot invoke 'foo' with an argument list of type '(P)'
foo(x)
^
MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
foo(x)
^
I.e. you are passing in a protocol while the function is specified for a
type.
Said other way: On which data do you expect the protocol to operate?
Regards,
Rien
Site: http://balancingrock.nl
Blog: http://swiftrien.blogspot.com
Github: http://github.com/Swiftrien
Project: http://swiftfire.nl
> On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users
> wrote:
>
> Hello community! I' wondering if somebody can explain this to me.
> Please take look at the snippet.
>
> protocol P {}
> struct X:P {}
>
> func foo(_ x:A) {}
>
> func bar() {
>//let x = X() // this compiles
>let x = X() as P // this does not compile. Why?
>foo(x)
> }
>
> I expect the both cases to work though. But only first works? And I do
> not understand why.
> My coworkers said that it is a compiler bug, but I'm not shure it is.
> Thanks for the help.
> ___
> 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
>>
>>
>
>
___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users
Re: [swift-users] Weird protocol behaviour.
What are you trying to solve here?
Do you heavily rely on what A can be?
Can’t you just write func foo(_ x: P) {} (here P is an existential like [in
some future] Any)?!
AnyObject is for classes, but you’d get the same result changing X to a class ;)
If you want scratch the surface of what happens to protocols in a generic
context, you could read our proposal about meta types here.
--
Adrian Zubarev
Sent with Airmail
Am 23. Dezember 2016 um 09:43:34, Mikhail Seriukov via swift-users
(swift-users@swift.org) schrieb:
No it does not.
You have made a type out of the parameter. It’s no longer a protocol.
IMO the failure here is to understand the difference between a type and a
protocol.
A type (even if empty) is always a combination of storage with functions (that
are assumed to work on the data in storage)
A protocol is just a definition of functions without the accompanying data.
I see your point.
But actually when I write it as `let x = X() as P` I really mean that I want
`x` to be `AnyObject` but conforming to P, not just protocol itself.
Is it even possible to downcast it this way?
2016-12-23 14:51 GMT+07:00 Marinus van der Lugt :
On 22 Dec 2016, at 22:43, Howard Lovatt wrote:
The following variation works:
protocol P {}
class P1:P {}
class X:P1 {}
func foo(_ x:A) {}
func bar() {
//let x = X() // this compiles
let x = X() as P1 // this does not compile. Why?
foo(x)
}
Which adds credence to the bug theory.
No it does not.
You have made a type out of the parameter. It’s no longer a protocol.
IMO the failure here is to understand the difference between a type and a
protocol.
A type (even if empty) is always a combination of storage with functions (that
are assumed to work on the data in storage)
A protocol is just a definition of functions without the accompanying data.
Rien.
Note two changes: 1. two levels of inheritance and 2. change to classes. If you
do two levels using protocols it doesn't work if you use either classes or
structs.
-- Howard.
On 23 December 2016 at 07:29, Kevin Nattinger wrote:
I recall seeing a request on the -evolution list for something like `T := X` to
indicate it could be X itself or anything inheriting / implementing it, so it’s
certainly known behavior, if not desired. IMO it’s a bug and `:` should be
fixed to include the root type, whether or not that requires a discussion on
-evolution.
On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users
wrote:
I suspect a compiler bug since A is a P. The equivalent in Java works:
interface P {}
class X implements P {}
void foo(A x) {}
void bar() {
final P x = new X();
foo(x);
}
-- Howard.
On 23 Dec 2016, at 3:19 am, Rien via swift-users wrote:
IMO the error message says it all:
Playground execution failed: error: MyPlayground8.playground:9:5: error: cannot
invoke 'foo' with an argument list of type '(P)'
foo(x)
^
MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
foo(x)
^
I.e. you are passing in a protocol while the function is specified for a type.
Said other way: On which data do you expect the protocol to operate?
Regards,
Rien
Site: http://balancingrock.nl
Blog: http://swiftrien.blogspot.com
Github: http://github.com/Swiftrien
Project: http://swiftfire.nl
On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users
wrote:
Hello community! I' wondering if somebody can explain this to me.
Please take look at the snippet.
protocol P {}
struct X:P {}
func foo(_ x:A) {}
func bar() {
//let x = X() // this compiles
let x = X() as P // this does not compile. Why?
foo(x)
}
I expect the both cases to work though. But only first works? And I do not
understand why.
My coworkers said that it is a compiler bug, but I'm not shure it is.
Thanks for the help.
___
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
___
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
Re: [swift-users] Weird protocol behaviour.
>
> No it does not.
> You have made a type out of the parameter. It’s no longer a protocol.
> IMO the failure here is to understand the difference between a type and a
> protocol.
> A type (even if empty) is always a combination of storage with functions
> (that are assumed to work on the data in storage)
> A protocol is just a definition of functions without the accompanying data.
>
I see your point.
But actually when I write it as `let x = X() as P` I really mean that I
want `x` to be `AnyObject` but conforming to P, not just protocol itself.
Is it even possible to downcast it this way?
2016-12-23 14:51 GMT+07:00 Marinus van der Lugt :
>
> On 22 Dec 2016, at 22:43, Howard Lovatt wrote:
>
> The following variation works:
>
> protocol P {}
>
> class P1:P {}
>
> class X:P1 {}
>
> func foo(_ x:A) {}
>
> func bar() {
> //let x = X() // this compiles
> let x = X() as P1 // this does not compile. Why?
> foo(x)
> }
>
> Which adds credence to the bug theory.
>
>
>
> No it does not.
> You have made a type out of the parameter. It’s no longer a protocol.
> IMO the failure here is to understand the difference between a type and a
> protocol.
> A type (even if empty) is always a combination of storage with functions
> (that are assumed to work on the data in storage)
> A protocol is just a definition of functions without the accompanying data.
>
> Rien.
>
>
>
>
> Note two changes: 1. two levels of inheritance and 2. change to classes.
> If you do two levels using protocols it doesn't work if you use either
> classes or structs.
>
>
> -- Howard.
>
> On 23 December 2016 at 07:29, Kevin Nattinger wrote:
>
>> I recall seeing a request on the -evolution list for something like `T :=
>> X` to indicate it could be X itself or anything inheriting / implementing
>> it, so it’s certainly known behavior, if not desired. IMO it’s a bug and
>> `:` should be fixed to include the root type, whether or not that requires
>> a discussion on -evolution.
>>
>> On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users <
>> swift-users@swift.org> wrote:
>>
>> I suspect a compiler bug since A is a P. The equivalent in Java works:
>>
>> interface P {}
>> class X implements P {}
>>
>> void foo(A x) {}
>>
>> void bar() {
>> final P x = new X();
>> foo(x);
>> }
>>
>> -- Howard.
>>
>> On 23 Dec 2016, at 3:19 am, Rien via swift-users
>> wrote:
>>
>> IMO the error message says it all:
>>
>> Playground execution failed: error: MyPlayground8.playground:9:5: error:
>> cannot invoke 'foo' with an argument list of type '(P)'
>>foo(x)
>>^
>>
>> MyPlayground8.playground:9:5: note: expected an argument list of type
>> '(A)'
>>foo(x)
>>^
>>
>> I.e. you are passing in a protocol while the function is specified for a
>> type.
>> Said other way: On which data do you expect the protocol to operate?
>>
>> Regards,
>> Rien
>>
>> Site: http://balancingrock.nl
>> Blog: http://swiftrien.blogspot.com
>> Github: http://github.com/Swiftrien
>> Project: http://swiftfire.nl
>>
>>
>>
>>
>> On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users <
>> swift-users@swift.org> wrote:
>>
>>
>> Hello community! I' wondering if somebody can explain this to me.
>>
>> Please take look at the snippet.
>>
>>
>> protocol P {}
>>
>> struct X:P {}
>>
>>
>> func foo(_ x:A) {}
>>
>>
>> func bar() {
>>
>>//let x = X() // this compiles
>>
>>let x = X() as P // this does not compile. Why?
>>
>>foo(x)
>>
>> }
>>
>>
>> I expect the both cases to work though. But only first works? And I do
>> not understand why.
>>
>> My coworkers said that it is a compiler bug, but I'm not shure it is.
>>
>> Thanks for the help.
>>
>> ___
>>
>> 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
>>
>>
>>
>
>
___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users
Re: [swift-users] Weird protocol behaviour.
on Thu Dec 22 2016, Mikhail Seriukov wrote:
> Hello community! I' wondering if somebody can explain this to me.
> Please take look at the snippet.
>
> protocol P {}
> struct X:P {}
>
> func foo(_ x:A) {}
>
> func bar() {
> //let x = X() // this compiles
> let x = X() as P // this does not compile. Why?
> foo(x)
> }
It's not a bug, exactly. In Swift we have the bizarre situation that P
(when used as a type) doesn't conform to P (when used as a generic
constraint). Doug can probably tell us if there's a good reason for
that or if it's just a temporary limitation. Doug?
--
-Dave
___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users
Re: [swift-users] Weird protocol behaviour.
The function foo(x: A){} requires a type which conforms to protocol P.
An existential of protocol P does not actually conform to protocol P.
It’s always been a limitation in Swift: https://bugs.swift.org/browse/SR-55
If the function’s signature were foo(x: P){}, it would work.
Howard’s example swaps the protocol P for a concrete type (P1), which is what
makes it work.
Cheers,
Guillaume Lessard
___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users
Re: [swift-users] Weird protocol behaviour.
The following variation works:
protocol P {}
class P1:P {}
class X:P1 {}
func foo(_ x:A) {}
func bar() {
//let x = X() // this compiles
let x = X() as P1 // this does not compile. Why?
foo(x)
}
Which adds credence to the bug theory.
Note two changes: 1. two levels of inheritance and 2. change to classes. If
you do two levels using protocols it doesn't work if you use either classes
or structs.
-- Howard.
On 23 December 2016 at 07:29, Kevin Nattinger wrote:
> I recall seeing a request on the -evolution list for something like `T :=
> X` to indicate it could be X itself or anything inheriting / implementing
> it, so it’s certainly known behavior, if not desired. IMO it’s a bug and
> `:` should be fixed to include the root type, whether or not that requires
> a discussion on -evolution.
>
> On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users <
> swift-users@swift.org> wrote:
>
> I suspect a compiler bug since A is a P. The equivalent in Java works:
>
> interface P {}
> class X implements P {}
>
>
> void foo(A x) {}
>
>
> void bar() {
> final P x = new X();
> foo(x);
> }
>
> -- Howard.
>
> On 23 Dec 2016, at 3:19 am, Rien via swift-users
> wrote:
>
> IMO the error message says it all:
>
> Playground execution failed: error: MyPlayground8.playground:9:5: error:
> cannot invoke 'foo' with an argument list of type '(P)'
>foo(x)
>^
>
> MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
>foo(x)
>^
>
> I.e. you are passing in a protocol while the function is specified for a
> type.
> Said other way: On which data do you expect the protocol to operate?
>
> Regards,
> Rien
>
> Site: http://balancingrock.nl
> Blog: http://swiftrien.blogspot.com
> Github: http://github.com/Swiftrien
> Project: http://swiftfire.nl
>
>
>
>
> On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users <
> swift-users@swift.org> wrote:
>
>
> Hello community! I' wondering if somebody can explain this to me.
>
> Please take look at the snippet.
>
>
> protocol P {}
>
> struct X:P {}
>
>
> func foo(_ x:A) {}
>
>
> func bar() {
>
>//let x = X() // this compiles
>
>let x = X() as P // this does not compile. Why?
>
>foo(x)
>
> }
>
>
> I expect the both cases to work though. But only first works? And I do not
> understand why.
>
> My coworkers said that it is a compiler bug, but I'm not shure it is.
>
> Thanks for the help.
>
> ___
>
> 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
>
>
>
___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users
Re: [swift-users] Weird protocol behaviour.
I recall seeing a request on the -evolution list for something like `T := X` to
indicate it could be X itself or anything inheriting / implementing it, so it’s
certainly known behavior, if not desired. IMO it’s a bug and `:` should be
fixed to include the root type, whether or not that requires a discussion on
-evolution.
> On Dec 22, 2016, at 2:17 PM, Howard Lovatt via swift-users
> wrote:
>
> I suspect a compiler bug since A is a P. The equivalent in Java works:
>
> interface P {}
> class X implements P {}
>
> void foo(A x) {}
>
> void bar() {
> final P x = new X();
> foo(x);
> }
>
> -- Howard.
>
> On 23 Dec 2016, at 3:19 am, Rien via swift-users > wrote:
>
>> IMO the error message says it all:
>>
>> Playground execution failed: error: MyPlayground8.playground:9:5: error:
>> cannot invoke 'foo' with an argument list of type '(P)'
>>foo(x)
>>^
>>
>> MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
>>foo(x)
>>^
>>
>> I.e. you are passing in a protocol while the function is specified for a
>> type.
>> Said other way: On which data do you expect the protocol to operate?
>>
>> Regards,
>> Rien
>>
>> Site: http://balancingrock.nl
>> Project: http://swiftfire.nl
>>> 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
___
swift-users mailing list
swift-users@swift.org
https://lists.swift.org/mailman/listinfo/swift-users
Re: [swift-users] Weird protocol behaviour.
I suspect a compiler bug since A is a P. The equivalent in Java works:
interface P {}
class X implements P {}
void foo(A x) {}
void bar() {
final P x = new X();
foo(x);
}
-- Howard.
> On 23 Dec 2016, at 3:19 am, Rien via swift-users
> wrote:
>
> IMO the error message says it all:
>
> Playground execution failed: error: MyPlayground8.playground:9:5: error:
> cannot invoke 'foo' with an argument list of type '(P)'
>foo(x)
>^
>
> MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
>foo(x)
>^
>
> I.e. you are passing in a protocol while the function is specified for a type.
> Said other way: On which data do you expect the protocol to operate?
>
> Regards,
> Rien
>
> Site: http://balancingrock.nl
> Blog: http://swiftrien.blogspot.com
> Github: http://github.com/Swiftrien
> Project: http://swiftfire.nl
>
>
>
>
>> On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users
>> wrote:
>>
>> Hello community! I' wondering if somebody can explain this to me.
>> Please take look at the snippet.
>>
>> protocol P {}
>> struct X:P {}
>>
>> func foo(_ x:A) {}
>>
>> func bar() {
>>//let x = X() // this compiles
>>let x = X() as P // this does not compile. Why?
>>foo(x)
>> }
>>
>> I expect the both cases to work though. But only first works? And I do not
>> understand why.
>> My coworkers said that it is a compiler bug, but I'm not shure it is.
>> Thanks for the help.
>> ___
>> 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
Re: [swift-users] Weird protocol behaviour.
IMO the error message says it all:
Playground execution failed: error: MyPlayground8.playground:9:5: error: cannot
invoke 'foo' with an argument list of type '(P)'
foo(x)
^
MyPlayground8.playground:9:5: note: expected an argument list of type '(A)'
foo(x)
^
I.e. you are passing in a protocol while the function is specified for a type.
Said other way: On which data do you expect the protocol to operate?
Regards,
Rien
Site: http://balancingrock.nl
Blog: http://swiftrien.blogspot.com
Github: http://github.com/Swiftrien
Project: http://swiftfire.nl
> On 22 Dec 2016, at 17:05, Mikhail Seriukov via swift-users
> wrote:
>
> Hello community! I' wondering if somebody can explain this to me.
> Please take look at the snippet.
>
> protocol P {}
> struct X:P {}
>
> func foo(_ x:A) {}
>
> func bar() {
> //let x = X() // this compiles
> let x = X() as P // this does not compile. Why?
> foo(x)
> }
>
> I expect the both cases to work though. But only first works? And I do not
> understand why.
> My coworkers said that it is a compiler bug, but I'm not shure it is.
> Thanks for the help.
> ___
> 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
