ong/sync: add lockable type

[komuw]

https://github.com/func25/go-practical-tips/blob/main/tips.md#making-a-type-with-built-in-locking-syncmutex-embedding

type Lockable[T any] struct {
    sync.Mutex
    Value T
}

func (l *Lockable[T]) SetValue(v T) {
    l.Lock()
    defer l.Unlock()

    l.Value = v
}

func (l *Lockable[T]) GetValue() T {
    l.Lock()
    defer l.Unlock()

    return l.Value
}

[komuw]

package main

import (
	"fmt"
	"sync"
)

type Lockable[T any] struct {
	sync.Mutex
	value T
}

func (l *Lockable[T]) Do(f func(l *Lockable[T])) {
	l.Lock()
	defer l.Unlock()
	f(l)
}

var log = Lockable[int]{}

func main() { fmt.Println("Hello, 世界") }

[komuw]

package main

import (
	"fmt"
	"sync"
	"time"
)

type Lockable[T any] struct {
	mu    sync.Mutex
	value T
}

// Do calls [f] and then returns the latest value in [Lockable] and any error from calling [f].
// Note: even where [f] returns an error the returned [value] may not be the zero value. It will be the latest value in [Lockable]
func (l *Lockable[T]) Do(
	f func(l *Lockable[T]) error,
) (value T, _ error) {
	l.mu.Lock()
	err := f(l)
	val := l.value // read only after calling f
	l.mu.Unlock()

	return val, err
}

func New[T any](value T) *Lockable[T] {
	return &Lockable[T]{value: value}
}

var log = New(0)

func main() {
	fmt.Println("val: ", log.value)
	val, err := log.Do(
		func(l *Lockable[int]) error {
			l.value = 34
			return nil
		},
	)
	if err != nil {
		panic(err)
	}
	fmt.Println("val: ", val)

	for i := range 19 {
		go func(ii int) {
			val, err := log.Do(
				func(l *Lockable[int]) error {
					l.value = ii
					return nil
				},
			)
			if err != nil {
				panic(err)
			}
			fmt.Println("ii: ", ii, "val: ", val)
		}(i)
	}

	time.Sleep(2 * time.Second)
}