Update lib

Author: mohanson

go.mod

@@ -1,3 +1,3 @@
 module github.com/mohanson/daze
 
-go 1.23
+go 1.25

lib/doa/doa.go

@@ -1,29 +1,33 @@
 // Package doa stands for "dead or alive". It provides simple utilities to intentionally crash the program with a panic.
 package doa
 
+import (
+	"log"
+)
+
 // Doa checks a boolean condition and triggers a panic if it’s false.
 func Doa(b bool) {
 	if !b {
-		panic("unreachable")
+		log.Panicln("doa: unreachable")
 	}
 }
 
 // Err returns the error passed to it, ignoring the first argument.
-func Err[T any](a T, err error) error {
+func Err(a any, err error) error {
 	return err
 }
 
 // Nil checks if an error is non-nil and panics if it is.
 func Nil(err error) {
 	if err != nil {
-		panic(err)
+		log.Panicln("doa:", err)
 	}
 }
 
 // Try returns a value if there’s no error, otherwise it panics.
 func Try[T any](a T, err error) T {
 	if err != nil {
-		panic(err)
+		log.Panicln("doa:", err)
 	}
 	return a
 }

lib/gracefulexit/README.md

@@ -1,3 +1,3 @@
 # Gracefulexit
 
-A graceful exit (or graceful handling) is a simple programming idiom[citation needed] wherein a program detects a serious error condition and "exits gracefully" in a controlled manner as a result. Often the program prints a descriptive error message to a terminal or log as part of the graceful exit.
+Package gracefulexit provides a method to exit the program gracefully. A graceful exit (or graceful handling) is a simple programming idiom[citation needed] wherein a program detects a serious error condition and "exits gracefully" in a controlled manner as a result. Often the program prints a descriptive error message to a terminal or log as part of the graceful exit.

lib/gracefulexit/cmd/http/main.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"log"
+	"net"
+	"net/http"
+
+	"github.com/mohanson/daze/lib/gracefulexit"
+)
+
+func main() {
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		w.Write([]byte("Hello World!"))
+		w.Write([]byte("\n"))
+	})
+	log.Println("main: listen and server on 127.0.0.1:8080")
+	l, err := net.Listen("tcp", "127.0.0.1:8080")
+	if err != nil {
+		log.Panicln("main:", err)
+	}
+	server := http.Server{}
+	go server.Serve(l)
+	gracefulexit.Wait()
+	log.Println("main: server close")
+	server.Close()
+	log.Println("main: done")
+}

lib/gracefulexit/gracefulexit.go

@@ -1,6 +1,7 @@
-// A graceful exit (or graceful handling) is a simple programming idiom[citation needed] wherein a program detects a
-// serious error condition and "exits gracefully" in a controlled manner as a result. Often the program prints a
-// descriptive error message to a terminal or log as part of the graceful exit.
+// Package gracefulexit provides a method to exit the program gracefully. A graceful exit (or graceful handling) is a
+// simple programming idiom[citation needed] wherein a program detects a serious error condition and "exits gracefully"
+// in a controlled manner as a result. Often the program prints a descriptive error message to a terminal or log as part
+// of the graceful exit.
 package gracefulexit
 
 import (

lib/lru/README.md

@@ -1,3 +1,3 @@
 # Lru
 
-Package lru implements an lru cache.
+Package lru implements an LRU cache.

lib/lru/lru.go

@@ -1,4 +1,4 @@
-// A data structure that follows the constraints of a least recently used (lru) cache.
+// Package lru implements an LRU cache.
 package lru
 
 import (
@@ -71,6 +71,17 @@ type Lru[K comparable, V any] struct {
 	M    *sync.Mutex
 }
 
+// Del removes the provided key from the cache.
+func (l *Lru[K, V]) Del(k K) {
+	l.M.Lock()
+	defer l.M.Unlock()
+	if e, ok := l.C[k]; ok {
+		l.Drop(k, e.V)
+		delete(l.C, k)
+		l.List.Remove(e)
+	}
+}
+
 // Get looks up a key's value from the cache.
 func (l *Lru[K, V]) GetExists(k K) (v V, ok bool) {
 	l.M.Lock()
@@ -90,17 +101,6 @@ func (l *Lru[K, V]) Get(k K) (v V) {
 	return
 }
 
-// Del removes the provided key from the cache.
-func (l *Lru[K, V]) Del(k K) {
-	l.M.Lock()
-	defer l.M.Unlock()
-	if e, ok := l.C[k]; ok {
-		l.Drop(k, e.V)
-		delete(l.C, k)
-		l.List.Remove(e)
-	}
-}
-
 // Has returns true if a key exists.
 func (l *Lru[K, V]) Has(k K) bool {
 	l.M.Lock()

lib/pretty/README.md

@@ -1,20 +1,18 @@
 # Pretty
 
-Utilities to prettify console output.
+Package pretty provides utilities for beautifying console output.
 
 **Progress**
 
-```
+```sh
 $ go run cmd/progress/main.go
 
 2025/03/12 09:53:42 pretty: [=========================>                   ]  59%
 ```
 
-
-
 **Table**
 
-```
+```sh
 $ go run cmd/table/main.go
 
 2025/03/12 09:51:57 pretty: City name Area Population Annual Rainfall

lib/pretty/pretty.go

@@ -1,17 +1,18 @@
+// Package pretty provides utilities for beautifying console output.
 package pretty
 
 import (
 	"fmt"
 	"log"
 	"os"
 	"strings"
-
-	"github.com/mohanson/daze/lib/doa"
 )
 
-// PrintProgress draw a progress bar in the terminal. The percent takes values ​​from 0 to 1.
+// PrintProgress draw a progress bar in the terminal. The percent takes values from 0 to 1.
 func PrintProgress(percent float64) {
-	doa.Doa(0 <= percent && percent <= 1)
+	if percent < 0 || percent > 1 {
+		log.Panicln("pretty: the percent takes values from 0 to 1")
+	}
 	out, _ := os.Stdout.Stat()
 	// Identify if we are displaying to a terminal or through a pipe or redirect.
 	if out.Mode()&os.ModeCharDevice == os.ModeCharDevice {

lib/priority/cmd/race/main.go

@@ -38,6 +38,6 @@ func main() {
 	<-ctx.Done()
 	fin()
 	for i := range cPriorityLevels {
-		log.Println("main:", i, ret[i])
+		log.Printf("main: report level=%d count=%d", i, ret[i])
 	}
 }