Recovering panic with wrapper in Go - go

Question

I have came across the following code that manages recover from panic using a wrapper. I understand that panic don't propagate across goroutines and they have to be managed independently, so it needs to be handled in the goroutine where the panic occurred.
package main
import (
"fmt"
"time"
)
func main() {
go Wrap(test)()
time.Sleep(time.Second)
fmt.Println("HELLO")
}
func test() {
panic("PANIC")
}
func Wrap(f func()) func() {
return func() {
defer func() {
if r := recover(); r != nil {
fmt.Printf("RECOVERED - %v\r\n", r)
}
}()
f()
}
}
func WrapWithSignal(f func(chan bool), signal chan bool) func() {
return func() {
defer func() {
if r := recover(); r != nil {
fmt.Printf("RECOVERED - %v\r\n", r)
signal <- false
}
}()
f(signal)
}
}
What will be the use of WrapWithSignal function, and how can I use it?
Is there another way to wrap functions in order to recover that is less verbose?

Answer 1

When implementing long-running processes, it's possible that certain code paths will result in a panic. This is usually common for things such as uninitialized maps and pointers, as well as division by zero problems in the case of poorly validated user input.
Having a program crash completely in these cases is frequently much worse than the panic itself, and so it can be helpful to catch and handle panics.
In most web applications, it's common to catch panics and emit an http.InternalServerError message when a panic occurs.
Within the recover, you can, essentially, do anything you want, although emitting a log is common.
1) Wrap with Signal can be used to recover from panic and send a signal to the given bool channel.
The warp with signal function implements the wrap pattern and can be used to wrap a signal channel and emit an event to the channel even when a panic occurs. In this case, if the recover was not called, you would get a deadlock.
package main
import (
"errors"
"fmt"
"math/rand"
"time"
)
func main() {
signal:= make(chan bool)
go WrapWithSignal(play, signal)()
if <-signal{
fmt.Println("Congratulations, you win!")
return
}
fmt.Println("You died.")
}
func play(signal chan bool){
fmt.Println("Playing russian roulette")
rand.Seed(time.Now().UnixNano())
if rand.Intn(2) == 1{
panic(errors.New("got a bullet"))
}
signal <- true
}
2) Is there another way to wrap functions in order to recover that is less verbose?
Short answer: NO, unless you use a package. A package theoretically is always less verbose.
Long answer: Depending the situation, you can for example, create a go routine wrapper and create your own panic group based on a waiting group. It can be useful while validating user input or doing concurrent operations and collect all the errors at the end. Split it into a package and you will get verbosity.
Just a sample: https://play.golang.org/p/on9AwZkvyIZ