Hi Martin, please see reply inline. On Wed, Feb 8, 2017 at 4:47 PM Martin R <martinr...@gmail.com> wrote:
> Isn't that exactly what the nil-coalescing operator ?? does? > > func query(name: String?) -> String { > return "{ param: \(name ?? "null") }" > } > > No, because func query(name: String?) -> String { return "{ param: \(name ?? "null") }" } print(query(name: nil)) //=> { param: null } print(query(name: "Max")) //=> { param: Max } The output I'm expecting from the second call should be is { param: "Max" } > If you use the JSONSerialization class from the Foundation library then > `nil` is bridged to `NSNull` and translated to "null" automatically (see > SE-0140). > > I agree that in this case JSONSerialization might be a fitting solution, I also agree that any required output can be solved by a Utility class. What I would like to argue is that there is a place for such syntactic sugar because it simplifies readability, for ex. what if I've want to wrap my non optional name parameter using %20%, and co. JSONSerialization is specific solution, I think that there is a generic case to have in the language some syntactic sugar for a 1 liner composition of unwrap and ternary conditional operation. Regards, > Martin > > > Am 08.02.2017 um 15:04 schrieb Maxim Veksler via swift-evolution < > swift-evolution@swift.org>: > > > > Hello, > > > > Let's assume I have an optional "name" parameter, based on the optional > status of the parameters I would like to compose string with either the > unwrapped value of name, or the string "null". The use case for is > syntactic sugar to compose a GraphQL queries. > > > > A (sampled) illustration of the code that currently solves it looks as > following: > > > > func query(name: String?) { > > let variables_name = name != nil ? "\"\(name!)\"" : "null" > > return "{ param: \(variables_name) }" > > } > > > > Based on optional status the following output is expected > > > > let name = "Max" > > query(name: name) > > // { param: "Max" } > > > > let name: String? = nil > > query(name: name) > > // { param: null } > > > > I think it might be useful to have an conditional unwrap operator !? > that would enable syntax sugar uch as the following built into the language: > > > > func query(name: String?) { > > return "{ param: \(name !? "\"\(name)\"": "null") }" > > } > > > > This expression is expected to produce same output as the examples > above. It means check the Optional state of name: String?, in case it has a > value, unwrap it and make the unwrapped value accessible under the same > name to the true condition part of the expression, otherwise return the > false condition part of the expression. > > > > The effectively removes the need to have the "if != nil" and the forced > unwrap syntactical code, and IMHO improves code readability and > expressiveness. > > > > I'm wondering what the community thinks of the displayed use case, and > proposed solution? > > > > > > -m > > _______________________________________________ > > 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