package stdlib

import (

"errors"

"fmt"

"maps"

"sort"

"github.com/zclconf/go-cty/cty"

"github.com/zclconf/go-cty/cty/convert"

"github.com/zclconf/go-cty/cty/function"

"github.com/zclconf/go-cty/cty/gocty"

)

var HasIndexFunc = function.New(&function.Spec{

Description: `Returns true if if the given collection can be indexed with the given key without producing an error, or false otherwise.`,

Params: []function.Parameter{

{

Name: "collection",

Type: cty.DynamicPseudoType,

AllowDynamicType: true,

},

{

Name: "key",

Type: cty.DynamicPseudoType,

AllowDynamicType: true,

},

},

Type: func(args []cty.Value) (ret cty.Type, err error) {

collTy := args[0].Type()

if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy == cty.DynamicPseudoType) {

return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")

}

return cty.Bool, nil

},

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

return args[0].HasIndex(args[1]), nil

},

})

var IndexFunc = function.New(&function.Spec{

Description: `Returns the element with the given key from the given collection, or raises an error if there is no such element.`,

Params: []function.Parameter{

{

Name: "collection",

Type: cty.DynamicPseudoType,

},

{

Name: "key",

Type: cty.DynamicPseudoType,

AllowDynamicType: true,

},

},

Type: func(args []cty.Value) (ret cty.Type, err error) {

collTy := args[0].Type()

key := args[1]

keyTy := key.Type()

switch {

case collTy.IsTupleType():

if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {

return cty.NilType, fmt.Errorf("key for tuple must be number")

}

if !key.IsKnown() {

return cty.DynamicPseudoType, nil

}

var idx int

err := gocty.FromCtyValue(key, &idx)

if err != nil {

return cty.NilType, fmt.Errorf("invalid key for tuple: %s", err)

}

etys := collTy.TupleElementTypes()

if idx >= len(etys) || idx < 0 {

return cty.NilType, fmt.Errorf("key must be between 0 and %d inclusive", len(etys))

}

return etys[idx], nil

case collTy.IsListType():

if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {

return cty.NilType, fmt.Errorf("key for list must be number")

}

return collTy.ElementType(), nil

case collTy.IsMapType():

if keyTy != cty.String && keyTy != cty.DynamicPseudoType {

return cty.NilType, fmt.Errorf("key for map must be string")

}

return collTy.ElementType(), nil

default:

return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")

}

},

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

has, err := HasIndex(args[0], args[1])

if err != nil {

return cty.NilVal, err

}

if has.False() { // safe because collection and key are guaranteed known here

return cty.NilVal, fmt.Errorf("invalid index")

}

return args[0].Index(args[1]), nil

},

})

var LengthFunc = function.New(&function.Spec{

Description: `Returns the number of elements in the given collection.`,

Params: []function.Parameter{

{

Name: "collection",

Type: cty.DynamicPseudoType,

AllowDynamicType: true,

AllowUnknown: true,

AllowMarked: true,

},

},

Type: func(args []cty.Value) (ret cty.Type, err error) {

collTy := args[0].Type()

if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy.IsSetType() || collTy == cty.DynamicPseudoType) {

return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")

}

return cty.Number, nil

},

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

return args[0].Length(), nil

},

})

