Can a struct be made comparable?

[Mark]

I have a package which has a function `Do[T comparable](a, b []T) Result`.

I have a struct:

```go

type N struct {

  x int

  y int

  t string

}

```

Is it possible to make `N` comparable; in particular by a field of my choice, e.g., `t`?

Or will I have to make, say, `DoFunc(a, b []N, eq func(i, j N) bool) Result` with, say,

`func eq(i, j N) { return i.t == j.t }`?

[Brian Candler]

Structs are already comparable, but all fields must be the same:

https://go.dev/play/p/XwhSz4DEDwL

I think your solution with function 'eq' is fine.  You can see the same thing in the standard library in slices.CompactFunc and slices.EqualFunc

https://pkg.go.dev/slices#CompactFunc

https://pkg.go.dev/slices#EqualFunc

For the case of "ordered" rather than "comparable", have a look at slices.BinarySearchFunc and related functions.

[Peter Galbavy]

As a slight digression - I thought I was going mad, but 'slices' and 'maps' are new :-) Only in 1.21 though...

Well, there is a lot of boiler plate that maps.Keys() will get rid of.

[Mark]

What I really want to do is to be able to diff slices of structs on the basis of one single field.

For example, given:

```

type Item struct {

  I int

  S string

}

```

and given `a` and `b` are both of type`[]Item`, I want to diff these slices based purely on the `S` field, ignoring the `I` field.

This diff pkg claims to be able to do this (something I'm testing, so I don't know either way yet), but in any case, it is incredibly slow.

[Mark]

In fact the diff pkg mentioned above does work but is of no use to me since for each change it gives back only the field(s) used, not the original structs (or pointers to them), so I can't see any way back to the original structs (or their slice indexes).

[Brian Candler]

You seem to be saying "if the S field is different then I want to consider these two structs different, and get pointers to the two structs. If the S field is the same then I want to skip the pair entirely". Is that right?

The required semantics are not entirely clear, but it sounds like a handful of lines of code to implement - there's no point importing and learning a third party library.

On the assumption that all the elements to be compared are in corresponding positions in a and b:

https://go.dev/play/p/Y71sLUpftzR

[Brian Candler]

I forgot you wanted generics:

https://go.dev/play/p/PhGVjsWWTdB

[Mark]

Hi Brian,

Your code certainly identifies the different items.

However, that's not a diff tool in the sense I mean.

Unix diff and tools like it don't just say x[i] != y[i], they find the longest common subsequences and in essence produce a series of edit commands that would turn slice x into slice y.

There are quite a few go diff tools that will do this, including my own based on Python's difflib sequence matcher.

What I want to do is find one that does this for slices of structs where only one struct field is considered for comparison purposes.

[Brian Candler]

The 'diff' package you showed identifies the changed object index by means of a "Path" attribute in the Changelog entry. If the top level object is a slice, then Atoi(change.Path[0]) is the index into the slice.

[Mark]

Hi Brian,

Ah, thank you, that helped a lot.

[Mark]

I finally worked out how to make my go-diff pkg (v1.1.0) able to diff sequences of structs based on a key function.