Good price.

  • nickwitha_k (he/him)
    7•1 month ago

    for no clear reason

    JS That’s the reason. The language has an awful type system.

    • Victor
      2•1 month ago

      I think its type system is “okay”, I mean inherently dynamic typing is pretty error-prone. But its type coercion algorithms are bonkers. Also that whole “NaN ≠ NaN” business…

      • nickwitha_k (he/him)
        2•1 month ago

        Also that whole “NaN ≠ NaN” business…

        See that’s one of the parts that is actually almost in line with other languages. In Go, for example, nil ≠ nil because nil is, by definition, undefined. You can’t say whether one thing that you know nothing about is at all like something else that you know nothing about. It really should raise an exception at the attempt to compare NaN though.

        • Victor
          1•1 month ago

          If nil ≠ nil, how do you compare a variable to the literal?

          • nickwitha_k (he/him)
            1•1 month ago

            You’d first check for nil values, then compare like normal. Extra step, yes, but it keeps you from hitting NPEs through that route.

            • Victor
              1•1 month ago

              You’d first check for nil values

              What does this mean, if not the same as

              then compare like normal

              ?

              • nickwitha_k (he/him)
                1•1 month ago

                IIRC, a nil value can be checked against a literal successfully but not against another nil value. Say you want to check for equality of two vars that could be nil. You just need an extra if statement to ensure that you are not trying to compare nil and nil or nil and a non-nil value (that’ll give you a type error or NPE):

                var a *string
var b *string

...
if a != nil && b != nil {
  if a == b {
    fmt.Println("Party!")
  } else {
    fmt.Println("Also Party!")
}
                • Victor
                  1•1 month ago

                  What I mean is that in JS you can’t do NaN != NaN, not even variable != NaN. So you’re not saying it’s the same in Go, since you can do a != nil?

                  • nickwitha_k (he/him)
                    1•1 month ago

                    Kinda. nil is a weird value in Go, not quite the same as null or None in JS and Python, respectively. A nil value may or may not be typed and it may or may not be comparable to similar or different types. There is logical consistency to where these scenarios can be hit but it is pretty convoluted and much safer, with fewer footguns to check for nil values before comparison.

                    I’m other words, in Go (nil == nil) || (nil != nil), depending on the underlaying types. One can always check if a variable has a nil value but may not be able to compare variables if one or more have a nil value. Therefore, it is best to first check for nil values to protect against errors that failure to execute comparisons might cause (anything from incorrect outcome to panic).

                    ETA: Here’s some examples

                    // this is always possible for a variable that may have a nil value. 
a != nil || a == nil

a = nil
b = nil
// This may or may not be valid, depending on the underlying types.
a != b || a == b

// Better practice for safety is to check for nil first
if a != nil && b != nil {
    if a == b {
        fmt.Println("equal")
    } else {
        fmt.Println("not equal")
    }
} else {
    fmt.Println("a and/or b is nil and may not be comparable")
}