Skip to content
Filtrera

let Statement

The let statement in Filtrera is used to define symbols, allowing you to assign values to names that can be referenced throughout your program. This reference guide provides a detailed specification of the let statement, its syntax, and usage for users already familiar with the concept.

Syntax

The basic syntax for the let statement is:

let <symbol_name> = <expression>

Optionally, you can specify an explicit type for the symbol:

let <symbol_name>: <type> = <expression>

Parameters

  • <symbol_name>: The name of the symbol. This should be a valid identifier.
  • <type> (optional): The explicit type of the symbol. This is useful for ensuring type compatibility, especially when defining complex values.
  • <expression>: The value or expression to be assigned to the symbol. This can be a constant, a calculation, a function, or any valid Filtrera expression.

Examples

Basic Symbol Definition

let age = 30

This defines a symbol named age and assigns it the value 30.

Symbol with Explicit Type

let age: number = 30

This defines a symbol named age with an explicit type number and assigns it the value 30.

Symbol with Expression

let area = width * height

In this example, the symbol area is assigned the result of the expression width * height.

Type Inference

Filtrera supports type inference, so the type of the symbol is automatically determined based on the assigned expression.

Example

let name = 'Alice'

Here, the type of name is inferred to be text because it is assigned the string "Alice".

Scope

Symbols defined inside a block are only accessible within that scope and any nested scope. This scoping rule helps in managing the visibility and lifetime of symbols, ensuring they do not interfere with other parts of the program.

Example

  let x = 10
  let y = 20


  // x and y are accessible here
    let z = x + y
    // x, y, and z are accessible here


  // z is not accessible here

In this example, x and y are defined at the top level of the block and are accessible within the nested block. However, z, which is defined in the nested block, is not accessible outside of it.

Usage

Referencing Symbols

Once defined, symbols can be referenced throughout the program.

let width = 5
let height = 10
let area = width * height


from area

In this example, the symbols width and height are used to calculate the area, which is then output.

Using Symbols in Functions and Filters

Symbols defined with let can be used within functions and filters to create more complex expressions and transformations.

let threshold = 20
let largeNumbers (collection) |> collection where n > threshold


from [1, 20, 30] largeNumbers

In this example, the symbol threshold is used within the filter function largeNumbers to filter the collection.

Defining Functions with let

The let statement can also be used to define functions by assigning a function expression to a symbol.

let square = (x) => x * x


from square(5)

Here, the symbol square is defined as a function that returns the square of its parameter.

Best Practices

  • Descriptive Names: Use descriptive names for symbols to enhance code readability and maintainability.
  • Consistent Naming: Follow a consistent naming convention for symbols to make your code more understandable.
  • Scope Awareness: Be aware of the scope of your symbols to avoid naming conflicts and unintended behaviors.
  • Explicit Types: Use explicit types when defining complex values to ensure type compatibility and improve code clarity.

Summary

The let statement is a fundamental feature in Filtrera for defining symbols and assigning values to them. By understanding its syntax and usage, you can create clear, concise, and maintainable code. Leveraging type inference and using symbols effectively allows for the creation of dynamic and flexible programs. Specifying explicit types when needed ensures typ