yomap

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolBools`: []bool{true, false, true, false},
			},
		},
	},
}

var coolBools []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolBools`}

if ym.BoolInBools(coolBools, true) {
	fmt.Println("Desired boolean found in array of bools")
}

Output:

Desired boolean found in array of bools

// ... see BoolInBools() example, substituting for type as appropriate ... //

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolBytes`: []byte{byte(0x2)},
			},
		},
	},
}

var coolBytes []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolBytes`}

if ym.ByteInBytes(coolBytes, byte(0x2)) {
	fmt.Println("Desired byte sequence found in array of bytes")
}

Output:

Desired byte sequence found in array of bytes

// ... see ByteInBytes() example, substituting for type as appropriate ... //

Output:

// Some complex numbers
c128 := 0.17 + 0.4i
c128a := 0.61 + 0.4i
c128b := 0.34 + 0.1i
c128c := 0.59 + 0.5i

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolNumbers`: []complex128{complex128(c128), complex128(c128a), complex128(c128b), complex128(c128c)},
			},
		},
	},
}

var coolNumbers []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolNumbers`}

if ym.Complex128InComplex128s(coolNumbers, complex128(c128a)) {
	fmt.Println("Desired complex128 found in array of complex128s")
}

Output:

Desired complex128 found in array of complex128s

// ... see the Complex128inComplex128s() example, substituting for type as appropriate ...//

Output:

// Some complex numbers
c64 := 0.17 + 0.4i
c64a := 0.61 + 0.4i
c64b := 0.34 + 0.1i
c64c := 0.59 + 0.5i

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolNumbers`: []complex64{complex64(c64), complex64(c64a), complex64(c64b), complex64(c64c)},
			},
		},
	},
}

var coolNumbers []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolNumbers`}

if ym.Complex64InComplex64s(coolNumbers, complex64(c64a)) {
	fmt.Println("Desired complex64 found in array of complex64s")
}

Output:

Desired complex64 found in array of complex64s

// ... see the Complex64inComplex64s() example, substituting for type as appropriate ...//

Output:

ym := YoMap{
	`coolString`: `true`,
	`coolBytes`:  []byte(`...someBytes...`),
	`coolBool`:   true,
}
ym.Delete([]string{`coolString`})
fmt.Printf("YoMap should be %d entries long now", ym.Len())

Output:

YoMap should be 2 entries long now

// Some weird array of mixed-types
ifs := make([]interface{}, 5)
ifs[0] = float32(3.14)
ifs[1] = float64(3.14159)
ifs[2] = []byte(`{"jsonKey": "someValue"}`)
ifs[3] = string("Testing 1 2 3")
//ifs[4] = bool(true)	// leave one unpopulated

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`mixed`: ifs,
			`thirdLevel`: YoMap{
				`coolFloats`: []float64{3.14, 3.1415, 3.14159},
			},
		},
	},
	`coolString`:  `very cool`,
	`coolStrings`: []string{`string1`, `string2`, `string3`, `string4`, `string5`, `string6`},
	`coolInts`:    []int{1, 2, 3, 4},
	`coolBools`:   []bool{true, false, true, false, true},
}

els := ym.Elements([]string{`coolStrings`})
eli := ym.Elements([]string{`coolInts`})
elb := ym.Elements([]string{`coolBools`})
elf := ym.Elements([]string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolFloats`})
elm := ym.Elements([]string{`firstLevel`, `secondLevel`, `mixed`})
lie := ym.Elements([]string{`coolString`})
empty := ym.Elements()
fmt.Printf("Strings: %d, Ints: %d, Bools: %d, Floats: %d, Mixed: %d, Single String: %d, Empty: %d", els, eli, elb, elf, elm, lie, empty)

Output:

Strings: 6, Ints: 4, Bools: 5, Floats: 3, Mixed: 4, Single String: 1, Empty: 0

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []error{fmt.Errorf("Error1"), fmt.Errorf("Error2"), fmt.Errorf("Error3")},
			},
		},
	},
}

var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.ErrorInErrors(coolMulti, fmt.Errorf("Error1")) {
	fmt.Println("Desired error found in array of errors")
}

Output:

Desired error found in array of errors

// ... see the ErrorInErrors() example, substituting for type as appropriate ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolNumbers`: []float32{3.14, 3.141, 3.1415, 3.14159},
			},
		},
	},
}