var ElementFunc = function.New(&function.Spec{

Description: `Returns the element with the given index from the given list or tuple, applying the modulo operation to the given index if it's greater than the number of elements.`,

Params: []function.Parameter{

{

Name: "list",

Type: cty.DynamicPseudoType,

AllowMarked: true,

},

{

Name: "index",

Type: cty.Number,

},

},

Type: func(args []cty.Value) (cty.Type, error) {

list := args[0]

listTy := list.Type()

switch {

case listTy.IsListType():

return listTy.ElementType(), nil

case listTy.IsTupleType():

if !args[1].IsKnown() {

// If the index isn't known yet then we can't predict the

// result type since each tuple element can have its own type.

return cty.DynamicPseudoType, nil

}

etys := listTy.TupleElementTypes()

var index int

err := gocty.FromCtyValue(args[1], &index)

if err != nil {

// e.g. fractional number where whole number is required

return cty.DynamicPseudoType, fmt.Errorf("invalid index: %s", err)

}

if len(etys) == 0 {

return cty.DynamicPseudoType, errors.New("cannot use element function with an empty list")

}

index = index % len(etys)

if index < 0 {

index += len(etys)

}

return etys[index], nil

default:

return cty.DynamicPseudoType, fmt.Errorf("cannot read elements from %s", listTy.FriendlyName())

}

},

Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {

var index int

err := gocty.FromCtyValue(args[1], &index)

if err != nil {

// can't happen because we checked this in the Type function above

return cty.DynamicVal, fmt.Errorf("invalid index: %s", err)

}

input, marks := args[0].Unmark()

if !input.IsKnown() {

return cty.UnknownVal(retType), nil

}

l := input.LengthInt()

if l == 0 {

return cty.DynamicVal, errors.New("cannot use element function with an empty list")

}

index = index % l

if index < 0 {

index += l

}

// We did all the necessary type checks in the type function above,

// so this is guaranteed not to fail.

return input.Index(cty.NumberIntVal(int64(index))).WithMarks(marks), nil

},

})

// CoalesceListFunc is a function that takes any number of list arguments

// and returns the first one that isn't empty.

var CoalesceListFunc = function.New(&function.Spec{

Description: `Returns the first of the given sequences that has a length greater than zero.`,

Params: []function.Parameter{},

VarParam: &function.Parameter{

Name: "vals",

Description: `List or tuple values to test in the given order.`,

Type: cty.DynamicPseudoType,

AllowUnknown: true,

AllowDynamicType: true,

AllowNull: true,

},

Type: func(args []cty.Value) (ret cty.Type, err error) {

if len(args) == 0 {

return cty.NilType, errors.New("at least one argument is required")

}

argTypes := make([]cty.Type, len(args))

for i, arg := range args {

// if any argument is unknown, we can't be certain know which type we will return

if !arg.IsKnown() {

return cty.DynamicPseudoType, nil

}

ty := arg.Type()

if !ty.IsListType() && !ty.IsTupleType() {

return cty.NilType, errors.New("coalescelist arguments must be lists or tuples")

}

argTypes[i] = arg.Type()

}

last := argTypes[0]

// If there are mixed types, we have to return a dynamic type.

for _, next := range argTypes[1:] {

if !next.Equals(last) {

return cty.DynamicPseudoType, nil

}

}

return last, nil

},

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

for _, arg := range args {

if !arg.IsKnown() {

// If we run into an unknown list at some point, we can't

// predict the final result yet. (If there's a known, non-empty

// arg before this then we won't get here.)

return cty.UnknownVal(retType), nil

}

if arg.IsNull() {

continue

}

if arg.LengthInt() > 0 {

return arg, nil

}

}

return cty.NilVal, errors.New("no non-null arguments")

},

})

// CompactFunc is a function that takes a list of strings and returns a new list

// with any empty string elements removed.

var CompactFunc = function.New(&function.Spec{

Description: `Removes all empty string elements from the given list of strings.`,

Params: []function.Parameter{

{

Name: "list",

Type: cty.List(cty.String),

},

},

Type: function.StaticReturnType(cty.List(cty.String)),

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

listVal := args[0]

if !listVal.IsWhollyKnown() {

// If some of the element values aren't known yet then we

// can't yet return a compacted list

return cty.UnknownVal(retType), nil

}

var outputList []cty.Value

for it := listVal.ElementIterator(); it.Next(); {

_, v := it.Element()

if v.IsNull() || v.AsString() == "" {

continue

}

outputList = append(outputList, v)

}

if len(outputList) == 0 {

return cty.ListValEmpty(cty.String), nil

}

return cty.ListVal(outputList), nil

},

})

