Merge pull request #12 from Code-Hex/fix/some-comments

fixed some comments

Author: Code-Hex

cache.go

@@ -62,7 +62,7 @@ func newItem[K comparable, V any](key K, val V, opts ...ItemOption) *Item[K, V]
 	}
 }
 
-// Cache is a cache.
+// Cache is a thread safe cache.
 type Cache[K comparable, V any] struct {
 	cache       Interface[K, *Item[K, V]]
 	expirations map[K]chan struct{}
@@ -104,7 +104,9 @@ func AsFIFO[K comparable, V any](opts ...fifo.Option) Option[K, V] {
 	}
 }
 
-// New creates a new Cache.
+// New creates a new thread safe Cache.
+//
+// There are several Cache replacement policies available with you specified any options.
 func New[K comparable, V any](opts ...Option[K, V]) *Cache[K, V] {
 	o := newOptions[K, V]()
 	for _, optFunc := range opts {

fifo/fifo.go

@@ -5,6 +5,7 @@ import (
 )
 
 // Cache is used a FIFO (First in first out) cache replacement policy.
+//
 // In FIFO the item that enter the cache first is evicted first
 // w/o any regard of how often or how many times it was accessed before.
 type Cache[K comparable, V any] struct {
@@ -38,7 +39,7 @@ func WithCapacity(cap int) Option {
 	}
 }
 
-// NewCache creates a new cache.
+// NewCache creates a new non-thread safe FIFO cache whose capacity is the default size (128).
 func NewCache[K comparable, V any](opts ...Option) *Cache[K, V] {
 	o := newOptions()
 	for _, optFunc := range opts {

lfu/lfu.go

@@ -4,7 +4,12 @@ import (
 	"container/heap"
 )
 
-// Cache is a thread safe LRU cache
+// Cache is used a LFU (Least-frequently used) cache replacement policy.
+//
+// Counts how often an item is needed. Those that are used least often are discarded first.
+// This works very similar to LRU except that instead of storing the value of how recently
+// a block was accessed, we store the value of how many times it was accessed. So of course
+// while running an access sequence we will replace a block which was used fewest times from our cache.
 type Cache[K comparable, V any] struct {
 	cap   int
 	queue *priorityQueue[K, V]
@@ -31,7 +36,7 @@ func WithCapacity(cap int) Option {
 	}
 }
 
-// NewCache creates a new LFU cache whose capacity is the default size (128).
+// NewCache creates a new non-thread safe LFU cache whose capacity is the default size (128).
 func NewCache[K comparable, V any](opts ...Option) *Cache[K, V] {
 	o := newOptions()
 	for _, optFunc := range opts {

lru/lru.go

@@ -4,7 +4,11 @@ import (
 	"container/list"
 )
 
-// Cache is a thread safe LRU cache
+// Cache is used a LRU (Least recently used) cache replacement policy.
+//
+// Discards the least recently used items first. This algorithm requires
+// keeping track of what was used when, which is expensive if one wants
+// to make sure the algorithm always discards the least recently used item.
 type Cache[K comparable, V any] struct {
 	cap   int
 	list  *list.List
@@ -36,7 +40,7 @@ func WithCapacity(cap int) Option {
 	}
 }
 
-// NewCache creates a new LRU cache whose capacity is the default size (128).
+// NewCache creates a new non-thread safe LRU cache whose capacity is the default size (128).
 func NewCache[K comparable, V any](opts ...Option) *Cache[K, V] {
 	o := newOptions()
 	for _, optFunc := range opts {

simple/simple.go

@@ -15,7 +15,7 @@ type entry[V any] struct {
 	createdAt time.Time
 }
 
-// NewCache creates a new cache.
+// NewCache creates a new non-thread safe cache.
 func NewCache[K comparable, V any]() *Cache[K, V] {
 	return &Cache[K, V]{
 		items: make(map[K]*entry[V], 0),