var coolNumbers []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolNumbers`}

if ym.Float32InFloat32s(coolNumbers, float32(3.14159)) {
	fmt.Println("Desired float32 found in array of float32s")
}

Output:

Desired float32 found in array of float32s

// ... see Float32InFloat32s() example, substituting for type as appropriate ... //

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolNumbers`: []float64{3.14, 3.141, 3.1415, 3.14159},
			},
		},
	},
}

var coolNumbers []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolNumbers`}

if ym.Float64InFloat64s(coolNumbers, float64(3.14159)) {
	fmt.Println("Desired float64 found in array of float64s")
}

Output:

Desired float64 found in array of float64s

// ... see Float64InFloat64s() example, substituting for type as appropriate ... //

Output:

ym := YoMap{
	`coolString`: true,
	`coolBytes`:  []byte(`bytes`),
	`coolBool`:   true,
}
cool := ym.Get([]string{`coolBool`}) // will be an interface{} unless type-asserted!
if _, isBool := cool.(bool); isBool {
	fmt.Printf("It's a bool? %v", isBool)
}

Output:

It's a bool? true

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolBool`: true,
			},
		},
	},
}

var (
	coolBool []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolBool`}
)

if ym.GetBoolEquals(coolBool, true) {
	fmt.Println("coolBool matched!")
}

Output:

coolBool matched!

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolByte`: byte(0x1),
			},
		},
	},
}

var (
	coolByte []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolByte`}
)

if ym.GetByteEquals(coolByte, byte(0x1)) {
	fmt.Println("coolByte matched!")
}

Output:

coolByte matched!

ym := YoMap{
	`coolString`: true,
	`coolBytes`:  []byte(`false`),
	`coolBool`:   true,
}
ym.Set([]string{`coolBytes`}, []byte(`true`))
coolBytes := ym.GetBytes([]string{`coolBytes`}) // will be []byte, no type assertion needed
fmt.Printf("%s: %v", string(coolBytes), coolBytes)

Output:

true: [116 114 117 101]

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolBytes`: []byte(`{"someKey":"someValue"}`),
			},
		},
	},
}

var (
	coolBytes []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolBytes`}
)

if ym.GetBytesEquals(coolBytes, []byte(`{"someKey":"someValue"}`)) {
	fmt.Println("coolBytes matched!")
}

Output:

coolBytes matched!

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolComplex128`: 0.61 + 0.4i,
			},
		},
	},
}

var (
	coolComplex128 []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolComplex128`}
)

if ym.GetComplex128Equals(coolComplex128, 0.61+0.4i) {
	fmt.Println("coolComplex128 matched!")
}

Output:

coolComplex128 matched!

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolComplex64`: complex64(0.61 + 0.4i),
			},
		},
	},
}

var (
	coolComplex64 []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolComplex64`}
)

if ym.GetComplex64Equals(coolComplex64, complex64(0.61+0.4i)) {
	fmt.Println("coolComplex64 matched!")
}

Output:

coolComplex64 matched!

ym := YoMap{
	`coolError`: fmt.Errorf("This is a pretty rad error"),
	`coolBool`:  true,
}
coolError := ym.GetError([]string{`coolError`}) // will be error, no type assertion needed
fmt.Printf("%s", coolError.Error())

Output:

This is a pretty rad error

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolError`: fmt.Errorf("This is a pretty rad error"),
			},
		},
	},
}

var (
	coolError []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolError`}
)

if ym.GetErrorEquals(coolError, fmt.Errorf("This is a pretty rad error")) {
	fmt.Println("coolError matched!")
}

Output:

coolError matched!

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolFloat32`: float32(3.14),
			},
		},
	},
}

var (
	coolFloat32 []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolFloat32`}
)

if ym.GetFloat32Equals(coolFloat32, float32(3.14)) {
	fmt.Println("coolFloat32 matched!")
}

Output:

coolFloat32 matched!

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolFloat64`: 3.14,
			},
		},
	},
}

