lock

README

Example

import "import.name/lock"
import "import.name/lock/unlock"

func ExampleLock() {
	var (
		mu    sync.Mutex
		count int
	)

	lock.Guard(&mu, func() {
		count++
	})

	n := lock.Guarded(&mu, func() int {
		return count
	})
	fmt.Println(n)
}

func ExampleUnlock() {
	var mu sync.Mutex

	mu.Lock()
	defer mu.Unlock()

	unlock.Guard(&mu, func() {
		time.Sleep(time.Second)
	})
}

func ExampleTagLock() {
	type countLocked struct{}

	var (
		mu    lock.TagMutex[countLocked]
		count int
	)

	incrementWithLock := func(l countLocked) {
		count++
	}

	readWithLock := func(l countLocked) int {
		return count
	}

	lock.GuardTag(&mu, func(l countLocked) {
		incrementWithLock(l)
	})

	n := lock.GuardTagged(&mu, func(l countLocked) int {
		return readWithLock(l)
	})
	fmt.Println(n)
}

Documentation

Overview

Package lock provides locking helpers.

Index

• func Guard(lock sync.Locker, f func())
• func GuardTag[Tag any](ock TagLocker[Tag], f func(Tag))
• func GuardTagged[Tag any, Val any](lock TagLocker[Tag], f func(Tag) Val) Val
• func Guarded[T any](lock sync.Locker, f func() T) T
• type TagLocker
• type TagMutex
  • func (mu *TagMutex[Tag]) Lock() Tag

Examples

• Guard
• TagMutex

Functions

func Guard

func Guard(lock sync.Locker, f func())

Guard invokes f while keeping the lock locked.

Example

package main

import (
	"fmt"
	"sync"

	"import.name/lock"
)

func main() {
	var (
		mu    sync.Mutex
		count int
	)

	lock.Guard(&mu, func() {
		count++
	})

	n := lock.Guarded(&mu, func() int {
		return count
	})
	fmt.Println(n)
}

func GuardTag

func GuardTag[Tag any](ock TagLocker[Tag], f func(Tag))

func GuardTagged

func GuardTagged[Tag any, Val any](lock TagLocker[Tag], f func(Tag) Val) Val

func Guarded

func Guarded[T any](lock sync.Locker, f func() T) T

Guarded invokes f while keeping the lock locked. The return value is passed through.

Types

type TagLocker

type TagLocker[Tag any] interface {
	Lock() Tag
	Unlock()
}

type TagMutex

type TagMutex[Tag any] struct {
	sync.Mutex
}

Example

package main

import (
	"fmt"

	"import.name/lock"
)

func main() {
	type countLocked struct{}

	var (
		mu    lock.TagMutex[countLocked]
		count int
	)

	incrementWithLock := func(l countLocked) {
		count++
	}

	readWithLock := func(l countLocked) int {
		return count
	}

	lock.GuardTag(&mu, func(l countLocked) {
		incrementWithLock(l)
	})

	n := lock.GuardTagged(&mu, func(l countLocked) int {
		return readWithLock(l)
	})
	fmt.Println(n)
}

func (*TagMutex[Tag]) Lock

func (mu *TagMutex[Tag]) Lock() Tag