modernise: Run new gopls modernise tool against the codebase and fix minor issues (#1826)

* modernise: Run new gopls modernise tool against codebase

* Address shazbert's nits

* apichecker, gctcli: Simplify HTML scraping functions and improve depth limit handling

* refactor: Create minSyncInterval const and update order book limit handling for binance and binanceUS

* refactor: Various slice usage improvements and rename TODO

* tranches: Revert deleteByID changes due to performance decrease

Shazbert was a F1 driver in a past lifetime 🏎️

* tranches: Simply retrieve copy

Thanks to shazbert

* documentation: Sort contributors list by contributions

* tranches: Remove deadcode in deleteByID

dispatch/dispatch.go

@@ -39,16 +39,16 @@ func init() {
 // NewDispatcher creates a new Dispatcher for relaying data.
 func NewDispatcher() *Dispatcher {
 	return &Dispatcher{
-		routes: make(map[uuid.UUID][]chan interface{}),
+		routes: make(map[uuid.UUID][]chan any),
 		outbound: sync.Pool{
 			New: getChan,
 		},
 	}
 }
 
-func getChan() interface{} {
+func getChan() any {
 	// Create unbuffered channel for data pass
-	return make(chan interface{})
+	return make(chan any)
 }
 
 // Start starts the dispatch system by spawning workers and allocating memory
@@ -202,7 +202,7 @@ func (d *Dispatcher) relayer() {
 }
 
 // publish relays data to the subscribed subsystems
-func (d *Dispatcher) publish(id uuid.UUID, data interface{}) error {
+func (d *Dispatcher) publish(id uuid.UUID, data any) error {
 	if d == nil {
 		return errDispatcherNotInitialized
 	}
@@ -235,7 +235,7 @@ func (d *Dispatcher) publish(id uuid.UUID, data interface{}) error {
 
 // Subscribe subscribes a system and returns a communication chan, this does not
 // ensure initial push.
-func (d *Dispatcher) subscribe(id uuid.UUID) (chan interface{}, error) {
+func (d *Dispatcher) subscribe(id uuid.UUID) (chan any, error) {
 	if d == nil {
 		return nil, errDispatcherNotInitialized
 	}
@@ -258,7 +258,7 @@ func (d *Dispatcher) subscribe(id uuid.UUID) (chan interface{}, error) {
 	}
 
 	// Get an unused channel from the channel pool
-	ch, ok := d.outbound.Get().(chan interface{})
+	ch, ok := d.outbound.Get().(chan any)
 	if !ok {
 		return nil, errTypeAssertionFailure
 	}
@@ -269,7 +269,7 @@ func (d *Dispatcher) subscribe(id uuid.UUID) (chan interface{}, error) {
 }
 
 // Unsubscribe unsubs a routine from the dispatcher
-func (d *Dispatcher) unsubscribe(id uuid.UUID, usedChan chan interface{}) error {
+func (d *Dispatcher) unsubscribe(id uuid.UUID, usedChan chan any) error {
 	if d == nil {
 		return errDispatcherNotInitialized
 	}

dispatch/dispatch_test.go

@@ -93,7 +93,7 @@ func TestSubscribe(t *testing.T) {
 	_, err = d.subscribe(nonEmptyUUID)
 	assert.ErrorIs(t, err, errDispatcherUUIDNotFoundInRouteList, "subscribe should error correctly")
 
-	d.outbound.New = func() interface{} { return "omg" }
+	d.outbound.New = func() any { return "omg" }
 	_, err = d.subscribe(id)
 	assert.ErrorIs(t, err, errTypeAssertionFailure, "subscribe should error correctly")
 
@@ -119,19 +119,19 @@ func TestUnsubscribe(t *testing.T) {
 	assert.ErrorIs(t, err, errChannelIsNil, "unsubscribe should error correctly")
 
 	// will return nil if not running
-	err = d.unsubscribe(nonEmptyUUID, make(chan interface{}))
+	err = d.unsubscribe(nonEmptyUUID, make(chan any))
 	assert.NoError(t, err, "unsubscribe should not error")
 
 	err = d.start(0, 0)
 	require.NoError(t, err, "start should not error")
 
-	err = d.unsubscribe(nonEmptyUUID, make(chan interface{}))
+	err = d.unsubscribe(nonEmptyUUID, make(chan any))
 	assert.ErrorIs(t, err, errDispatcherUUIDNotFoundInRouteList, "unsubscribe should error correctly")
 
 	id, err := d.getNewID(uuid.NewV4)
 	require.NoError(t, err, "getNewID should not error")
 
-	err = d.unsubscribe(id, make(chan interface{}))
+	err = d.unsubscribe(id, make(chan any))
 	assert.ErrorIs(t, err, errChannelNotFoundInUUIDRef, "unsubscribe should error correctly")
 
 	ch, err := d.subscribe(id)
@@ -169,8 +169,8 @@ func TestPublish(t *testing.T) {
 	assert.ErrorIs(t, err, errNoData, "publish should error correctly")
 
 	// demonstrate job limit error
-	d.routes[nonEmptyUUID] = []chan interface{}{
-		make(chan interface{}),
+	d.routes[nonEmptyUUID] = []chan any{
+		make(chan any),
 	}
 	for range 200 {
 		if err = d.publish(nonEmptyUUID, "test"); err != nil {

dispatch/dispatch_types.go

@@ -28,7 +28,7 @@ type Dispatcher struct {
 	// channels, a relayer will be given a unique id through its job channel,
 	// then publish the data across the full registered channels for that uuid.
 	// See relayer() method below.
-	routes map[uuid.UUID][]chan interface{}
+	routes map[uuid.UUID][]chan any
 	// routesMtx protects the routes variable ensuring acceptable read/write access
 	routesMtx sync.Mutex
 
@@ -61,7 +61,7 @@ type Dispatcher struct {
 // job defines a relaying job associated with a ticket which allows routing to
 // routines that require specific data
 type job struct {
-	Data interface{}
+	Data any
 	ID   uuid.UUID
 }
 
@@ -75,7 +75,7 @@ type Mux struct {
 // Pipe defines an outbound object to the desired routine
 type Pipe struct {
 	// Channel to get all our lovely information
-	c chan interface{}
+	c chan any
 	// ID to tracked system
 	id uuid.UUID
 	// Reference to multiplexer

dispatch/mux.go

@@ -43,7 +43,7 @@ func (m *Mux) Subscribe(id uuid.UUID) (Pipe, error) {
 }
 
 // Unsubscribe returns channel to the pool for the full signature set
-func (m *Mux) Unsubscribe(id uuid.UUID, ch chan interface{}) error {
+func (m *Mux) Unsubscribe(id uuid.UUID, ch chan any) error {
 	if m == nil {
 		return errMuxIsNil
 	}
@@ -52,7 +52,7 @@ func (m *Mux) Unsubscribe(id uuid.UUID, ch chan interface{}) error {
 
 // Publish takes in a persistent memory address and dispatches changes to
 // required pipes.
-func (m *Mux) Publish(data interface{}, ids ...uuid.UUID) error {
+func (m *Mux) Publish(data any, ids ...uuid.UUID) error {
 	if m == nil {
 		return errMuxIsNil
 	}
@@ -91,6 +91,6 @@ func (p *Pipe) Release() error {
 }
 
 // Channel returns the Pipe's channel
-func (p *Pipe) Channel() <-chan interface{} {
+func (p *Pipe) Channel() <-chan any {
 	return p.c
 }