var (
	coolFloat64 []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolFloat64`}
)

if ym.GetFloat64Equals(coolFloat64, 3.14) {
	fmt.Println("coolFloat64 matched!")
}

Output:

coolFloat64 matched!

// See GetIntEquals() example, substituting for desired int type

Output:

// See GetIntEquals() example, substituting for desired int type

Output:

// See GetIntEquals() example, substituting for desired int type

Output:

// See GetIntEquals() example, substituting for desired int type

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolInt`: 42,
			},
		},
	},
}

var (
	coolInt []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolInt`}
)

if ym.GetIntEquals(coolInt, 42) {
	fmt.Println("coolInt matched!")
}

Output:

coolInt matched!

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolRune`: 'c',
			},
		},
	},
}

var (
	coolRune []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolRune`}
)

if ym.GetRuneEquals(coolRune, 'c') {
	fmt.Println("coolRune matched!")
}

Output:

coolRune matched!

ym := YoMap{
	`coolString`: `false`,
	`coolBytes`:  []byte(`false`),
	`coolBool`:   true,
}
ym.Set([]string{`coolString`}, `true`)
coolString := ym.GetString([]string{`coolString`}) // will be string, no type assertion needed
fmt.Printf("%s", coolString)

Output:

true

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolString`: `cats rule!`,
			},
		},
	},
	`coolKey`: `importantV@lu3`,
}

var (
	coolString []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolString`}
	coolKey    []string = []string{`coolKey`}
)

if ym.GetStringEquals(coolKey, `importantV@lu3`) && ym.GetStringEquals(coolString, `cats rule!`) {
	fmt.Println("coolString and coolKey both matched!")
}

Output:

coolString and coolKey both matched!

// See GetUintEquals() example, substituting for desired int type

Output:

// See GetUintEquals() example, substituting for desired int type

Output:

// See GetUintEquals() example, substituting for desired int type

Output:

// See GetUintEquals() example, substituting for desired int type

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolUint`: uint(42),
			},
		},
	},
}

var (
	coolUint []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolUint`}
)

if ym.GetUintEquals(coolUint, uint(42)) {
	fmt.Println("coolUint matched!")
}

Output:

coolUint matched!

ym := YoMap{
	`coolYoMap`: YoMap{
		`otherCoolString`: false,
		`otherCoolBytes`:  []byte(`false`),
		`coolBool`:        true,
	},
	`coolString`: `false`,
	`coolBytes`:  []byte(`false`),
	`coolBool`:   true,
}
cym := ym.GetYoMap([]string{`coolYoMap`}) // will be YoMap, no type assertion needed
fmt.Printf("YoMap.CoolYoMap is %d entries long", cym.Len())

Output:

YoMap.CoolYoMap is 3 entries long

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolString`: `this is pretty awesome!`,
				`lameString`: `I don't like cats`,
			},
		},
	},
}
var path []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolString`}
if ym.Has(path) && ym.IsString(path) {
	g := ym.Get(path).(string)
	fmt.Printf("Found: %s", g)
}

Output:

Found: this is pretty awesome!

// ... see IntInInts() example, substituting for type as appropriate ... //

Output:

// ... see IntInInts() example, substituting for type as appropriate ... //

Output:

// ... see IntInInts() example, substituting for type as appropriate ... //

Output:

// ... see IntInInts() example, substituting for type as appropriate ... //

Output:

// ... see IntInInts() example, substituting for type as appropriate ... //

Output:

// ... see IntInInts() example, substituting for type as appropriate ... //

Output:

// ... see IntInInts() example, substituting for type as appropriate ... //

Output:

// ... see IntInInts() example, substituting for type as appropriate ... //

Output:

// ... see IntInInts() example, substituting for type as appropriate ... //

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolNumbers`: []int{1, 2, 3, 4},
			},
		},
	},
}