// ContainsFunc is a function that determines whether a given list or

// set contains a given single value as one of its elements.

var ContainsFunc = function.New(&function.Spec{

Description: `Returns true if the given value is a value in the given list, tuple, or set, or false otherwise.`,

Params: []function.Parameter{

{

Name: "list",

Type: cty.DynamicPseudoType,

},

{

Name: "value",

Type: cty.DynamicPseudoType,

AllowNull: true,

},

},

Type: function.StaticReturnType(cty.Bool),

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {

arg := args[0]

ty := arg.Type()

if !ty.IsListType() && !ty.IsTupleType() && !ty.IsSetType() {

return cty.NilVal, errors.New("argument must be list, tuple, or set")

}

if args[0].IsNull() {

return cty.NilVal, errors.New("cannot search a nil list or set")

}

if args[0].LengthInt() == 0 {

return cty.False, nil

}

if !args[0].IsKnown() || !args[1].IsKnown() {

return cty.UnknownVal(cty.Bool), nil

}

containsUnknown := false

for it := args[0].ElementIterator(); it.Next(); {

_, v := it.Element()

eq := args[1].Equals(v)

if !eq.IsKnown() {

// We may have an unknown value which could match later, but we

// first need to continue checking all values for an exact

// match.

containsUnknown = true

continue

}

if eq.True() {

return cty.True, nil

}

}

if containsUnknown {

return cty.UnknownVal(cty.Bool), nil

}

return cty.False, nil

},

})

// DistinctFunc is a function that takes a list and returns a new list

// with any duplicate elements removed.

var DistinctFunc = function.New(&function.Spec{

Description: `Removes any duplicate values from the given list, preserving the order of remaining elements.`,

Params: []function.Parameter{

{

Name: "list",

Type: cty.List(cty.DynamicPseudoType),

},

},

Type: func(args []cty.Value) (cty.Type, error) {

return args[0].Type(), nil

},

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

listVal := args[0]

if !listVal.IsWhollyKnown() {

return cty.UnknownVal(retType), nil

}

var list []cty.Value

for it := listVal.ElementIterator(); it.Next(); {

_, v := it.Element()

list, err = appendIfMissing(list, v)

if err != nil {

return cty.NilVal, err

}

}

if len(list) == 0 {

return cty.ListValEmpty(retType.ElementType()), nil

}

return cty.ListVal(list), nil

},

})

// ChunklistFunc is a function that splits a single list into fixed-size chunks,

// returning a list of lists.

var ChunklistFunc = function.New(&function.Spec{

Description: `Splits a single list into multiple lists where each has at most the given number of elements.`,

Params: []function.Parameter{

{

Name: "list",

Description: `The list to split into chunks.`,

Type: cty.List(cty.DynamicPseudoType),

AllowMarked: true,

},

{

Name: "size",

Description: `The maximum length of each chunk. All but the last element of the result is guaranteed to be of exactly this size.`,

Type: cty.Number,

AllowMarked: true,

},

},

Type: func(args []cty.Value) (cty.Type, error) {

return cty.List(args[0].Type()), nil

},

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

listVal := args[0]

sizeVal := args[1]

listVal, listMarks := listVal.Unmark()

sizeVal, sizeMarks := sizeVal.Unmark()

// All return paths below must include .WithMarks(retMarks) to propagate

// the top-level marks into the return value. Deep marks inside the

// list will just propagate naturally because we treat those values

// as opaque here.

retMarks := cty.NewValueMarks(listMarks, sizeMarks)

var size int

err = gocty.FromCtyValue(sizeVal, &size)

if err != nil {

return cty.NilVal, fmt.Errorf("invalid size: %s", err)

}

if size < 0 {

return cty.NilVal, errors.New("the size argument must be positive")

}

if listVal.LengthInt() == 0 {

return cty.ListValEmpty(listVal.Type()).WithMarks(retMarks), nil

}

output := make([]cty.Value, 0)

// if size is 0, returns a list made of the initial list

if size == 0 {

output = append(output, listVal)

return cty.ListVal(output).WithMarks(retMarks), nil

}

chunk := make([]cty.Value, 0)

l := listVal.LengthInt()

i := 0

for it := listVal.ElementIterator(); it.Next(); {

_, v := it.Element()

chunk = append(chunk, v)

// Chunk when index isn't 0, or when reaching the values's length

if (i+1)%size == 0 || (i+1) == l {

output = append(output, cty.ListVal(chunk))

chunk = make([]cty.Value, 0)

}

i++

}

return cty.ListVal(output).WithMarks(retMarks), nil

},

})

