Go: Package Function Interface for Local Struct

I have a tricky issue which I'm not sure is possible with Go, basically I'm writing a package that implements a simple binary search, which I want to return a value of a struct which is defined by the user, i.e. not in the package.

So effectively I want a function in the package which can be assigned to a struct that is defined locally, that is to say in package main.

So in the package is the function for binary search:

package binsearch
func (f *SomeStruct) Get(lookup uint) (int, uint, bool) {
	min := 0
	max := len(f.Key)-1
	at := max/2
	for {
		current := f.Key[at]
		if lookup<current {
			max = at-1
		} else {
		if lookup>current {
			min = at+1
			} else {
				return at, f.Value[at], true // found
			}
		}
		if min>max {
			return 0, 0, false // doesn't exist
		}
		at = (max+min)/2
	}
}

And then in main something like:

package main

type mystruct struct {
Key []uint
Value []uint
}

func main() {
test := new(mystruct)
// Then add some data here
i, value, ok := test.Get(12345)
}

Somehow I need to define in package main that the binsearch.Get function should be applied to mystruct. Is this possible?

Here is what it would look like using interfaces:

package binsearch

type Searchable interface {
    Key(pos int) uint
    Value(pos int) uint
    Len() int
}

func Get(s Searchable, lookup uint) (int, uint, bool) {
    min := 0
    max := s.Len()-1
    at := max/2
    for {
        current := s.Key(at)
        if lookup<current {
            max = at-1
        } else {
        if lookup>current {
            min = at+1
            } else {
                return at, f.Value(at), true // found
            }
        }
        if min>max {
            return 0, 0, false // doesn't exist
        }
        at = (max+min)/2
    }
}

and main

package main

import (
    "path/to/binsearch"
)

type mystruct struct {
    key []uint
    value []uint
}

func (m *mystruct) Key(pos int) uint {
    return m.key[pos]
}

func (m *mystruct) Value(pos int) uint {
    return m.value[pos]
}

func (m *mystruct) Len() int {
    return len(m.key)
}

func main() {
    test := new(mystruct)
    // Then add some data here
    i, value, ok := binsearch.Get(test, 12345)
}

No, you will have to use an interface and define it on your mystruct.

type BinarySearchable interface {
	Keys() []uint
	Values() []uint
}

func Get(bs BinarySearchable, lookup uint) (int, uint, bool) {
	keys := bs.Keys()
	vals := bs.Values()
	min := 0
	max := len(keys) - 1
	at := max / 2
	for {
		current := keys[at]
		if lookup < current {
			max = at - 1
		} else {
			if lookup > current {
				min = at + 1
			} else {
				return at, vals[at], true // found
			}
		}
		if min > max {
			return 0, 0, false // doesn't exist
		}
		at = (max + min) / 2
	}
}

type mystruct struct {
	keys   []uint
	values []uint
}

func (ms *mystruct) Keys() []uint {
	return ms.keys
}

func (ms *mystruct) Values() []uint {
	return ms.values
}

func main() {
	test := &mystruct{[]uint{12, 123456, 13}, []uint{1,2,3}}
	fmt.Println(Get(test, 123456))
}

<kbd>playground</kbd>

You can do this without interfaces but you have to convert your mystruct type into a binsearch.SomeStruct type. This is because the binsearch.Get function is defined to take a pointer to a binsearch.SomeStruct as a receiver and Go doesn't autconvert types for you in this situation.

There is no general way to do this, but one specific to your application might look like this:

s := &SomeStruct{}
copy(test.Key, s.Key)
copy(test.Value, s.Value)

i, value, ok := s.Get(12345)

It is not possible in the way you described. What Golang use is the concept of interface: you define a set of methods that a given struct must implement.

type Fooer interface {
    Bar(i int)
}

You can then define a function or method that will take a variable of this type as parameter, and use the defined set of methods to do its job.

func Foo(a Fooer) {
    // Do you stuff here using the Bar() method
}

The convention is to give the interface a name ending in -er. You can see examples of interfaces in the fmt package with Stringer and Scanner, or closer to you example, in the package sort which define an interface named Interface (which full name is sort.Interface, which is a break in the convention but actually cleaner than said convention given there is only one interface in the package and the package is built to work with this interface).