var coolNumbers []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolNumbers`}

if ym.IntInInts(coolNumbers, 4) {
	fmt.Println("Desired int found in array of ints")
}

Output:

Desired int found in array of ints

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: true,
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []bool{false, false, false, false, true},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsBool(coolSingle) && ym.IsBools(coolMulti) {
	fmt.Println("coolSingle is a bool, and coolMulti is an array of bools")
}

Output:

coolSingle is a bool, and coolMulti is an array of bools

// ... see the IsBool() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: byte(0x1),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []byte(`{"jsonKey": "jsonValue"}`),
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsByte(coolSingle) && ym.IsBytes(coolMulti) {
	fmt.Println("coolSingle is a byte, and coolMulti is an array of bytes")
}

Output:

coolSingle is a byte, and coolMulti is an array of bytes

// ... see the IsByte() example ...//

Output:

// Some complex numbers
c128 := 0.17 + 0.4i
c128a := 0.61 + 0.4i
c128b := 0.34 + 0.1i
c128c := 0.59 + 0.5i

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: c128,
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []complex128{c128a, c128b, c128c},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsComplex128(coolSingle) && ym.IsComplex128s(coolMulti) {
	fmt.Println("coolSingle is a complex128, and coolMulti is an array of complex128s")
}

Output:

coolSingle is a complex128, and coolMulti is an array of complex128s

// ... see the IsComplex128() example ...//

Output:

// Some complex numbers
c64 := 0.17 + 0.4i
c64a := 0.61 + 0.4i
c64b := 0.34 + 0.1i
c64c := 0.59 + 0.5i

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: complex64(c64),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []complex64{complex64(c64a), complex64(c64b), complex64(c64c)},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsComplex64(coolSingle) && ym.IsComplex64s(coolMulti) {
	fmt.Println("coolSingle is a complex64, and coolMulti is an array of complex64s")
}

Output:

coolSingle is a complex64, and coolMulti is an array of complex64s

// ... see the IsComplex64() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: fmt.Errorf("Error 501: User dislikes cats"),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []error{fmt.Errorf("Error1"), fmt.Errorf("Error2"), fmt.Errorf("Error3")},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsError(coolSingle) && ym.IsErrors(coolMulti) {
	fmt.Println("coolSingle is an error, and coolMulti is an array of errors")
}

Output:

coolSingle is an error, and coolMulti is an array of errors

// ... see the IsError() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: float32(3.14),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []float32{3.14, 3.141, 3.1415},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsFloat32(coolSingle) && ym.IsFloat32s(coolMulti) {
	fmt.Println("coolSingle is a float32, and coolMulti is an array of float32s")
}

Output:

coolSingle is a float32, and coolMulti is an array of float32s

// ... see the IsFloat32() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: float64(3.14),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []float64{3.14, 3.141, 3.1415},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsFloat64(coolSingle) && ym.IsFloat64s(coolMulti) {
	fmt.Println("coolSingle is a float64, and coolMulti is an array of float64s")
}

Output:

coolSingle is a float64, and coolMulti is an array of float64s

// ... see the IsFloat64() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: int(3054957437),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []int{0, -1, 78243, 342},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsInt(coolSingle) && ym.IsInts(coolMulti) {
	fmt.Println("coolSingle is a int, and coolMulti is an array of ints")
}

Output:

coolSingle is a int, and coolMulti is an array of ints

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: int16(3054),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []int16{0, -1, 782, 342},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsInt16(coolSingle) && ym.IsInt16s(coolMulti) {
	fmt.Println("coolSingle is a int, and coolMulti is an array of ints")
}

Output:

coolSingle is a int, and coolMulti is an array of ints

// ... see the IsInt16() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: int32(3054957),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []int32{0, -1, 78243, 342},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsInt32(coolSingle) && ym.IsInt32s(coolMulti) {
	fmt.Println("coolSingle is a int, and coolMulti is an array of ints")
}

Output:

coolSingle is a int, and coolMulti is an array of ints

// ... see the IsInt32() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: int64(3054957437),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []int64{0, -1, 78243, 342},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsInt64(coolSingle) && ym.IsInt64s(coolMulti) {
	fmt.Println("coolSingle is a int, and coolMulti is an array of ints")
}

Output:

coolSingle is a int, and coolMulti is an array of ints

// ... see the IsInt64() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: int8(30),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []int8{0, -1, 78, 42},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsInt8(coolSingle) && ym.IsInt8s(coolMulti) {
	fmt.Println("coolSingle is a int, and coolMulti is an array of ints")
}

Output:

coolSingle is a int, and coolMulti is an array of ints

// ... see the IsInt8() example ...//

Output:

// Some weird array of mixed-types
ifs := make([]interface{}, 4)
ifs[0] = float32(3.14)
ifs[1] = float64(3.14159)
ifs[2] = []byte(`{"jsonKey": "someValue"}`)
ifs[3] = string("Testing 1 2 3")

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: ifs,
			},
		},
	},
}

var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsInterfaces(coolMulti) {
	fmt.Println("coolMulti is an array of interfaces")
}

Output:

coolMulti is an array of interfaces

// ... see the IsInt() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: nil,
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []error{nil, nil, nil},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}

if ym.IsNil(coolSingle) {
	fmt.Println("coolSingle is a nil")
}

Output:

coolSingle is a nil

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: 'c',
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []rune{'a', 'b', 'c'},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsRune(coolSingle) && ym.IsRunes(coolMulti) {
	fmt.Println("coolSingle is a rune, and coolMulti is an array of runes")
}

Output:

coolSingle is a rune, and coolMulti is an array of runes

// ... see the IsRune() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: `quite cool`,
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []string{`false`, `blarg`, `_____`, `Hello.`},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsString(coolSingle) && ym.IsStrings(coolMulti) {
	fmt.Println("coolSingle is a string, and coolMulti is an array of strings")
}

Output:

coolSingle is a string, and coolMulti is an array of strings

// ... see the IsString() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: uint(3054957437),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []uint{0, 53, 78243, 342},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsUint(coolSingle) && ym.IsUints(coolMulti) {
	fmt.Println("coolSingle is a uint, and coolMulti is an array of uints")
}

Output:

coolSingle is a uint, and coolMulti is an array of uints

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: uint16(30545),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []uint16{0, 53, 7243, 342},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsUint16(coolSingle) && ym.IsUint16s(coolMulti) {
	fmt.Println("coolSingle is a uint, and coolMulti is an array of uints")
}

Output:

coolSingle is a uint, and coolMulti is an array of uints

// ... see the IsUint16() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: uint32(30549577),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []uint32{0, 53, 78243, 342},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsUint32(coolSingle) && ym.IsUint32s(coolMulti) {
	fmt.Println("coolSingle is a uint, and coolMulti is an array of uints")
}

Output:

coolSingle is a uint, and coolMulti is an array of uints

// ... see the IsUint32() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: uint64(3054957437),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []uint64{0, 53, 78243, 342},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsUint64(coolSingle) && ym.IsUint64s(coolMulti) {
	fmt.Println("coolSingle is a uint, and coolMulti is an array of uints")
}

Output:

coolSingle is a uint, and coolMulti is an array of uints

// ... see the IsUint64() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: uint8(30),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []uint8{0, 53, 254, 142},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsUint8(coolSingle) && ym.IsUint8s(coolMulti) {
	fmt.Println("coolSingle is a uint, and coolMulti is an array of uints")
}

Output:

coolSingle is a uint, and coolMulti is an array of uints

// ... see the IsUint8() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`coolSingle`: uintptr(437853),
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []uintptr{432875, 53234, 18845, 24536},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `coolSingle`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.IsUintptr(coolSingle) && ym.IsUintptrs(coolMulti) {
	fmt.Println("coolSingle is a uintptr, and coolMulti is an array of uintptrs")
}

Output:

coolSingle is a uintptr, and coolMulti is an array of uintptrs

// ... see the IsUintptr() example ...//

Output:

// ... see the IsUint() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: []YoMap{
				{`test`: `haha`},
				{`notfunny`: `true`},
			},
		},
	},
}

var coolSingle []string = []string{`firstLevel`, `secondLevel`}
var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`}

