import suggestion from ward

examples/line-filters/line-filters.go

@@ -8,43 +8,43 @@
 // pattern to write your own Go line filters.
 package main
 
-// Package `bufio` will help us read line-by-line.
+import (
-import "bufio"
+    "bufio"
-import "strings"
+    "io"
-import "os"
+    "log"
-import "io"
+    "os"
+    "strings"
+)
 
 func main() {
-
     // Wrapping the unbuffered `os.Stdin` with a buffered
     // reader gives us a convenient `ReadString` method
     // that we'll use to read input line-by-line.
-    in := bufio.NewReader(os.Stdin)
+    rdr := bufio.NewReader(os.Stdin)
     out := os.Stdout
 
+    for {
         // `ReadString` returns the next string from the
         // input up to the given separator byte. We give the
         // newline byte `'\n'` as our separator so we'll get
         // successive input lines.
-    for {
+        switch line, err := rdr.ReadString('\n'); err {
-        inLine, err := in.ReadString('\n')
+        case nil:
-
-        // The `EOF` error is expected when we reach the
-        // end of input, so exit gracefully in that case.
-        // Otherwise there's a problem.
-        if err == io.EOF {
-            return
-        }
-        if err != nil {
-            panic(err)
-        }
-
             // Write out the uppercased line, checking for an
             // error on the write as we did on the read.
-        outLine := strings.ToUpper(inLine)
+            ucl := strings.ToUpper(line)
-        _, err = out.WriteString(outLine)
+            if _, err = out.WriteString(ucl); err != nil {
-        if err != nil {
+                log.Println(err)
-            panic(err)
+                os.Exit(-1)
+            }
+        case io.EOF:
+            // The `EOF` error is expected when we reach the
+            // end of input, so exit gracefully in that case.
+            os.Exit(0)
+        default:
+            // Otherwise there's a problem
+            log.Println(err)
+            os.Exit(-1)
         }
     }
 }