// FlattenFunc is a function that takes a list and replaces any elements

// that are lists with a flattened sequence of the list contents.

var FlattenFunc = function.New(&function.Spec{

Description: `Transforms a list, set, or tuple value into a tuple by replacing any given elements that are themselves sequences with a flattened tuple of all of the nested elements concatenated together.`,

Params: []function.Parameter{

{

Name: "list",

Type: cty.DynamicPseudoType,

AllowMarked: true,

},

},

Type: func(args []cty.Value) (cty.Type, error) {

if !args[0].IsWhollyKnown() {

return cty.DynamicPseudoType, nil

}

argTy := args[0].Type()

if !argTy.IsListType() && !argTy.IsSetType() && !argTy.IsTupleType() {

return cty.NilType, errors.New("can only flatten lists, sets and tuples")

}

// marks are attached to values, so ignore while determining type

retVal, _, known := flattener(args[0])

if !known {

return cty.DynamicPseudoType, nil

}

tys := make([]cty.Type, len(retVal))

for i, ty := range retVal {

tys[i] = ty.Type()

}

return cty.Tuple(tys), nil

},

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

inputList := args[0]

if unmarked, marks := inputList.Unmark(); unmarked.LengthInt() == 0 {

return cty.EmptyTupleVal.WithMarks(marks), nil

}

out, markses, known := flattener(inputList)

if !known {

return cty.UnknownVal(retType).WithMarks(markses...), nil

}

return cty.TupleVal(out).WithMarks(markses...), nil

},

})

// Flatten until it's not a cty.List, and return whether the value is known.

// We can flatten lists with unknown values, as long as they are not

// lists themselves.

func flattener(flattenList cty.Value) ([]cty.Value, []cty.ValueMarks, bool) {

var markses []cty.ValueMarks

flattenList, flattenListMarks := flattenList.Unmark()

if len(flattenListMarks) > 0 {

markses = append(markses, flattenListMarks)

}

if !flattenList.Length().IsKnown() {

// If we don't know the length of what we're flattening then we can't

// predict the length of our result yet either.

return nil, markses, false

}

out := make([]cty.Value, 0)

isKnown := true

for it := flattenList.ElementIterator(); it.Next(); {

_, val := it.Element()

// Any dynamic types could result in more collections that need to be

// flattened, so the type cannot be known.

if val == cty.DynamicVal {

isKnown = false

}

if !val.IsNull() && (val.Type().IsListType() || val.Type().IsSetType() || val.Type().IsTupleType()) {

if !val.IsKnown() {

isKnown = false

_, unknownMarks := val.Unmark()

markses = append(markses, unknownMarks)

continue

}

res, resMarks, known := flattener(val)

markses = append(markses, resMarks...)

if known {

out = append(out, res...)

} else {

isKnown = false

}

} else {

out = append(out, val)

}

}

return out, markses, isKnown

}

// KeysFunc is a function that takes a map and returns a sorted list of the map keys.