if ym.IsYoMap(coolSingle) && ym.IsYoMaps(coolMulti) {
	fmt.Println("coolSingle is a yomap, and coolMulti is an array of yomaps")
}

Output:

coolSingle is a yomap, and coolMulti is an array of yomaps

// ... see the IsYoMap() example ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolString`: `this is pretty awesome!`,
			},
		},
	},
}
var path []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `lameString`}
if ym.Lacks(path) {
	fmt.Println("lameString didn't exist")
}

Output:

lameString didn't exist

ym := YoMap{
	`coolString`: true,
	`coolBytes`:  []byte(`bytes`),
	`coolBool`:   true,
}
fmt.Printf("YoMap is %d entries long", ym.Len())

Output:

YoMap is 3 entries long

// ... see ErrorInInterfaces() example, substituting with nil ... //

Output:

ym := New()
if ym.Ready() {
	fmt.Printf("This YoMap instance is so ready")
}

Output:

This YoMap instance is so ready

ym := YoMap{
	`coolString`: true,
	`coolBytes`:  []byte(`bytes`),
	`coolBool`:   true,
}
ym.Reset()
fmt.Printf("%d entries remaining in YoMap", ym.Len())

Output:

0 entries remaining in YoMap

// ... see the RuneInRunes() example, substituting for type as appropriate ...//

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []rune{'a', 'b', 'c'},
			},
		},
	},
}

