I assume your existing implementation is at https://github.com/juju/httputil/blob/master/relativeurl.go?

Also, since this func only takes paths, have you considered the path package instead? It wouldn't be paired with its counterpart ResolveReference, but I wonder if the func would be useful in any other context that would avoid having to import net/url.

@mvdan I'm fairly sure that this wouldn't be useful in any context other than HTTP. The logic is peculiar to the specific semantics used by relative URLs. For example, a trailing slash is significant.

ResolveReference takes two *URL and returns a *URL.
Why does this function work on strings instead of *URLs?
It seems like it should match ResolveReference if it is the inverse.

url.Relative seems OK to me.

Ping @rogpeppe; see @rsc's comment above.

Or if it's two *url.URLs as arguments, it could be a method named "Sub" like https://golang.org/pkg/time/#Time.Sub

We have

func (base *URL) ResolveReference(ref *URL) (abs *URL)

We could add

func (base *URL) Relative(abs *URL) (ref *URL)

or

func (abs *URL) Relative(base *URL) (ref *URL)

It's unclear to me which people would expect.

Filepath has

func Rel(base, targ string) (rel string)

Does anyone want to make a case for why this is important? We often want relative file paths, for example to display to users, but it's pretty rare to insist on relative URLs. Pretty much all URL uses are fine as absolute URLs.

We needed this because we have some HTTP services that are behind an apache gateway that rewrites URL paths to add a prefix (so we have several hosted services under the same virtual host).

The problem is that it's not possible for a service to form a link to an absolute path within that service, because that might be wrong (it's also possible to reach the service without going through the apache proxy).

So we need to use relative links - hence this function (which was non-trivial to get right FWIW).

Thanks for the context @rogpeppe. For now it seems like this would be best outside the standard library - the need seems very specific and rare.