Golang: optimal way of typing associative slices?

I'm parsing loads of HTTP logs pursing a goal tell how many requests each IP address generated.

The first thing I did is:

var hits = make(map[string]uint)

// so I could populate it with
hits[ipAddr]++

However, I would like to make it "typed", so that it would be immediately clear that hits[string]uint uses an IP address as a string identifier. I thought, well maybe a struct can help me:

type Hit struct {
    IP    string
    Count uint
}

But that way (I think) I'm loosing the performance, because now I how to really look for specific Hit to increment it's count. I tolerate that I could be paranoid here, and could simple go for the loop:

var hits = make([]Hit)

// TrackHit just damn tracks it
func TrackHit(ip string) {
    for hit, _ := range hits {
        if hit.IP == ip {
             hit.Count++
             return
        }
    }

    append(hits, Hit{
        IP:    ip,
        Count: 0,
    })
}

But that just looks ... suboptimal. I think everything that could be written in 1 line makes you shine as professional, and when 1 line turns into 13, I tend to feel "whaaa? Doing something wrong here, mom?"

Any typed one-liners here in Go?

Thanks

As Uvelichitel pointed out, you can use a typed string:

type IP string
var hits = make(map[IP]uint)
hits[IP("127.0.0.1")]++

Or you could use the existing stdlib IP type:

var hits = make(map[net.IP]uint)
hits[net.ParseIP("127.0.0.1")]++

Either would make it clear that you're referring to IPs, without the overhead introduced by looping over a slice of structs for every increment. The latter has the advantage of giving you full stdlib support for any other IP manipulation you need to do, and a more compact representation (4 bytes for IPv4 addresses instead of a 7-15 character UTF-8 string), at the cost of parsing the strings. Which one is better will depend on your specific use case.