The book ... has been performing good on all our channels and until yesterday we had sold 130 copies. ... It was great news for me and thought of sharing it with you :)
takeown /f C:\cygwin /r /d y
icacls c:\cygwin /t /grant everyone:F
del c:\cygwin
package main
import (
"fibonacci")
func main() {
println(fibonacci.FibSimple(4))
println(fibonacci.FibMemoized(5))
println(fibonacci.FibChanneled(6))
}
1-functional-fundamentals/ch01-pure-fp/02_fib/src/fibonacci/meomoize.go
package fibonacci
type Memoized func(int) int
var fibMem = Memoize(fib)
func Memoize(mf Memoized) Memoized {
cache := make(map[int]int)
return func(key int) int {
if val, found := cache[key]; found {
return val
}
temp := mf(key)
cache[key] = temp
return temp
}
}
func FibMemoized(n int) int {
return fibMem(n)
}
func fib(x int) int {
if x == 0 {
return 0 } else if x <= 2 {
return 1 } else {
return fib(x-2) + fib(x-1)
}
}
l3x/fp-go.git, whereas it's actually l3x/learn-fp-go.git.go run cars.go in the following path: ~/myprojects/fp-go/1-functional-fundamentals/ch01-pure-fp/01_oop.~/myprojects/fp-go/1-functional-fundamentals/ch01-pure-fp/01_oop/src/oop. And even when you do run go run cars.go from that directory, you get:go run: cannot run non-main package
planets used instead of names within collection.NewFromSlice()strings.Join should be strings.Join([]string{"Hey", v.(string)}, " ") or strings.Join([]string{"Hey ", v.(string)}, "")names := []interface{}{
"Alice",
"Bob",
"Cindy",
}
collection := collections.NewFromSlice(names)
collection = collection.Map(func(v interface{}) interface{} {
return strings.Join([]string{"Hey", v.(string)}, " ")
})
println(collection) // or the use of fmt.Println(collection)
if p[i] >= 't' && p[i] <= 'z' {
p[i] = p[i] - 32
}
if p[i] >= 'a' && p[i] <= 'z' {
p[i] = p[i] - 32
}
| Developer | Says... |
| Java |
I do not like the way Go makes me handle errors after every function call.
I want exception handling like this:
try {
Decrypt()
Authenticate()
Charge()
}
catch (Exception e) {
// handle exception
}
but after adding all those error checks my code looks more like this:
err := Decrypt()
if err != nil {
return err
}
err = Authenticate()
if err != nil {
return err
}
Charge()
Go error handling looks like a bunch of scaffolding obscuring my code's intentions.
 |
| Go | As you know, Go does not support exception handling. Instead, you return errors to inform the calling function/method that something went wrong. You are supposed to handle an error as soon as possible. This is what we call the idiomatic way to handle errors. When you throw exceptions, how far up the call stack will your handler be? What if your exception gets handled before it reaches your global error handler? Will it stop or be rethrown? If rethrown, do you really want to handle your errors more than once? |
| Go |
Also, since an error is a value we can program it and do. See that Scan method? It might encounter an IO error, but it does not immediately return the error. Instead it returns a boolean value to indicate success. Later we can check for the error.
scanner := bufio.NewScanner(input)
for scanner.Scan() {
token := scanner.Text()
// process token
}
if err := scanner.Err(); err != nil {
// process the error
}
We can also clean up the following repetitive error checking code:
_, err = fd.Write(p0[a:b])
if err != nil {
return err
}
_, err = fd.Write(p1[c:d])
if err != nil {
return err
}
_, err = fd.Write(p2[e:f])
if err != nil {
return err
}
// and so on
... by writing a helper that will allow us to wait until we're done writing to handle the error.
var err error
write := func(buf []byte) {
if err != nil {
return
}
_, err = w.Write(buf)
}
write(p0[a:b])
write(p1[c:d])
write(p2[e:f])
// and so on
if err != nil {
return err
}
|
| Java | That is much better, but is that a reusable pattern? In each of those two examples above, we had to write custom error handling code in two different places, right? Isn't there a more generic, yet Go idiomatic way to handle errors that will eliminate that repetitive error checking code and allow me to check for errors in one place, at the end of my workflow? |
| FP |
Yes, Java developer there is and it's called the Lexical Workflow Solution. Read all about it in chapter 11. If you use it, your code will look something like this:
step = Next(step, Decrypt)
step = Next(step, Authenticate)
step = Next(step, Charge)
json, err := step(nil)
if err != nil {
// handle error
}
|
