[swift-evolution] !? operator for ternary conditional unwrapping

[Maxim Veksler]

Hi Martin, please see reply inline.

On Wed, Feb 8, 2017 at 4:47 PM Martin R <martinr448 at 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 at 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 at swift.org
> > https://lists.swift.org/mailman/listinfo/swift-evolution
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://lists.swift.org/pipermail/swift-evolution/attachments/20170208/e49ed755/attachment.html>