var KeysFunc = function.New(&function.Spec{

Description: `Returns a list of the keys of the given map in lexicographical order.`,

Params: []function.Parameter{

{

Name: "inputMap",

Description: `The map to extract keys from. May instead be an object-typed value, in which case the result is a tuple of the object attributes.`,

Type: cty.DynamicPseudoType,

AllowUnknown: true,

AllowMarked: true,

},

},

Type: func(args []cty.Value) (cty.Type, error) {

ty := args[0].Type()

switch {

case ty.IsMapType():

return cty.List(cty.String), nil

case ty.IsObjectType():

atys := ty.AttributeTypes()

if len(atys) == 0 {

return cty.EmptyTuple, nil

}

// All of our result elements will be strings, and atys just

// decides how many there are.

etys := make([]cty.Type, len(atys))

for i := range etys {

etys[i] = cty.String

}

return cty.Tuple(etys), nil

default:

return cty.DynamicPseudoType, function.NewArgErrorf(0, "must have map or object type")

}

},

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {

// We must unmark the value before we can use ElementIterator on it, and

// then re-apply the same marks (possibly none) when we return. Since we

// don't mark map keys, we can throw away any nested marks, which would

// only apply to values.

m, marks := args[0].Unmark()

var keys []cty.Value

switch {

case m.Type().IsObjectType():

// In this case we allow unknown values so we must work only with

// the attribute _types_, not with the value itself.

var names []string

for name := range m.Type().AttributeTypes() {

names = append(names, name)

}

sort.Strings(names) // same ordering guaranteed by cty's ElementIterator

if len(names) == 0 {

return cty.EmptyTupleVal.WithMarks(marks), nil

}

keys = make([]cty.Value, len(names))

for i, name := range names {

keys[i] = cty.StringVal(name)

}

return cty.TupleVal(keys).WithMarks(marks), nil

default:

if !m.IsKnown() {

return cty.UnknownVal(retType).WithMarks(marks), nil

}

// cty guarantees that ElementIterator will iterate in lexicographical

// order by key.

for it := m.ElementIterator(); it.Next(); {

k, _ := it.Element()

keys = append(keys, k)

}

if len(keys) == 0 {

return cty.ListValEmpty(cty.String).WithMarks(marks), nil

}

return cty.ListVal(keys).WithMarks(marks), nil

}

},

})

// LookupFunc is a function that performs dynamic lookups of map types.

var LookupFunc = function.New(&function.Spec{

Description: `Returns the value of the element with the given key from the given map, or returns the default value if there is no such element.`,

Params: []function.Parameter{

{

Name: "inputMap",

Type: cty.DynamicPseudoType,

AllowMarked: true,

},

{

Name: "key",

Type: cty.String,

AllowMarked: true,

},

{

Name: "default",

Type: cty.DynamicPseudoType,

AllowMarked: true,

},

},

Type: func(args []cty.Value) (ret cty.Type, err error) {

ty := args[0].Type()

switch {

case ty.IsObjectType():

if !args[1].IsKnown() {

return cty.DynamicPseudoType, nil

}

keyVal, _ := args[1].Unmark()

key := keyVal.AsString()

if ty.HasAttribute(key) {

return args[0].GetAttr(key).Type(), nil

} else if len(args) == 3 {

// if the key isn't found but a default is provided,

// return the default type

return args[2].Type(), nil

}

return cty.DynamicPseudoType, function.NewArgErrorf(0, "the given object has no attribute %q", key)

case ty.IsMapType():

if len(args) == 3 {

_, err = convert.Convert(args[2], ty.ElementType())

if err != nil {

return cty.NilType, function.NewArgErrorf(2, "the default value must have the same type as the map elements")

}

}

return ty.ElementType(), nil

default:

return cty.NilType, function.NewArgErrorf(0, "lookup() requires a map as the first argument")

}

},

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

// leave default value marked

defaultVal := args[2]

var markses []cty.ValueMarks

// unmark collection, retain marks to reapply later

mapVar, mapMarks := args[0].Unmark()

markses = append(markses, mapMarks)

// include marks on the key in the result

keyVal, keyMarks := args[1].Unmark()

if len(keyMarks) > 0 {

markses = append(markses, keyMarks)

}

lookupKey := keyVal.AsString()

if !mapVar.IsWhollyKnown() {

return cty.UnknownVal(retType).WithMarks(markses...), nil

}

if mapVar.Type().IsObjectType() {

if mapVar.Type().HasAttribute(lookupKey) {

return mapVar.GetAttr(lookupKey).WithMarks(markses...), nil

}

} else if mapVar.HasIndex(cty.StringVal(lookupKey)) == cty.True {

return mapVar.Index(cty.StringVal(lookupKey)).WithMarks(markses...), nil

}

defaultVal, err = convert.Convert(defaultVal, retType)

if err != nil {

return cty.NilVal, err

}

return defaultVal.WithMarks(markses...), nil

},

})

