upgrade to go 1.18, use generics

go.mod

 module github.com/ergochat/ergo
 
-go 1.17
+go 1.18
 
 require (
 	code.cloudfoundry.org/bytefmt v0.0.0-20200131002437-cf55d5288a48

irc/channel.go

 		info.Bans = channel.lists[modes.BanMask].Masks()
 		info.Invites = channel.lists[modes.InviteMask].Masks()
 		info.Excepts = channel.lists[modes.ExceptMask].Masks()
-		info.AccountToUMode = make(map[string]modes.Mode)
-		for account, mode := range channel.accountToUMode {
-			info.AccountToUMode[account] = mode
-		}
+		info.AccountToUMode = utils.CopyMap(channel.accountToUMode)
 	}
 
 	if includeFlags&IncludeSettings != 0 {

irc/channelmanager.go

 	sync.RWMutex // tier 2
 	// chans is the main data structure, mapping casefolded name -> *Channel
 	chans               map[string]*channelManagerEntry
-	chansSkeletons      utils.StringSet // skeletons of *unregistered* chans
-	registeredChannels  utils.StringSet // casefolds of registered chans
-	registeredSkeletons utils.StringSet // skeletons of registered chans
-	purgedChannels      utils.StringSet // casefolds of purged chans
+	chansSkeletons      utils.HashSet[string] // skeletons of *unregistered* chans
+	registeredChannels  utils.HashSet[string] // casefolds of registered chans
+	registeredSkeletons utils.HashSet[string] // skeletons of registered chans
+	purgedChannels      utils.HashSet[string] // casefolds of purged chans
 	server              *Server
 }
 
 // NewChannelManager returns a new ChannelManager.
 func (cm *ChannelManager) Initialize(server *Server) {
 	cm.chans = make(map[string]*channelManagerEntry)
-	cm.chansSkeletons = make(utils.StringSet)
+	cm.chansSkeletons = make(utils.HashSet[string])
 	cm.server = server
 
 	// purging should work even if registration is disabled
 	cm.Lock()
 	defer cm.Unlock()
 
-	cm.registeredChannels = make(utils.StringSet, len(rawNames))
-	cm.registeredSkeletons = make(utils.StringSet, len(rawNames))
+	cm.registeredChannels = make(utils.HashSet[string], len(rawNames))
+	cm.registeredSkeletons = make(utils.HashSet[string], len(rawNames))
 	for _, name := range rawNames {
 		cfname, err := CasefoldChannel(name)
 		if err == nil {

irc/channelreg.go

 }
 
 // PurgedChannels returns the set of all casefolded channel names that have been purged
-func (reg *ChannelRegistry) PurgedChannels() (result utils.StringSet) {
-	result = make(utils.StringSet)
+func (reg *ChannelRegistry) PurgedChannels() (result utils.HashSet[string]) {
+	result = make(utils.HashSet[string])
 
 	prefix := fmt.Sprintf(keyChannelPurged, "")
 	reg.server.store.View(func(tx *buntdb.Tx) error {

irc/client.go

 }
 
 // Friends refers to clients that share a channel with this client.
-func (client *Client) Friends(capabs ...caps.Capability) (result map[*Session]empty) {
-	result = make(map[*Session]empty)
+func (client *Client) Friends(capabs ...caps.Capability) (result utils.HashSet[*Session]) {
+	result = make(utils.HashSet[*Session])
 
 	// look at the client's own sessions
 	addFriendsToSet(result, client, capabs...)
 }
 
 // Friends refers to clients that share a channel or extended-monitor this client.
-func (client *Client) FriendsMonitors(capabs ...caps.Capability) (result map[*Session]empty) {
+func (client *Client) FriendsMonitors(capabs ...caps.Capability) (result utils.HashSet[*Session]) {
 	result = client.Friends(capabs...)
 	client.server.monitorManager.AddMonitors(result, client.nickCasefolded, capabs...)
 	return
 }
 
 // helper for Friends
-func addFriendsToSet(set map[*Session]empty, client *Client, capabs ...caps.Capability) {
+func addFriendsToSet(set utils.HashSet[*Session], client *Client, capabs ...caps.Capability) {
 	client.stateMutex.RLock()
 	defer client.stateMutex.RUnlock()
 	for _, session := range client.sessions {
 		if session.capabilities.HasAll(capabs...) {
-			set[session] = empty{}
+			set.Add(session)
 		}
 	}
 }
 	} else if client.oper == nil && len(client.channels) >= config.Channels.MaxChannelsPerClient {
 		err = errTooManyChannels
 	} else {
-		client.channels[channel] = empty{} // success
+		client.channels.Add(channel) // success
 	}
 	client.stateMutex.Unlock()
 

irc/client_test.go

 
 func TestGenerateBatchID(t *testing.T) {
 	var session Session
-	s := make(utils.StringSet)
+	s := make(utils.HashSet[string])
 
 	count := 100000
 	for i := 0; i < count; i++ {

irc/config.go

 // OperClass defines an assembled operator class.
 type OperClass struct {
 	Title        string
-	WhoisLine    string          `yaml:"whois-line"`
-	Capabilities utils.StringSet // map to make lookups much easier
+	WhoisLine    string                `yaml:"whois-line"`
+	Capabilities utils.HashSet[string] // map to make lookups much easier
 }
 
 // OperatorClasses returns a map of assembled operator classes from the given config.
 
 			// create new operclass
 			var oc OperClass
-			oc.Capabilities = make(utils.StringSet)
+			oc.Capabilities = make(utils.HashSet[string])
 
 			// get inhereted info from other operclasses
 			if len(info.Extends) > 0 {

irc/handlers.go

 		// Construct set of channels the client is in.
 		userChannels := make(ChannelSet)
 		for _, channel := range client.Channels() {
-			userChannels[channel] = empty{}
+			userChannels.Add(channel)
 		}
 
 		// Another client is a friend if they share at least one channel, or they are the same client.
 				if channel.flags.HasMode(modes.Auditorium) {
 					return false // TODO this should respect +v etc.
 				}
-				if _, present := userChannels[channel]; present {
+				if userChannels.Has(channel) {
 					return true
 				}
 			}

irc/history/history.go

 
 // returns all correspondents, in reverse time order
 func (list *Buffer) allCorrespondents() (results []TargetListing) {
-	seen := make(utils.StringSet)
+	seen := make(utils.HashSet[string])
 
 	list.RLock()
 	defer list.RUnlock()

irc/import.go

 	Channels map[string]channelImport
 }
 
-func serializeAmodes(raw map[string]string, validCfUsernames utils.StringSet) (result []byte, err error) {
+func serializeAmodes(raw map[string]string, validCfUsernames utils.HashSet[string]) (result []byte, err error) {
 	processed := make(map[string]int, len(raw))
 	for accountName, mode := range raw {
 		if len(mode) != 1 {
 	tx.Set(keySchemaVersion, strconv.Itoa(importDBSchemaVersion), nil)
 	tx.Set(keyCloakSecret, utils.GenerateSecretKey(), nil)
 
-	cfUsernames := make(utils.StringSet)
+	cfUsernames := make(utils.HashSet[string])
 	skeletonToUsername := make(map[string]string)
 	warnSkeletons := false
 

irc/monitor.go

 	"sync"
 
 	"github.com/ergochat/ergo/irc/caps"
+	"github.com/ergochat/ergo/irc/utils"
 
 	"github.com/ergochat/irc-go/ircmsg"
 )
 	// client -> (casefolded nick it's watching -> uncasefolded nick)
 	watching map[*Session]map[string]string
 	// casefolded nick -> clients watching it
-	watchedby map[string]map[*Session]empty
+	watchedby map[string]utils.HashSet[*Session]
 }
 
 func (mm *MonitorManager) Initialize() {
 	mm.watching = make(map[*Session]map[string]string)
-	mm.watchedby = make(map[string]map[*Session]empty)
+	mm.watchedby = make(map[string]utils.HashSet[*Session])
 }
 
 // AddMonitors adds clients using extended-monitor monitoring `client`'s nick to the passed user set.
-func (manager *MonitorManager) AddMonitors(users map[*Session]empty, cfnick string, capabs ...caps.Capability) {
+func (manager *MonitorManager) AddMonitors(users utils.HashSet[*Session], cfnick string, capabs ...caps.Capability) {
 	manager.RLock()
 	defer manager.RUnlock()
 	for session := range manager.watchedby[cfnick] {
 		if session.capabilities.Has(caps.ExtendedMonitor) && session.capabilities.HasAll(capabs...) {
-			users[session] = empty{}
+			users.Add(session)
 		}
 	}
 }
 		manager.watching[session] = make(map[string]string)
 	}
 	if manager.watchedby[cfnick] == nil {
-		manager.watchedby[cfnick] = make(map[*Session]empty)
+		manager.watchedby[cfnick] = make(utils.HashSet[*Session])
 	}
 
 	if len(manager.watching[session]) >= limit {
 	}
 
 	manager.watching[session][cfnick] = nick
-	manager.watchedby[cfnick][session] = empty{}
+	manager.watchedby[cfnick].Add(session)
 	return nil
 }
 
 	manager.Lock()
 	defer manager.Unlock()
 	delete(manager.watching[session], cfnick)
-	delete(manager.watchedby[cfnick], session)
+	manager.watchedby[cfnick].Remove(session)
 	return nil
 }
 
 	defer manager.Unlock()
 
 	for cfnick := range manager.watching[session] {
-		delete(manager.watchedby[cfnick], session)
+		manager.watchedby[cfnick].Remove(session)
 	}
 	delete(manager.watching, session)
 }

irc/nickname.go

 		"MemoServ", "BotServ", "OperServ",
 	}
 
-	restrictedCasefoldedNicks = make(utils.StringSet)
-	restrictedSkeletons       = make(utils.StringSet)
+	restrictedCasefoldedNicks = make(utils.HashSet[string])
+	restrictedSkeletons       = make(utils.HashSet[string])
 )
 
 func performNickChange(server *Server, client *Client, target *Client, session *Session, nickname string, rb *ResponseBuffer) error {

irc/types.go

 	"time"
 
 	"github.com/ergochat/ergo/irc/modes"
+	"github.com/ergochat/ergo/irc/utils"
 )
 
-type empty struct{}
-
 // ClientSet is a set of clients.
-type ClientSet map[*Client]empty
-
-// Add adds the given client to this set.
-func (clients ClientSet) Add(client *Client) {
-	clients[client] = empty{}
-}
-
-// Remove removes the given client from this set.
-func (clients ClientSet) Remove(client *Client) {
-	delete(clients, client)
-}
-
-// Has returns true if the given client is in this set.
-func (clients ClientSet) Has(client *Client) bool {
-	_, ok := clients[client]
-	return ok
-}
+type ClientSet = utils.HashSet[*Client]
 
 type memberData struct {
 	modes    *modes.ModeSet
 }
 
 // ChannelSet is a set of channels.
-type ChannelSet map[*Channel]empty
+type ChannelSet = utils.HashSet[*Channel]

irc/utils/types.go

 
 type empty struct{}
 
-type StringSet map[string]empty
+type HashSet[T comparable] map[T]empty
 
-func (s StringSet) Has(str string) bool {
-	_, ok := s[str]
+func (s HashSet[T]) Has(elem T) bool {
+	_, ok := s[elem]
 	return ok
 }
 
-func (s StringSet) Add(str string) {
-	s[str] = empty{}
+func (s HashSet[T]) Add(elem T) {
+	s[elem] = empty{}
+}
+
+func (s HashSet[T]) Remove(elem T) {
+	delete(s, elem)
+}
+
+func CopyMap[K comparable, V any](input map[K]V) (result map[K]V) {
+	result = make(map[K]V, len(input))
+	for key, value := range input {
+		result[key] = value
+	}
+	return
 }

irc/znc.go

 type zncPlaybackTimes struct {
 	start   time.Time
 	end     time.Time
-	targets utils.StringSet // nil for "*" (everything), otherwise the channel names
+	targets utils.HashSet[string] // nil for "*" (everything), otherwise the channel names
 	setAt   time.Time
 }
 
 		end = zncWireTimeToTime(params[3])
 	}
 
-	var targets utils.StringSet
+	var targets utils.HashSet[string]
 	var nickTargets []string
 
 	// three cases:
 	if params[1] == "*" {
 		playPrivmsgs = true // XXX nil `targets` means "every channel"
 	} else {
-		targets = make(utils.StringSet)
+		targets = make(utils.HashSet[string])
 		for _, targetName := range strings.Split(targetString, ",") {
 			if strings.HasPrefix(targetName, "#") {
 				if cfTarget, err := CasefoldChannel(targetName); err == nil {