func (l *List) Remove() error {
	err := (*bbolt.DB)(l.db).Update(func(tx *bbolt.Tx) error {
		return tx.DeleteBucket(l.name)
	})
	l.name = nil
	return err
}
Remove this list
package simplebolt
import (
	"encoding/binary"
	"errors"
	"strconv"
	"strings"
	"time"
	"go.etcd.io/bbolt"
)
const (
	Version = 5.1
)
type (
	Database bbolt.DB
	boltBucket struct {
		db   *Database  
		name []byte     
	}
	List boltBucket
	Set boltBucket
	HashMap boltBucket
	KeyValue boltBucket
)
var (
	ErrBucketNotFound = errors.New("Bucket not found")
	ErrKeyNotFound = errors.New("Key not found")
	ErrDoesNotExist = errors.New("Does not exist")
	ErrExistsInSet = errors.New("Element already exists in set")
	ErrInvalidID = errors.New("Element ID can not contain \":\"")
	errFoundIt = errors.New("Found it")
	errReachedEnd = errors.New("Reached end of data structure")
)
func New(filename string) (*Database, error) {
	db, err := bbolt.Open(filename, 0600, &bbolt.Options{Timeout: 1 * time.Second})
	if err != nil {
		return nil, err
	}
	return (*Database)(db), nil
}
func (db *Database) Close() {
	(*bbolt.DB)(db).Close()
}
func (db *Database) Path() string {
	return (*bbolt.DB)(db).Path()
}
func (db *Database) Ping() error {
	return nil
}
func NewList(db *Database, id string) (*List, error) {
	name := []byte(id)
	if err := (*bbolt.DB)(db).Update(func(tx *bbolt.Tx) error {
		if _, err := tx.CreateBucketIfNotExists(name); err != nil {
			return errors.New("Could not create bucket: " + err.Error())
		}
		return nil  
	}); err != nil {
		return nil, err
	}
	return &List{db, name}, nil
}
func (l *List) Add(value string) error {
	if l.name == nil {
		return ErrDoesNotExist
	}
	return (*bbolt.DB)(l.db).Update(func(tx *bbolt.Tx) error {
		bucket := tx.Bucket(l.name)
		if bucket == nil {
			return ErrBucketNotFound
		}
		n, err := bucket.NextSequence()
		if err != nil {
			return err
		}
		return bucket.Put(byteID(n), []byte(value))
	})
}
func (l *List) All() ([]string, error) {
	var results []string
	if l.name == nil {
		return nil, ErrDoesNotExist
	}
	err := (*bbolt.DB)(l.db).View(func(tx *bbolt.Tx) error {
		bucket := tx.Bucket(l.name)
		if bucket == nil {
			return ErrBucketNotFound
		}
		return bucket.ForEach(func(_, value []byte) error {
			results = append(results, string(value))
			return nil  
		})
	})
	return results, err
}
func (l *List) Last() (string, error) {
	var result string
	if l.name == nil {
		return "", ErrDoesNotExist
	}
	err := (*bbolt.DB)(l.db).View(func(tx *bbolt.Tx) error {
		bucket := tx.Bucket(l.name)
		if bucket == nil {
			return ErrBucketNotFound
		}
		cursor := bucket.Cursor()
		_, value := cursor.Last()
		result = string(value)
		return nil  
	})
	return result, err
}
func (l *List) LastN(n int) ([]string, error) {
	var results []string
	if l.name == nil {
		return nil, ErrDoesNotExist
	}
	err := (*bbolt.DB)(l.db).View(func(tx *bbolt.Tx) error {
		bucket := tx.Bucket(l.name)
		if bucket == nil {
			return ErrBucketNotFound
		}
		c := bucket.Cursor()
		sizeBytes, _ := c.Last()
		size := binary.BigEndian.Uint64(sizeBytes)
		if size < uint64(n) {
			return errors.New("Too few items in list")
		}
		startPos := byteID(size - uint64(n) + 1)
		for key, value := c.Seek(startPos); key != nil; key, value = c.Next() {
			results = append(results, string(value))
		}
		return nil  
	})
	return results, err
}