// MergeFunc constructs a function that takes an arbitrary number of maps or

// objects, and returns a single value that contains a merged set of keys and

// values from all of the inputs.

//

// If more than one given map or object defines the same key then the one that

// is later in the argument sequence takes precedence.

var MergeFunc = function.New(&function.Spec{

Description: `Merges all of the elements from the given maps into a single map, or the attributes from given objects into a single object.`,

Params: []function.Parameter{},

VarParam: &function.Parameter{

Name: "maps",

Type: cty.DynamicPseudoType,

AllowDynamicType: true,

AllowNull: true,

AllowMarked: true,

},

Type: func(args []cty.Value) (cty.Type, error) {

// empty args is accepted, so assume an empty object since we have no

// key-value types.

if len(args) == 0 {

return cty.EmptyObject, nil

}

// collect the possible object attrs

attrs := map[string]cty.Type{}

first := cty.NilType

matching := true

attrsKnown := true

for i, arg := range args {

ty := arg.Type()

// any dynamic args mean we can't compute a type

if ty.Equals(cty.DynamicPseudoType) {

return cty.DynamicPseudoType, nil

}

// check for invalid arguments

if !ty.IsMapType() && !ty.IsObjectType() {

return cty.NilType, fmt.Errorf("arguments must be maps or objects, got %#v", ty.FriendlyName())

}

// marks are attached to values, so ignore while determining type

arg, _ = arg.Unmark()

switch {

case ty.IsObjectType():

if arg.IsNull() {

// Null objects are treated by this function as if they have

// no attributes at all.

ty = cty.EmptyObject

}

maps.Copy(attrs, ty.AttributeTypes())

case ty.IsMapType():

switch {

case arg.IsNull():

// pass, nothing to add

case arg.IsKnown():

ety := arg.Type().ElementType()

for it := arg.ElementIterator(); it.Next(); {

attr, _ := it.Element()

attrs[attr.AsString()] = ety

}

default:

// any unknown maps means we don't know all possible attrs

// for the return type

attrsKnown = false

}

}

// record the first argument type for comparison

if i == 0 {

first = ty

continue

}

if matching && !ty.Equals(first) {

matching = false

}

}

// the types all match, so use the first argument type

if matching {

return first, nil

}

// We had a mix of unknown maps and objects, so we can't predict the

// attributes

if !attrsKnown {

return cty.DynamicPseudoType, nil

}

return cty.Object(attrs), nil

},

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

outputMap := make(map[string]cty.Value)

var markses []cty.ValueMarks // remember any marked maps/objects we find

for _, arg := range args {

if arg.IsNull() {

continue

}

arg, argMarks := arg.Unmark()

if len(argMarks) > 0 {

markses = append(markses, argMarks)

}

for it := arg.ElementIterator(); it.Next(); {

k, v := it.Element()

outputMap[k.AsString()] = v

}

}

switch {

case retType.IsMapType():

if len(outputMap) == 0 {

return cty.MapValEmpty(retType.ElementType()).WithMarks(markses...), nil

}

return cty.MapVal(outputMap).WithMarks(markses...), nil

case retType.IsObjectType(), retType.Equals(cty.DynamicPseudoType):

return cty.ObjectVal(outputMap).WithMarks(markses...), nil

default:

panic(fmt.Sprintf("unexpected return type: %#v", retType))

}

},

})