var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.RuneInRunes(coolMulti, 'c') {
	fmt.Println("Desired rune found in array of runes")
}

Output:

Desired rune found in array of runes

ym := YoMap{
	`coolString`: `true`,
	`coolBytes`:  []byte(`...someBytes...`),
	`coolBool`:   true,
}
ym.Set([]string{`coolError`}, fmt.Errorf("Coolness limit has been exceeded"))
ym.Set([]string{`coolInt`}, 1)

length := ym.Len()
fmt.Printf("YoMap is %d entries long", length)

Output:

YoMap is 5 entries long

ym := YoMap{
	`coolString`: `true`,
	`coolBytes`:  []byte(`...someBytes...`),
	`coolBool`:   true,
}
ym.String()

// This should print the following to Stdout:
//coolString:		true (type:string)
//coolBytes:		[46 46 46 115 111 109 101 66 121 116 101 115 46 46 46] (type:[]uint8)
//coolBool:		true (type:bool)

Output:

// ... see StringInStrings() example, substituting for type as appropriate ... //

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolStrings`: []string{`string1`, `string2`, `string3`},
			},
		},
	},
}

var coolStrings []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolStrings`}

if ym.StringInStrings(coolStrings, `string1`) {
	fmt.Println("Desired string found in array of strings")
}

Output:

Desired string found in array of strings

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolUnknownThing`: 3.14159,
			},
		},
	},
}

var path []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolUnknownThing`}

fmt.Printf("%s", ym.TypeOf(path))

Output:

float64

// ... see UintInUints() example, substituting for type as appropriate ... //

Output:

// ... see UintInUints() example, substituting for type as appropriate ... //

Output:

// ... see UintInUints() example, substituting for type as appropriate ... //

Output:

// ... see UintInUints() example, substituting for type as appropriate ... //

Output:

// ... see IntInInts() example, substituting for type as appropriate ... //

Output:

// ... see UintInUints() example, substituting for type as appropriate ... //

Output:

// ... see UintInUints() example, substituting for type as appropriate ... //

Output:

// ... see UintInUints() example, substituting for type as appropriate ... //

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolNumbers`: []uint{1, 2, 3, 4},
			},
		},
	},
}

var coolNumbers []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolNumbers`}

if ym.UintInUints(coolNumbers, uint(4)) {
	fmt.Println("Desired uint found in array of uints")
}

Output:

Desired uint found in array of uints

// ... see the UintptrInUintptrs() example, substituting for type as appropriate ... //

Output:

ym := YoMap{
	`firstLevel`: YoMap{
		`secondLevel`: YoMap{
			`thirdLevel`: YoMap{
				`coolMulti`: []uintptr{432875, 53234, 18845, 24536},
			},
		},
	},
}

var coolMulti []string = []string{`firstLevel`, `secondLevel`, `thirdLevel`, `coolMulti`}

if ym.UintptrInUintptrs(coolMulti, uintptr(53234)) {
	fmt.Println("Desired uintptr found in array of uintptrs")
}

Output:

Desired uintptr found in array of uintptrs