{
            dash: [8, 10],
            fill: 'dash',
          }
        ),
      ]),


    bars(title, targets, desc=''):
      self.base(title, targets, desc)
      + options.legend.withCalcs([])
      + options.legend.withDisplayMode('list')
      + custom.withDrawStyle('bars')
      + custom.withStacking({ mode: 'normal' })
      + timeSeries.queryOptions.withInterval('15s')

                  "uid": "-- Mixed --"
               },
               "fieldConfig": {
                  "defaults": {
                     "custom": {
                        "drawStyle": "bars",
                        "fillOpacity": 10,
                        "showPoints": "never"
                     },
                     "unit": "s"
                  },
                  "overrides": [

            "type": "datasource",
            "uid": "-- Mixed --"
         },
         "fieldConfig": {
            "defaults": {
               "custom": {
                  "drawStyle": "bars",
                  "fillOpacity": 100,
                  "gradientMode": "none",
                  "showPoints": "never",
                  "stacking": {
                     "mode": "normal"
                  }

            "type": "datasource",
            "uid": "-- Mixed --"
         },
         "fieldConfig": {
            "defaults": {
               "custom": {
                  "drawStyle": "bars",
                  "fillOpacity": 100,
                  "gradientMode": "none",
                  "showPoints": "never",
                  "stacking": {
                     "mode": "normal"
                  }

            "axisCenteredZero": false,
            "axisColorMode": "text",
            "axisLabel": "",
            "axisPlacement": "auto",
            "barAlignment": 0,
            "drawStyle": "bars",
            "fillOpacity": 100,
            "gradientMode": "none",
            "hideFrom": {
              "legend": false,
              "tooltip": false,
              "viz": false
            },

func (S) StructValueMethod()
func (ignored S) StructValueMethodNamedRecv()

func (s *S2) unexported(x int8, y int16, z int64) {}

func Bar(x int8, y int16, z int64)                  {}
func Bar1(x int8, y int16, z int64) uint64          {}
func Bar2(x int8, y int16, z int64) (uint8, uint64) {}
func BarE() Error                                   {}

func unexported(x int8, y int16, z int64) {}

func TakesFunc(f func(dontWantName int) int)

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(build);
        }

        Build build2;
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        try (ObjectInputStream ois = new ObjectInputStream(bais)) {
            build2 = (Build) ois.readObject();
        }

pkg p1, const FloatConst = 1.5  // 3/2
pkg p1, const FloatConst ideal-float
pkg p1, const StrConst = "foo"
pkg p1, const StrConst ideal-string
pkg p1, func Bar(int8, int16, int64)
pkg p1, func Bar1(int8, int16, int64) uint64
pkg p1, func Bar2(int8, int16, int64) (uint8, uint64)
pkg p1, func BarE() Error
pkg p1, func Now() Time
pkg p1, func PlainFunc(int, int, string) (*B, error)
pkg p1, func TakesFunc(func(int) int)
pkg p1, method (*B) JustOnB()

        try {
            final ByteArrayOutputStream baos = new ByteArrayOutputStream(BYTE_ARRAY_SIZE);
            final ObjectOutputStream oos = new ObjectOutputStream(baos);
            try {
                oos.writeObject(obj);
            } finally {
                oos.close();
            }
            return baos.toByteArray();
        } catch (final IOException ex) {

   *
   * <p>For example:
   *
   * <pre>{@code
   * Streams.zip(
   *   Stream.of("foo1", "foo2", "foo3"),
   *   Stream.of("bar1", "bar2"),
   *   (arg1, arg2) -> arg1 + ":" + arg2)
   * }</pre>
   *
   * <p>will return {@code Stream.of("foo1:bar1", "foo2:bar2")}.
   *
   * <p>The resulting stream will only be as long as the shorter of the two input streams; if one