code: func (l *Loader) Load(module string) (syms *Struct, err error) {
  	defer func() {
  		err = errors.Annotate(err, "in %s", module).Err()
  	}()
  
  	l.init()
  	if !l.loading.Add(module) {
  		return nil, errors.New("recursive dependency")
  	}
  	defer l.loading.Del(module)
  
  	// Already processed it?
  	if syms, ok := l.symbols[module]; ok {
  		return syms, nil
  	}
  
  	// Load and parse the source code into a distilled AST.
  	src, err := l.Source(module)
  	if err != nil {
  		return nil, err
  	}
  	l.sources[module] = src
  	mod, err := ast.ParseModule(module, src)
  	if err != nil {
  		return nil, err
  	}
  
  	// Recursively resolve all references in 'mod' to their concrete definitions
  	// (perhaps in other modules). This returns a struct with a list of all
  	// symbols defined in the module.
  	var top *Struct
  	if top, err = l.resolveRefs(&mod.Namespace, nil); err != nil {
  		return nil, err
  	}
  	l.symbols[module] = top
  	return top, nil
  }
docs: // Loads loads the module and all modules it references, populating the
  // loader's state with information about exported symbols.
  //
  // Returns a struct with a list of symbols defined in the module.
  //
  // Can be called multiple times with different modules.