esync

package main

import (
	"context"
	"fmt"
	"math"

	"gitlab.com/efronlicht/esync"
)

func main() {
	realsqrt := func(_ context.Context, x float64) (float64, error) {
		if x < 0 || math.IsNaN(x) {
			return 0, fmt.Errorf("expected x >= 0 and not NaN, got %v", x)
		}
		return math.Sqrt(x), nil
	}

	cache := esync.NewCache(realsqrt)
	checkAndPrint := func(k float64) {
		val, err, _, loaded := cache.Check(k)

		if err != nil {
			fmt.Printf("k=%v: error: %v: loaded: %v\n", k, err, loaded)
			return
		} else {
			fmt.Printf("k=%v: ok: %.3f: loaded: %v\n", k, val, loaded)
		}
	}
	checkAndPrint(2)              // no value yet.
	cache.Warm(context.TODO(), 2) // warm the cache.

	checkAndPrint(2) // now we have the value.

	checkAndPrint(-1)              // this will not fetch the value.
	cache.Warm(context.TODO(), -1) // warm the cache - this should give an error
	checkAndPrint(-1)              // now we have the value.

}

Output:

k=2: ok: 0.000: loaded: false
k=2: ok: 1.414: loaded: true
k=-1: ok: 0.000: loaded: false
k=-1: error: expected x >= 0 and not NaN, got -1: loaded: true

package main

import (
	"context"
	"fmt"
	"time"

	"gitlab.com/efronlicht/esync"
	"gitlab.com/efronlicht/esync/example"
)

func main() {
	c := esync.NewCache(example.GoDoc)
	_, _, _ = c.Get(context.TODO(), "os", 5*time.Second) // this will fetch the value.
	_, _, _ = c.Get(context.TODO(), "sync", 5*time.Second)
	printWarm := func(key string) {
		_, _, _, loaded := c.Check(key)
		fmt.Printf("cache warm for %s: %v\n", key, loaded)
	}
	printWarm("os")
	printWarm("sync")
	fmt.Println("clearing cache")
	c.Clear()
	printWarm("os")
	printWarm("sync")

}

Output:

cache warm for os: true
cache warm for sync: true
clearing cache
cache warm for os: false
cache warm for sync: false

package main

import (
	"context"
	"fmt"
	"time"

	"gitlab.com/efronlicht/esync"
	"gitlab.com/efronlicht/esync/example"
)

func main() {
	c := esync.NewCache(example.GoDoc)
	_, _, _ = c.Get(context.TODO(), "os", 5*time.Second) // this will fetch the value.
	_, _, loaded := c.Get(context.TODO(), "os", 5*time.Second)
	fmt.Printf("before delete: loaded=%v\n", loaded) // true
	c.Delete("os")
	_, _, loaded = c.Get(context.TODO(), "os", 5*time.Second)
	fmt.Printf("after delete: loaded=%v\n", loaded) // false
}

Output:

before delete: loaded=true
after delete: loaded=false

Iterate through all the entries in the cache.

package main

import (
	"context"
	"fmt"
	"time"

	"gitlab.com/efronlicht/esync"
	"gitlab.com/efronlicht/esync/example"
)

func main() {
	c := esync.NewCache(example.GoDoc)
	c.Warm(context.TODO(), "os", "sync")
	t0 := time.Now()
	time.Sleep(50 * time.Millisecond)
	c.Warm(context.TODO(), "sync", "fmt")
	for k, entry := range c.Entries() {
		fmt.Printf("%s: expired: %v\n", k, entry.Stored.Before(t0))
	}
}

Output:

sync: expired: false
os: expired: true
fmt: expired: false

Fetch and cache documentation from pkg.go.dev and cache it.

package main

import (
	"context"
	"fmt"
	"time"

	"gitlab.com/efronlicht/esync"
	"gitlab.com/efronlicht/esync/example"
)

func main() {
	cache := esync.NewCache(example.GoDoc)

	printGet := func(key string, ttl time.Duration) {
		_, err, loaded := cache.Get(context.TODO(), key, ttl)
		fmt.Printf("key=%s, (err != nil) = %v, loaded=%v\n", key, err != nil, loaded)
	}

	printGet("sync", 5*time.Second) // the first call will fetch the documentation.
	printGet("sync", 5*time.Second) // the cache entry is still fresh, so this will return the documentation from the cache.
	time.Sleep(50 * time.Millisecond)
	// ask for a value fresher than the cache entry.
	printGet("sync", 25*time.Millisecond) // this will fetch the documentation again.

	// ask for a package we know can't be found.
	printGet("efronlicht/this-package-does-not-exist", 5*time.Second) // this will fail.

	// we also cache errors.
	printGet("efronlicht/this-package-does-not-exist", 5*time.Second) // this will return the error from the cache.
}

Output:

key=sync, (err != nil) = false, loaded=false
key=sync, (err != nil) = false, loaded=true
key=sync, (err != nil) = false, loaded=false
key=efronlicht/this-package-does-not-exist, (err != nil) = true, loaded=false
key=efronlicht/this-package-does-not-exist, (err != nil) = true, loaded=true

package main

import (
	"context"
	"fmt"
	"time"

	"gitlab.com/efronlicht/esync"
	"gitlab.com/efronlicht/esync/example"
)

func main() {
	c := esync.NewCache(example.GoDoc)
	c.Warm(context.TODO(), "os", "sync")
	t0 := time.Now()
	time.Sleep(50 * time.Millisecond)
	c.Warm(context.TODO(), "sync", "fmt")
	for k := range c.LiveEntries(t0) {
		fmt.Printf("%s\n", k)
	}
}

Output:

fmt
sync

package main

import (
	"context"
	"fmt"
	"time"

	"gitlab.com/efronlicht/esync"
	"gitlab.com/efronlicht/esync/example"
)

func main() {
	cache := esync.NewCache(example.GoDoc)
	ticker := time.NewTicker(20 * time.Millisecond)
	ctx, cancel := context.WithCancel(context.Background())
	const ttl = 100 * time.Millisecond
	go cache.StartGC(ctx, ticker.C, 100*time.Millisecond)
	check := func(key string) {
		_, _, _, loaded := cache.Check(key)
		if loaded {
			fmt.Println("hit")
		} else {
			fmt.Println("miss")
		}
	}
	check("os") // never fetched, so it should not be in the cache.
	cache.Warm(context.TODO(), "os")
	check("os") // os should be in the cache.
	time.Sleep(300 * time.Millisecond)
	check("os")                        // os should have been removed from the cache.
	cancel()                           // stop the gc.
	cache.Warm(context.TODO(), "os")   // fetch the value again.
	check("os")                        // os should be in the cache.
	time.Sleep(300 * time.Millisecond) //
	check("os")                        //  gc has stopped: os should still be in the cache

}

Output:

miss
hit
miss
hit
hit

You can use a pool to reduce memory allocations when you need temporary buffers for I/O operations or formatting.

package main

import (
	"bytes"

	"gitlab.com/efronlicht/esync"
)

func main() {
	const kib = 1024
	pool := esync.NewPool(func() *bytes.Buffer { return bytes.NewBuffer(make([]byte, 0, 16*kib)) }) // new buffers will start pre-allocated with 16 KiB of capacity.

	// Get a buffer from the pool.
	buf := pool.Get()
	defer pool.Put(buf) // return the buffer to the pool when done.
	/* do computation with buf */
}

Output: