What's the most idiomatic way to pick a value from a slice based on a condition in Go?

I've been doing a lot of loops to filter values and sometimes even converted slices to maps with convenient indexes to achieve this, but I feel it might not be the best way to do it in Go. So:

Considering the following boilerplate code, what's the most idiomatic way to find the first person named "Bob" on people slice? found should be a bool variables to determine if a person named "Bob" was found or not.

package main

import "fmt"

type Person struct {
    Age int
    Name string
}

var people=[]Person{{Age:18,Name:"Deb"},{Age:22,Name:"Bob"},{Age:35,Name:"Bob"}}

func main() {
	FirstBob, found := // how to pick first "Bob"?
	fmt.Println(FirstBob)
}

Being more general: What's the most idiomatic way to pick the first value from a slice that matches a certain condition?

For example,

package main

import "fmt"

type Person struct {
	Age  int
	Name string
}

var people = []Person{{Age: 18, Name: "Deb"}, {Age: 22, Name: "Bob"}, {Age: 35, Name: "Bob"}}

func findPerson(people []Person, name string) (Person, bool) {
	for _, p := range people {
		if p.Name == name {
			return p, true
		}
	}
	return Person{}, false
}

func main() {
	FirstBob, found := findPerson(people, "Bob")
	if found {
		fmt.Println(FirstBob)
	}
}

Output:

{22 Bob}

If you want to return a pointer to the Person struct,

package main

import "fmt"

type Person struct {
	Age  int
	Name string
}

var people = []Person{{Age: 18, Name: "Deb"}, {Age: 22, Name: "Bob"}, {Age: 35, Name: "Bob"}}

func findPerson(people []Person, name string) (*Person, bool) {
	for i := range people {
		p := &people[i]
		if p.Name == name {
			return p, true
		}
	}
	return nil, false
}

func main() {
	FirstBob, found := findPerson(people, "Bob")
	if found {
		fmt.Println(*FirstBob)
	}
}

Output:

{22 Bob}

The idiomatic way is to write out the loop--for example, Go team member (and former Python coder) Andrew Gerrand's closing talk at GopherCon 2014 mentions other functional-style list-processing shortcuts ("filter", "map", etc.) at https://www.youtube.com/watch?v=dKGmK_Z1Zl0&t=23m40s

The standard justification is that not using those shortcuts yields more consistent code (developers can't make different choices about whether to use map or not), and it's explicit (it's held to be more obvious when you're doing nested loops or loops over enormous datasets if the loops are visible as a for block).

That said, 1) if you repeat the same kind of search lots of places you might as well factor it like in peterSO's answer, and 2) "idiomatic" is an ideal that not all code satisfies all the time; if you think it makes your code vastly easier to work with, nothing stops you from writing a type-specific shortcut (think: type People []Person; func (p People) FirstMatchingIndex(predicate func(p *Person) bool) int {...}). The standard strings.IndexFunc is close to a "find (the index of) the first item satisfying a predicate" function, for example.