Is there a reason the team wants to do synthesis instead of other options? If that’s no longer assignment, it’s going to break a lot of code.
Sent from my iPhone > On Dec 23, 2017, at 1:19 PM, Dave Abrahams <dabrah...@apple.com> wrote: > > > > Sent from my iPhone > >> On Dec 21, 2017, at 2:33 PM, Ethan Diamond <ethan.j.diam...@gmail.com> wrote: >> >> >>> On Dec 21, 2017, at 10:59 AM, Dave Abrahams <dabrah...@apple.com> wrote: >>> >>> >>> >>>> On Dec 21, 2017, at 10:19 AM, Ethan Diamond <ethanjdiam...@gmail.com> >>>> wrote: >>>> >>>> Just to clarify, Dave - >>>> >>>> What happens there if one case has associated values >>> >>>> and one has an associated value thats an optional? >>>> >>>> Enum A { >>>> case x(String?) >>>> case y >>>> } >>>> >>>> let a = A.x(nil) >>> >>> A.x is String?? >> >> This was assigning .x to a, not evaluating a synthesized value > > And I was making an assertion, not asking a question 😉 >> >>> >>>> a.y // What's the result? >>> >>> nil as Optional<Void> >>> >>>> a.x // Would produce a double optional, which are clumsy to nil check >>> >>> They’re a fact of life. If that’s a problem, we should consider fixing it, >>> but it’s orthogonal to this one. >>> >>>> >>>> I'm not a fan of solving this via synthesis in general. We have metatypes >>>> for classes/structs/protocols, which are useful in all sorts of >>>> situations. Cases are essentially "types" of enums. Why not have case >>>> metatypes? They're useful for the same reasons class types are, and >>>> there's already precedence in the language for syntax. >>> >>> You mean “precedent?” OK, but I don’t see how it helps with any of the >>> same problems as synthesized properties for cases do. >>> >> >> I’m not really sure what the problems synthesized properties are trying to >> solve are. Chris brought them up as a possible solution to my pain point, >> which they only solve partially. Checking for a case I don’t know up front >> (for example, comparing the cases of two values) still isn’t covered. >> >>>> >>>> >>>> >>>>> On Thu, Dec 21, 2017 at 7:14 AM Dave Abrahams <dabrah...@apple.com> wrote: >>>>> IIRC what we discussed was synthesizing members of type >>>>> Optional<Payload> which could then be checked against nil. >>>>> >>>>> if _ = x.failure { ... } >>>>> if x.failure != nil { ... } >>>>> if let r = x.success {...} >>>>> >>>>> IMO synthesizing predicates would be a huge missed opportunity by >>>>> comparison >>>>> >>>>> Sent from my iPhone >>>>> >>>>>> On Dec 20, 2017, at 1:31 PM, Chris Lattner via swift-evolution >>>>>> <swift-evolution@swift.org> wrote: >>>>>> >>>>>> In the past, we’ve discussed synthesizing predicate members onto enums. >>>>>> E.g. given: >>>>>> >>>>>> enum E { >>>>>> case X >>>>>> case Y(Int) >>>>>> } >>>>>> >>>>>> you’d get something like: >>>>>> >>>>>> extension E { >>>>>> func isX() -> Bool { return self == .X } >>>>>> func getY() -> Int? { … } >>>>>> } >>>>>> >>>>>> which would solve the client side of this nicely. >>>>>> >>>>>> -Chris >>>>>> >>>>>> >>>>>> >>>>>>> On Dec 20, 2017, at 11:24 AM, Ethan Diamond via swift-evolution >>>>>>> <swift-evolution@swift.org> wrote: >>>>>>> >>>>>>> Sorry all for attaching the original post to the Non-Exhaustive enums >>>>>>> thread. I"m moving it down to it's own thread. >>>>>>> >>>>>>> My understanding is I'm not allowed to write up a proposal unless I >>>>>>> have the time to implement it. Is that still true? This is a major pain >>>>>>> point for me to avoid having to write things like this: >>>>>>> >>>>>>> if case .search = presenter.state { return true } else { return false } >>>>>>> >>>>>>> Side note: Thanks Kevin, didn't know you could nest enums in switches >>>>>>> like that. Super helpful! >>>>>>> >>>>>>> ------------------------------------------------------ >>>>>>> I thought I would add another case that isn’t possible with current >>>>>>> syntax (so far as I’m aware). You can’t negate the comparison to do >>>>>>> something for all cases except a particular case. You have to have an >>>>>>> empty if block and use the else block, or have an empty case in a >>>>>>> switch statement and use the default. >>>>>>> >>>>>>> enum Enum { >>>>>>> case a(param: String) >>>>>>> case b(param: String) >>>>>>> case c(param: String) >>>>>>> } >>>>>>> >>>>>>> let enumeration: Enum = .a(param: "Hi") >>>>>>> >>>>>>> if !(case .a = enumeration) { >>>>>>> // Do something >>>>>>> } >>>>>>> >>>>>>> — Charles >>>>>>> >>>>>>> > On Dec 20, 2017, at 9:55 AM, Kevin Nattinger via swift-evolution >>>>>>> > <swift-evolution at swift.org> wrote: >>>>>>> > >>>>>>> > I agree this would be useful. At the moment I have to hack around it >>>>>>> > with things like `var isFoo: Bool { if case .foo = self …`* with >>>>>>> > cases I commonly need, but this is definitely a feature that has come >>>>>>> > up before and I support. It is potentially related to getting the >>>>>>> > values through an accessor, which has also come up several times. >>>>>>> > >>>>>>> > Sidenote, your `switch` example is actually trivial with existing >>>>>>> > syntax: >>>>>>> > >>>>>>> > switch enumeration { >>>>>>> > case .a(.c(let param)): // or just .a(.c) if you don't need the value >>>>>>> > print(param) >>>>>>> > default: >>>>>>> > break >>>>>>> > } >>>>>>> > >>>>>>> > I use this from time to time switching over, e.g., optional enums. >>>>>>> > >>>>>>> > *: ugliest syntax ever, and it can't even be used as a standalone >>>>>>> > expression. >>>>>>> > >>>>>>> > >>>>>>> >> On Dec 20, 2017, at 8:44 AM, Ethan Diamond via swift-evolution >>>>>>> >> <swift-evolution at swift.org <mailto:swift-evolution at swift.org>> >>>>>>> >> wrote: >>>>>>> >> >>>>>>> >> Hello everyone, >>>>>>> >> >>>>>>> >> One major pain point I've run into with Swift is the inability to >>>>>>> >> evaluate the case of an enum that has associated values in a way >>>>>>> >> that just returns a bool. We've been given the ability in a switch >>>>>>> >> statement: >>>>>>> >> >>>>>>> >> enum Enum { >>>>>>> >> case a(param: String) >>>>>>> >> case b(param: String) >>>>>>> >> } >>>>>>> >> >>>>>>> >> let enumeration: Enum = a(param: "Hi") >>>>>>> >> switch enumeration { >>>>>>> >> case a: >>>>>>> >> // Do something >>>>>>> >> case b: >>>>>>> >> // Do something >>>>>>> >> } >>>>>>> >> >>>>>>> >> We'e been given the ability in the context of an if statement: >>>>>>> >> >>>>>>> >> enum Enum { >>>>>>> >> case a(param: String) >>>>>>> >> case b(param: String) >>>>>>> >> } >>>>>>> >> >>>>>>> >> let enumeration: Enum = a(param: "Hi") >>>>>>> >> >>>>>>> >> if case .a = enumeration { >>>>>>> >> // Do something >>>>>>> >> } >>>>>>> >> >>>>>>> >> But without a basic was of getting a bool for if an enum is a given >>>>>>> >> case, here's a list of things I can't do: >>>>>>> >> >>>>>>> >> Where statements: >>>>>>> >> >>>>>>> >> enum Enum { >>>>>>> >> case a(param: Enum2) >>>>>>> >> case b(param: Enum2) >>>>>>> >> } >>>>>>> >> >>>>>>> >> enum Enum2 { >>>>>>> >> case c(param: String) >>>>>>> >> case d(param: String) >>>>>>> >> } >>>>>>> >> >>>>>>> >> let enumeration: Enum = a(param: "Hi") >>>>>>> >> switch enumeration { >>>>>>> >> case a(let inner) where [INNER CASE IS .c] >>>>>>> >> } >>>>>>> >> >>>>>>> >> --------- >>>>>>> >> >>>>>>> >> Filter an array for a certain case: >>>>>>> >> >>>>>>> >> Expertly explained by Erica Sadun here: >>>>>>> >> http://ericasadun.com/2017/01/31/challenge-filtering-associated-value-enumeration-arrays/ >>>>>>> >> >>>>>>> >> <http://ericasadun.com/2017/01/31/challenge-filtering-associated-value-enumeration-arrays/> >>>>>>> >> >>>>>>> >> --------- >>>>>>> >> >>>>>>> >> Nicely set a UIButton to hidden if an enum is a certain case: >>>>>>> >> >>>>>>> >> enum State { >>>>>>> >> case `default` >>>>>>> >> case searching(results: [Result]) >>>>>>> >> } >>>>>>> >> >>>>>>> >> myButton.isHidden = [STATE IS .searching] >>>>>>> >> >>>>>>> >> --------- >>>>>>> >> >>>>>>> >> I've run into this issue a ton of times because I tend to represent >>>>>>> >> my views a State enums. I haven't seen anything on the board for >>>>>>> >> plans for solving this issue, thought. Has there been any discussion >>>>>>> >> about addressing it? Ideally I'd be able to do this: >>>>>>> >> >>>>>>> >> enum Enum { >>>>>>> >> case a(param: String) >>>>>>> >> case b(param: String) >>>>>>> >> } >>>>>>> >> >>>>>>> >> let enumeration: Enum = a(param: "Hi") >>>>>>> >> >>>>>>> >> case .a = enumeration // Bool >>>>>>> >> case .a(let param) = enumeration // Bool, assigns "Hi" to "param" >>>>>>> >> >>>>>>> >> Thanks! >>>>>>> >> Ethan >>>>>>> >> >>>>>>> >> _______________________________________________ >>>>>>> >> swift-evolution mailing list >>>>>>> >> swift-evolution at swift.org <mailto: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 >>>>>>> _______________________________________________ >>>>>>> swift-evolution mailing list >>>>>>> swift-evolution@swift.org >>>>>>> https://lists.swift.org/mailman/listinfo/swift-evolution >>>>>> >>>>>> _______________________________________________ >>>>>> swift-evolution mailing list >>>>>> swift-evolution@swift.org >>>>>> https://lists.swift.org/mailman/listinfo/swift-evolution >>> >>
_______________________________________________ swift-evolution mailing list swift-evolution@swift.org https://lists.swift.org/mailman/listinfo/swift-evolution