func SetValEmpty(element Type) Value {
	return Value{
		ty: Set(element),
		v:  set.NewSet(setRules{element}),
	}
}
SetValEmpty returns an empty set of the given element type.
package cty
import (
	"fmt"
	"math/big"
	"reflect"
	"golang.org/x/text/unicode/norm"
	"github.com/zclconf/go-cty/cty/set"
)
func BoolVal(v bool) Value {
	return Value{
		ty: Bool,
		v:  v,
	}
}
func NumberVal(v *big.Float) Value {
	return Value{
		ty: Number,
		v:  v,
	}
}
func ParseNumberVal(s string) (Value, error) {
	f, _, err := big.ParseFloat(s, 10, 512, big.ToNearestEven)
	if err != nil {
		return NilVal, fmt.Errorf("a number is required")
	}
	return NumberVal(f), nil
}
func MustParseNumberVal(s string) Value {
	ret, err := ParseNumberVal(s)
	if err != nil {
		panic(err)
	}
	return ret
}
func NumberIntVal(v int64) Value {
	return NumberVal(new(big.Float).SetInt64(v))
}
func NumberUIntVal(v uint64) Value {
	return NumberVal(new(big.Float).SetUint64(v))
}
func NumberFloatVal(v float64) Value {
	return NumberVal(new(big.Float).SetFloat64(v))
}
func StringVal(v string) Value {
	return Value{
		ty: String,
		v:  NormalizeString(v),
	}
}
func NormalizeString(s string) string {
	return norm.NFC.String(s)
}
func ObjectVal(attrs map[string]Value) Value {
	attrTypes := make(map[string]Type, len(attrs))
	attrVals := make(map[string]interface{}, len(attrs))
	for attr, val := range attrs {
		attr = NormalizeString(attr)
		attrTypes[attr] = val.ty
		attrVals[attr] = val.v
	}
	return Value{
		ty: Object(attrTypes),
		v:  attrVals,
	}
}
func TupleVal(elems []Value) Value {
	elemTypes := make([]Type, len(elems))
	elemVals := make([]interface{}, len(elems))
	for i, val := range elems {
		elemTypes[i] = val.ty
		elemVals[i] = val.v
	}
	return Value{
		ty: Tuple(elemTypes),
		v:  elemVals,
	}
}
func ListVal(vals []Value) Value {
	if len(vals) == 0 {
		panic("must not call ListVal with empty slice")
	}
	elementType := DynamicPseudoType
	rawList := make([]interface{}, len(vals))
	for i, val := range vals {
		if elementType == DynamicPseudoType {
			elementType = val.ty
		} else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
			panic(fmt.Errorf(
				"inconsistent list element types (%#v then %#v)",
				elementType, val.ty,
			))
		}
		rawList[i] = val.v
	}
	return Value{
		ty: List(elementType),
		v:  rawList,
	}
}
func ListValEmpty(element Type) Value {
	return Value{
		ty: List(element),
		v:  []interface{}{},
	}
}
func MapVal(vals map[string]Value) Value {
	if len(vals) == 0 {
		panic("must not call MapVal with empty map")
	}
	elementType := DynamicPseudoType
	rawMap := make(map[string]interface{}, len(vals))
	for key, val := range vals {
		if elementType == DynamicPseudoType {
			elementType = val.ty
		} else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
			panic(fmt.Errorf(
				"inconsistent map element types (%#v then %#v)",
				elementType, val.ty,
			))
		}
		rawMap[NormalizeString(key)] = val.v
	}
	return Value{
		ty: Map(elementType),
		v:  rawMap,
	}
}
func MapValEmpty(element Type) Value {
	return Value{
		ty: Map(element),
		v:  map[string]interface{}{},
	}
}
func SetVal(vals []Value) Value {
	if len(vals) == 0 {
		panic("must not call SetVal with empty slice")
	}
	elementType := DynamicPseudoType
	rawList := make([]interface{}, len(vals))
	for i, val := range vals {
		if elementType == DynamicPseudoType {
			elementType = val.ty
		} else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
			panic(fmt.Errorf(
				"inconsistent set element types (%#v then %#v)",
				elementType, val.ty,
			))
		}
		rawList[i] = val.v
	}
	rawVal := set.NewSetFromSlice(setRules{elementType}, rawList)
	return Value{
		ty: Set(elementType),
		v:  rawVal,
	}
}
func SetValFromValueSet(s ValueSet) Value {
	ety := s.ElementType()
	rawVal := s.s.Copy()  
	return Value{
		ty: Set(ety),
		v:  rawVal,
	}
}