code: func Marshal(in interface{}) (out []byte, err error) {
  	defer handleErr(&err)
  	e := newEncoder()
  	defer e.destroy()
  	e.marshal("", reflect.ValueOf(in))
  	e.finish()
  	out = e.out
  	return
  }
docs: // Marshal serializes the value provided into a YAML document. The structure
  // of the generated document will reflect the structure of the value itself.
  // Maps and pointers (to struct, string, int, etc) are accepted as the in value.
  //
  // Struct fields are only unmarshalled if they are exported (have an upper case
  // first letter), and are unmarshalled using the field name lowercased as the
  // default key. Custom keys may be defined via the "yaml" name in the field
  // tag: the content preceding the first comma is used as the key, and the
  // following comma-separated options are used to tweak the marshalling process.
  // Conflicting names result in a runtime error.
  //
  // The field tag format accepted is:
  //
  //     `(...) yaml:"[<key>][,<flag1>[,<flag2>]]" (...)`
  //
  // The following flags are currently supported:
  //
  //     omitempty    Only include the field if it's not set to the zero
  //                  value for the type or to empty slices or maps.
  //                  Does not apply to zero valued structs.
  //
  //     flow         Marshal using a flow style (useful for structs,
  //                  sequences and maps.
  //
  //     inline       Inline the struct it's applied to, so its fields
  //                  are processed as if they were part of the outer
  //                  struct.
  //
  // In addition, if the key is "-", the field is ignored.
  //
  // For example:
  //
  //     type T struct {
  //         F int "a,omitempty"
  //         B int
  //     }
  //     yaml.Marshal(&T{B: 2}) // Returns "b: 2\n"
  //     yaml.Marshal(&T{F: 1}} // Returns "a: 1\nb: 0\n"
  //