proposal: Go 2: simplify error handling and simplify conditions processing and "?" pipe operation symbol

[enddeadroyal]

1.Simplify error handling:
for example (reference to rust)
old(go 1.12):

dat,err := ioutil.readFull("Go Programming.pdf")
if err != nil {
   log.error(err.Message())
   return err
}

OR

if dat,err := ioutil.readFull("Go Programming.pdf");err != nil {
   log.error(err.Message())
   return err
}

expect:

dat := ioutil.readFull("Go Programming.pdf") ? err =>  log.error(err.Message())

OR

dat := ioutil.readFull("Go Programming.pdf") ? err => {
     log.error(err.Message())
     return err
}

when err is nil, don't do err expression

2 Simplify Conditions Process
old(go 1.12):

dat,err := ioutil.readFull("Go Programming.pdf")
_,ok := err.(os.Err)
if ok {
 //do something
}
_,ok := err.(file.NotFindErr)
if ok {
 //do something
}

expect:

switch err => {
    os.Err, io.Err: =>    //do something
    file.NotFindErr:=> {
            //do something
     }
}

when 1 and 2 use at the same time

dat := ioutil.readFull("Go Programming.pdf") ? err => {
   switch err => {
     os.Err, io.Err:=>    //do something
     file.NotFindErr:=> {
            //do something
      }
    }
}

OR

dat := ioutil.readFull("Go Programming.pdf") ? switch err => {
    os.Err, io.Err:=>    //do something
    file.NotFindErr:=> {
            //do something
    }
}

"?" operation symbol is was used as a pipe which concat expressions
like as linux "|" operation symbol

netstat -an | grep 8080

[ianlancetaylor]

Has similarities to #33177, #32946, and likely others.

[ianlancetaylor]

The switch err => syntax seems quite similar to a type switch. I don't see the advantage to the new syntax.

The other syntax seems to change

if r, err := F(); err != nil {
    ...
}

to

r := F() ? err => {
    ...
}

If I'm counting right this replaces if, a comma, a semicolon, and != nil with ? and =>. This seems to save 6 characters, not counting whitespace. That doesn't seem like a huge benefit to me.

[enddeadroyal]

Thank you for answer

if r, err := F(); err != nil {
    ...
}

to

r := F() ? err => {
    ...
}

The scope of these two r is different
The first will make the nesting very serious

if r, err := F(); err != nil {
    ...
}else {
   if r, err := F(); err != nil {
    ...
   }else{
      if r, err := F(); err != nil {
         ...
      }else {
         ...
     }
   }
}

to

r := F() ? err => {
    ...
}
r := F() ? err => {
    ...
}
r := F() ? err => {
    ...
}

[enddeadroyal]

no need for “=>”

if r, err := F(); err != nil {
    ...
}

to

r := F() ? err {
    ....
}

[ianlancetaylor]

Thanks for the correction on scoping. I don't think it affects the token count, though.

Eliminating => does save another two characters, so now overall it saves 8 characters.

[gocs]

This looks like something like a ternary operator.

[ianlancetaylor]

This proposal introduces new syntax unlike anything else in Go. As discussed above, it doesn't appear to bring a significant savings in character count. It has similarities to other error handling proposals that have been declined.

For these reasons, this is a likely decline. Leaving open for four weeks for final comments.

-- for @golang/proposal-review