YAML reader for CUE

This yaml parser is a heavily modified version of Canonical's go-yaml parser, which in turn is a port of the libyaml parser.


The yaml package is licensed under the Apache License 2.0. Please see the LICENSE file for details.

Expand ▾ Collapse ▴



    Package yaml implements YAML support for the Go language.

    Source code and other details for the project are available at GitHub:



    This section is empty.


    This section is empty.


    func Unmarshal

    func Unmarshal(filename string, in []byte) (expr ast.Expr, err error)

      Unmarshal decodes the first document found within the in byte slice and assigns decoded values into the out value.

      Maps and pointers (to a struct, string, int, etc) are accepted as out values. If an internal pointer within a struct is not initialized, the yaml package will initialize it if necessary for unmarshalling the provided data. The out parameter must not be nil.

      The type of the decoded values should be compatible with the respective values in out. If one or more values cannot be decoded due to a type mismatches, decoding continues partially until the end of the YAML content, and a *yaml.TypeError is returned with details for all missed values.

      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 (see Marshal). Conflicting names result in a runtime error.

      For example:

      type T struct {
          F int `yaml:"a,omitempty"`
          B int
      var t T
      yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)

      See the documentation of Marshal for the format of tags and a list of supported tag options.


      type Decoder

      type Decoder struct {
      	// contains filtered or unexported fields

        A Decorder reads and decodes YAML values from an input stream.

        func NewDecoder

        func NewDecoder(filename string, src interface{}) (*Decoder, error)

          NewDecoder returns a new decoder that reads from r.

          The decoder introduces its own buffering and may read data from r beyond the YAML values requested.

          func (*Decoder) Decode

          func (dec *Decoder) Decode() (expr ast.Expr, err error)

            Decode reads the next YAML-encoded value from its input and stores it in the value pointed to by v. It returns io.EOF if there are no more value in the stream.

            See the documentation for Unmarshal for details about the conversion of YAML into a Go value.

            type IsZeroer

            type IsZeroer interface {
            	IsZero() bool

              IsZeroer is used to check whether an object is zero to determine whether it should be omitted when marshaling with the omitempty flag. One notable implementation is time.Time.

              type MapItem

              type MapItem struct {
              	Key, Value interface{}

                MapItem is an item in a MapSlice.

                type MapSlice

                type MapSlice []MapItem

                  MapSlice encodes and decodes as a YAML map. The order of keys is preserved when encoding and decoding.

                  type Marshaler

                  type Marshaler interface {
                  	MarshalYAML() (interface{}, error)

                    The Marshaler interface may be implemented by types to customize their behavior when being marshaled into a YAML document. The returned value is marshaled in place of the original value implementing Marshaler.

                    If an error is returned by MarshalYAML, the marshaling procedure stops and returns with the provided error.

                    type TypeError

                    type TypeError struct {
                    	Errors []string

                      A TypeError is returned by Unmarshal when one or more fields in the YAML document cannot be properly decoded into the requested types. When this error is returned, the value is still unmarshaled partially.

                      func (*TypeError) Error

                      func (e *TypeError) Error() string

                      type Unmarshaler

                      type Unmarshaler interface {
                      	UnmarshalYAML(unmarshal func(interface{}) error) error

                        The Unmarshaler interface may be implemented by types to customize their behavior when being unmarshaled from a YAML document. The UnmarshalYAML method receives a function that may be called to unmarshal the original YAML value into a field or variable. It is safe to call the unmarshal function parameter more than once if necessary.