There have been questions about when panic is and isn't appropriate. My recommendation would be that panic is appropriate when an internal invariant of a system is broken, while all other cases (in particular, incorrect or invalid usage) should return errors. Consider the following code, modelling a bank where account balances should never go below 0:

type Bank struct {
  accounts map[int]int
}

func (b *Bank) Transfer(from int, to int, amount int) error {
  if amount < 0 {
    return fmt.Errorf("amount cannot be negative, got %v", amount)
  }
  if balance := b.accounts[from]; balance < amount {
    return fmt.Errorf("unable to transfer %v, balance is %v", amount, balance)
  }
  b.accounts[from] -= amount
  b.accounts[to] += amount
  return nil
}

func (b *Bank) Balance(account int) int {
  balance := b.accounts[account]
  if balance < 0 {
    panic("found balance less than 0")
  }
  return balance
}

Transfer() should return an error when transferring more money than the account has: this is an error condition triggered by an external call, and it is up to the caller to handle it.

However, Balance() should panic if it ever finds a balance less than 0. This is an invariant that our system should enforce through the checks in Transfer(), thus it can only happen if the code inside the system is faulty. Panicing instead of returning an error here saves our callers from handling this error, which should really never happen in the first place.

Don't panic! #4465

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions