cmd := exec.Command("go", "mod", "download", "-modcacherw", "rsc.io/quote@v1.5.2")
	cmd.Stderr = os.Stderr
	cmd.Env = append(os.Environ(), "GOPATH="+gopath)
	return cmd.Run()
}

// readCache repeatedly globs for go.mod files in the given cache, then opens
// those files for reading. When the done chan is closed, readCache closes
// files and returns.
func readCache(gopath string, done <-chan struct{}) {

			// Not a bare extension, but a glob. Ignore for now:
			// - we do not have an implementation for this glob
			//   syntax (translation to path/filepath.Match could
			//   be possible)
			// - support for globs with weight ordering would have
			//   performance impact to all lookups to support the
			//   rarely seen glob entries
			// - trying to match glob metacharacters literally is
			//   not useful
			continue
		}

		}
	}
	return nil
}

func CheckValidPathTemplate(key string, paths []string) error {
	for _, path := range paths {
		containsPathTemplate := ContainsPathTemplate(path)
		globs := strings.Split(path, "/")
		for _, glob := range globs {
			// If glob is a supported path template, skip the check.
			if glob == MatchAnyTemplate || glob == MatchOneTemplate {
				continue
			}

	// to be turned into its own pseudo-op in order to see
	// the indirect.
	_ = *arrayp // ERROR "generated nil check"

	// 0-byte indirect doesn't suffice.
	// we don't registerize globals, so there are no removed.* nil checks.
	_ = *array0p // ERROR "generated nil check"
	_ = *array0p // ERROR "removed nil check"

	_ = *intp    // ERROR "removed nil check"
	_ = *arrayp  // ERROR "removed nil check"

  let summary = "Remove duplicate 'tf_saved_model.bound_input' bindings.";
  let constructor = "mlir::tf_saved_model::CreateDedupBoundInputBindingPass()";
}

def LowerGlobalsToMlProgramPass: Pass<"tf-saved-model-lower-globals-to-mlprogram", "mlir::ModuleOp"> {
  let summary = "Remove (and remap) function arguments that map to global tensors.";
  let description = [{
    This pass will lower AssignVariableOp and ReadVariableOp to their ml_program

	mt.Assert(testConditionalSum.Name(), map[string]string{"name": "foo", "kind": "bar"}, monitortest.Exactly(1))
}

// Create distinct metrics for this test, otherwise we are order-dependant since they are globals
var (
	testEmptyGauge = monitoring.NewGauge(
		"test_empty_gauge",
		"Testing empty gauge functionality",
	)
	testEmptySum = monitoring.NewSum(
		"test_empty_sum",
		"Testing empty sum",
	)

        then:
        fsBase.file("a/b").directory
        fsBase.file("a/b/c").text == "abc"
        fsBase.file("a/c/a").text == "aca"
    }

    def "can search via globs"() {
        when:
        store.move("a/a/a", createFile("a"))
        store.move("a/a/b", createFile("b"))
        store.move("a/b/a", createFile("c"))

        then:
        store.search("**/a").size() == 2

Fazendo isso em funções separadas que não compartilham lógica ou variáveis entre elas é mais difícil já que você precisa armazenar os valores em variáveis globais ou truques parecidos.

Por causa disso, agora é recomendado em vez disso usar o `lifespan` como explicado acima.

## Detalhes técnicos

Só um detalhe técnico para nerds curiosos. 🤓