30. Designing a small type

type account struct {
    owner   string
    balance int
}

func newAccount(owner string) *account {
    return &account{owner: owner}
}

func (a *account) deposit(amount int) error {
    if amount <= 0 {
        return fmt.Errorf("cannot deposit %d", amount)
    }
    a.balance = a.balance + amount
    return nil
}

func (a *account) withdraw(amount int) error {
    if amount <= 0 {
        return fmt.Errorf("cannot withdraw %d", amount)
    }
    if amount > a.balance {
        return fmt.Errorf("cannot withdraw %d: the balance is %d", amount, a.balance)
    }
    a.balance = a.balance - amount
    return nil
}

func (a *account) getBalance() int {
    return a.balance
}

func main() {
    acc := newAccount("Keiko")

    err := acc.deposit(100)
    if err != nil {
        fmt.Println("Error:", err)
    }

    err = acc.withdraw(30)
    if err != nil {
        fmt.Println("Error:", err)
    }
    fmt.Println(acc.getBalance()) // 70

    err = acc.withdraw(1000)
    if err != nil {
        fmt.Println("Error:", err) // Error: cannot withdraw 1000: the balance is 70
    }
    fmt.Println(acc.getBalance()) // 70
}

func main() {
    acc := newAccount("Keiko")
    acc.balance = -500
    fmt.Println(acc.getBalance()) // -500
}

// Chapter 30 example: package bank. Every rule about an account is here, and
// other packages cannot reach past these methods to the fields.

package bank

import (
    "errors"
    "fmt"
)

// Account is one bank account. Make one with NewAccount.
type Account struct {
    owner   string
    balance int
}

// NewAccount returns an account with a balance of 0. The owner must not be
// empty.
func NewAccount(owner string) (*Account, error) {
    if owner == "" {
        return nil, errors.New("an account needs an owner")
    }
    return &Account{owner: owner}, nil
}

// checkAmount is a helper for this package only.
func checkAmount(amount int) error {
    if amount <= 0 {
        return fmt.Errorf("the amount %d is not above 0", amount)
    }
    return nil
}

// Deposit adds to the balance. The amount must be above 0.
func (a *Account) Deposit(amount int) error {
    err := checkAmount(amount)
    if err != nil {
        return err
    }
    a.balance = a.balance + amount
    return nil
}

// Withdraw takes from the balance. The amount must be above 0, and no more
// than the balance.
func (a *Account) Withdraw(amount int) error {
    err := checkAmount(amount)
    if err != nil {
        return err
    }
    if amount > a.balance {
        return fmt.Errorf("cannot withdraw %d: the balance is %d", amount, a.balance)
    }
    a.balance = a.balance - amount
    return nil
}

// Owner returns the name on the account.
func (a *Account) Owner() string {
    return a.owner
}

// Balance returns the current balance.
func (a *Account) Balance() int {
    return a.balance
}

// Chapter 30 example: a small command loop that uses package bank.
//
// Run from this folder:
//   cd exercises/30/02-account-package
//   go run .

package main

import (
    "bufio"
    "fmt"
    "os"
    "strconv"
    "strings"

    "accountpackage/bank"
)

var reader = bufio.NewReader(os.Stdin)

// readLine prints the prompt and gives back one trimmed line. The error is
// not nil when there is no more input.
func readLine(prompt string) (string, error) {
    fmt.Print(prompt)
    text, err := reader.ReadString('\n')
    line := strings.TrimSpace(text)
    if err != nil && line == "" {
        return "", err
    }
    return line, nil
}

// doAmount runs "deposit" or "withdraw" with the amount the user typed.
func doAmount(acc *bank.Account, verb string, amountText string) {
    amount, err := strconv.Atoi(amountText)
    if err != nil {
        fmt.Println("That is not a whole number.")
        return
    }

    if verb == "deposit" {
        err = acc.Deposit(amount)
    } else {
        err = acc.Withdraw(amount)
    }
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Balance:", acc.Balance())
}

func main() {
    acc, err := bank.NewAccount("Keiko")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    fmt.Println("Account for", acc.Owner())

    for {
        line, err := readLine("> ")
        if err != nil {
            fmt.Println()
            fmt.Println("No more input.")
            return
        }

        words := strings.Fields(line)
        if len(words) == 1 && words[0] == "quit" {
            fmt.Println("Goodbye.")
            return
        }
        if len(words) == 1 && words[0] == "balance" {
            fmt.Println("Balance:", acc.Balance())
            continue
        }
        if len(words) == 2 && (words[0] == "deposit" || words[0] == "withdraw") {
            doAmount(acc, words[0], words[1])
            continue
        }
        fmt.Println("Commands: deposit <amount>, withdraw <amount>, balance, quit")
    }
}