code: func (tl TypeLoader) LoadProcs(args *ArgType) (map[string]*Proc, error) {
  	var err error
  
  	// not supplied, so bail
  	if tl.ProcList == nil {
  		return nil, nil
  	}
  
  	// load procs
  	procList, err := tl.ProcList(args.DB, args.Schema)
  	if err != nil {
  		return nil, err
  	}
  
  	// process procs
  	procMap := map[string]*Proc{}
  	for _, p := range procList {
  		// fix the name if it starts with one or more underscores
  		name := p.ProcName
  		for strings.HasPrefix(name, "_") {
  			name = name[1:]
  		}
  
  		// create template
  		procTpl := &Proc{
  			Name:   snaker.SnakeToCamelIdentifier(name),
  			Schema: args.Schema,
  			Params: []*Field{},
  			Return: &Field{},
  			Proc:   p,
  		}
  
  		// parse return type into template
  		// TODO: fix this so that nullable types can be returned
  		_, procTpl.Return.NilType, procTpl.Return.Type = tl.ParseType(args, p.ReturnType, false)
  
  		// load proc parameters
  		err = tl.LoadProcParams(args, procTpl)
  		if err != nil {
  			return nil, err
  		}
  
  		procMap[p.ProcName] = procTpl
  	}
  
  	// generate proc templates
  	for _, p := range procMap {
  		err = args.ExecuteTemplate(ProcTemplate, "sp_"+p.Name, "", p)
  		if err != nil {
  			return nil, err
  		}
  	}
  
  	return procMap, nil
  }
docs: // LoadProcs loads schema stored procedures definitions.