I think you should explore the direction of removing NilLiteralConvertible
entirely, together with nil. My example could instead use:
let tree: JSON = ["name": "Alex", "age": 20, "email": .null]
Rationale would be that when nil was added to the language, enum
constructors could not omit their
I know I know.
I should have framed this as removing NilLiteralConvertible from Optional and
supplying it with a new keyword.
I don’t find nil to adequately represent what it is doing with optionals. It
*looks* like it is setting a object to nil when this really isn’t the case. The
optional
> On Jun 8, 2016, at 11:54 AM, Антон Жилин via swift-evolution
> wrote:
>
> The difference between nil and .none is that the former is more "generic"
> than the latter.
>
> NilLiteralConvertible protocol expresses types that can contain "null" as
> legal
The difference between nil and .none is that the former is more
"generic" than the latter.
NilLiteralConvertible protocol expresses types that can contain "null" as
legal values. `nil` does not have a type, it's just a token that is casted
to whatever NilLiteralConvertible type is expected.
nil is not only usable with Optionals, although that is its most common usage.
Any type implementing NilLiteralConvertible can be initialized with a nil
literal
-DW
> On Jun 8, 2016, at 10:45 AM, Brandon Knope via swift-evolution
> wrote:
>
> This is precisely the
This is precisely the point I was trying to make.
“nil” is a holdover from other languages; i.e. we are comfortable with using
it. I think there are better alternatives to consider.
However, when evaluating whether it makes sense with swift, I think it fails
some of the criteria for inclusion.
Reading the thread.. I wonder if we need "nil" at all, why not use (just a
question, not a suggestion) .none ? I.e. now we can use nil and .none in
the same situations, .none is just 2 symbols longer, '.none' highlight that
Optional is a special type (that there is .some(T) in Optional), no
I'am not either for removing nil nor renaming it none, I think that they are
conceptually different things.
This syntactic sugar brings unfortunately many things around. One fastidious
thing is it multiple semantics: As null pointer. As none value.
I am personally not favorable for multiples
None would be similar to Null or nothing about the types in that sense
which None is not a type.
Nil would be interpret as Int, Float, String, etc
On Wed, Jun 8, 2016 at 9:17 AM, Dany St-Amant via swift-evolution <
swift-evolution@swift.org> wrote:
> No clue as to the origins, but if you
It depends how you frame it.
When I see nil I think of 0 or a pointer.
let someInt: Int? = nil
Does someInt really have a value of 0? Is it really a pointer (because it looks
like one).
let someInt: Int? = none
let someInt: Int? = .none
- Doesn't look like a pointer and can't be
That’s not quite what I meant. nil feels right to refer to an object-you
can say “Foo is nil”, but you can’t really say that “Foo is none”, since
while you can’t really use none as an adjective, as you can with nil. It’s
really about what flows right-none is the opposite of some, but nil isn’t.
That's exactly the point I was going for.
none makes more sense in this context than nil in my opinion
Brandon
> On Jun 7, 2016, at 8:10 PM, Saagar Jha wrote:
>
> Well, some is the opposite of none in that if I don’t have some, I have none.
> nil is just a carry-over
Well, some is the opposite of none in that if I don’t have some, I have
none. nil is just a carry-over from Objective-C.
On Tue, Jun 7, 2016 at 5:07 PM Brandon Knope via swift-evolution <
swift-evolution@swift.org> wrote:
> I guess for me it comes down to this:
>
> *Why were some and none chosen
I guess for me it comes down to this:
Why were some and none chosen for as the cases for Optional?
As an extension of that, why does nil then represent none instead of the
obvious none?
There has to be a reason why it's not:
enum Optional {
case some(T)
case nil
}
None seems a lot more
There are NilLiteralConvertible types other than Optional, but they’re
dwindling now that pointer nullability is represented by Optional. That said,
I’m not convinced renaming “nil” is worth it at this point. Similarity with
other languages is still a good thing.
It’s true that we might not
Quick thought:
If optional has a .none case, wouldn't it be more consistent to rename nil to
none?
Also, would nil make it into Swift if not for other languages?
It also might make it somewhat clearer:
var someInt: Int? = none //looks less like a pointer and more like a value of
nothing
1.
16 matches
Mail list logo