Float32 Function Parameter

Float32 function parameters expect a 32-bit floating point number value from a practitioner configuration. Values are accessible in function logic by the Go built-in float32 type, Go built-in *float32 type, or the framework float32 type.

In this Terraform configuration example, a float32 parameter is set to the value 1.23:

provider::example::example(1.23)

Function Definition

Use the function.Float32Parameter type in the function definition to accept a float32 value.

In this example, a function definition includes a first position float32 parameter:

func (f ExampleFunction) Definition(ctx context.Context, req function.DefinitionRequest, resp *function.DefinitionResponse) {
    resp.Definition = function.Definition{
        // ... other Definition fields ...
        Parameters: []function.Parameter{
            function.Float32Parameter{
                Name: "float32_param",
                // ... potentially other Float32Parameter fields ...
            },
        },
    }
}

If the float32 value should be the element type of a collection parameter type, set the ElementType field according to the framework float32 type. Refer to the collection parameter type documentation for additional details.

If the float32 value should be a value type of an object parameter type, set the AttributeTypes map value according to the framework float32 type. Refer to the object parameter type documentation for additional details.

Allow Null Values

By default, Terraform will not pass null values to the function logic. Use the AllowNullValue field to explicitly allow null values, if there is a meaningful distinction that should occur in function logic. Enabling AllowNullValue requires using a Go pointer type or framework float32 type when reading argument data.

Allow Unknown Values

By default, Terraform will not pass unknown values to the function logic. Use the AllowUnknownValues field to explicitly allow unknown values, if there is a meaningful distinction that should occur in function logic. Enabling AllowUnknownValues requires using a framework float32 type when reading argument data.

Custom Types

You may want to build your own data value and type implementations to allow your provider to combine validation and other behaviors into a reusable bundle. This helps avoid duplication and ensures consistency. These implementations use the CustomType field in the parameter type.

Refer to Custom Types for further details on creating provider-defined types and values.

Documentation

Refer to function documentation for information about the Name, Description, and MarkdownDescription fields available.

Reading Argument Data

The function implementation documentation covers the general methods for reading function argument data in function logic.

When retrieving the argument value for this parameter:

• If CustomType is set, use its associated value type.
• If AllowUnknownValues is enabled, you must use the framework float32 type.
• If AllowNullValue is enabled, you must use the Go built-in *float32 type or framework float32 type.
• Otherwise, use the Go built-in float32 type, Go built-in *float32 type, or framework float32 type.

In this example, a function defines a single float32 parameter and accesses its argument value:

func (f ExampleFunction) Definition(ctx context.Context, req function.DefinitionRequest, resp *function.DefinitionResponse) {
    resp.Definition = function.Definition{
        // ... other Definition fields ...
        Parameters: []function.Parameter{
            function.Float32Parameter{
                Name: "float32_param",
                // ... potentially other Float32Parameter fields ...
            },
        },
    }
}

func (f ExampleFunction) Run(ctx context.Context, req function.RunRequest, resp *function.RunResponse) {
    var float32Arg float32
    // var float32Arg *float32 // e.g. with AllowNullValue, where Go nil equals Terraform null
    // var float32Arg types.Float32 // e.g. with AllowUnknownValues or AllowNullValue

    resp.Error = function.ConcatFuncErrors(resp.Error, req.Arguments.Get(ctx, &float32Arg))

    // float32Arg is now populated
    // ... other logic ...
}