// ReverseListFunc takes a sequence and produces a new sequence of the same length

// with all of the same elements as the given sequence but in reverse order.

var ReverseListFunc = function.New(&function.Spec{

Description: `Returns the given list with its elements in reverse order.`,

Params: []function.Parameter{

{

Name: "list",

Type: cty.DynamicPseudoType,

AllowMarked: true,

},

},

Type: func(args []cty.Value) (cty.Type, error) {

argTy := args[0].Type()

switch {

case argTy.IsTupleType():

argTys := argTy.TupleElementTypes()

retTys := make([]cty.Type, len(argTys))

for i, ty := range argTys {

retTys[len(retTys)-i-1] = ty

}

return cty.Tuple(retTys), nil

case argTy.IsListType(), argTy.IsSetType(): // We accept sets here to mimic the usual behavior of auto-converting to list

return cty.List(argTy.ElementType()), nil

default:

return cty.NilType, function.NewArgErrorf(0, "can only reverse list or tuple values, not %s", argTy.FriendlyName())

}

},

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

in, marks := args[0].Unmark()

inVals := in.AsValueSlice()

outVals := make([]cty.Value, len(inVals))

for i, v := range inVals {

outVals[len(outVals)-i-1] = v

}

switch {

case retType.IsTupleType():

return cty.TupleVal(outVals).WithMarks(marks), nil

default:

if len(outVals) == 0 {

return cty.ListValEmpty(retType.ElementType()).WithMarks(marks), nil

}

return cty.ListVal(outVals).WithMarks(marks), nil

}

},

})

// SetProductFunc calculates the Cartesian product of two or more sets or

// sequences. If the arguments are all lists then the result is a list of tuples,

// preserving the ordering of all of the input lists. Otherwise the result is a

// set of tuples.

var SetProductFunc = function.New(&function.Spec{

Description: `Calculates the cartesian product of two or more sets.`,

Params: []function.Parameter{},

VarParam: &function.Parameter{

Name: "sets",

Description: "The sets to consider. Also accepts lists and tuples, and if all arguments are of list or tuple type then the result will preserve the input ordering",

Type: cty.DynamicPseudoType,

AllowMarked: true,

AllowUnknown: true,

},

Type: func(args []cty.Value) (retType cty.Type, err error) {

if len(args) < 2 {

return cty.NilType, errors.New("at least two arguments are required")

}

listCount := 0

elemTys := make([]cty.Type, len(args))

for i, arg := range args {

aty := arg.Type()

switch {

case aty.IsSetType():

elemTys[i] = aty.ElementType()

case aty.IsListType():

elemTys[i] = aty.ElementType()

listCount++

case aty.IsTupleType():

// We can accept a tuple type only if there's some common type

// that all of its elements can be converted to.

allEtys := aty.TupleElementTypes()

if len(allEtys) == 0 {

elemTys[i] = cty.DynamicPseudoType

listCount++

break

}

ety, _ := convert.UnifyUnsafe(allEtys)

if ety == cty.NilType {

return cty.NilType, function.NewArgErrorf(i, "all elements must be of the same type")

}

elemTys[i] = ety

listCount++

default:

return cty.NilType, function.NewArgErrorf(i, "a set or a list is required")

}

}

if listCount == len(args) {

return cty.List(cty.Tuple(elemTys)), nil

}

return cty.Set(cty.Tuple(elemTys)), nil

},

RefineResult: refineNonNull,

Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {

ety := retType.ElementType()

var retMarks cty.ValueMarks

total := 1

var hasUnknownLength bool

for _, arg := range args {

arg, marks := arg.Unmark()

retMarks = cty.NewValueMarks(retMarks, marks)

// Continue processing after we find an argument with unknown

// length to ensure that we cover all the marks

if !(arg.IsKnown() && arg.Length().IsKnown()) {

hasUnknownLength = true

continue

}

// Because of our type checking function, we are guaranteed that

// all of the arguments are known, non-null values of types that