Function builtinComparator

array.go:1744–1829

(opChain *chain, array []interface{})

}

func builtinComparator(opChain *chain, array []interface{}) func(x, y *Value) bool {
	var prev interface{}
	for index, curr := range array {
		switch curr.(type) {
		case bool, float64, string, nil:
			// ok, do nothing

		default:
			opChain.fail(AssertionFailure{
				Type: AssertBelongs,
				Actual: &AssertionValue{
					unquotedType(fmt.Sprintf("%T", curr)),
				},
				Expected: &AssertionValue{AssertionList{
					unquotedType("Boolean (bool)"),
					unquotedType("Number (int*, uint*, float*)"),
					unquotedType("String (string)"),
					unquotedType("Null (nil)"),
				}},
				Reference: &AssertionValue{
					array,
				},
				Errors: []error{
					errors.New("expected: type of each element of reference array" +
						" belongs to allowed list"),
					fmt.Errorf("element %v has disallowed type %T", index, curr),
				},
			})
			return nil
		}

		if index > 0 && fmt.Sprintf("%T", curr) != fmt.Sprintf("%T", prev) {
			opChain.fail(AssertionFailure{
				Type: AssertEqual,
				Actual: &AssertionValue{
					unquotedType(fmt.Sprintf("%T (type of element %v)", curr, index)),
				},
				Expected: &AssertionValue{
					unquotedType(fmt.Sprintf("%T (type of element %v)", prev, index-1)),
				},
				Reference: &AssertionValue{
					array,
				},
				Errors: []error{
					errors.New("expected:" +
						" types of all elements of reference array are the same"),
					fmt.Errorf("element %v has type %T, but element %v has type %T",
						index-1, prev, index, curr),
				},
			})
			return nil
		}

		prev = curr
	}

	if len(array) > 1 {
		switch array[0].(type) {