Home » Pinescript Syntax » Understanding Type Casting in Pine Script

Understanding Type Casting in Pine Script

Photo of author
Published on

In this article, we delve into the nuances of type casting in Pine Script, illustrating how to effectively utilize this feature through examples and explanations.

What is Type Casting?

Type casting in programming languages refers to the conversion of a variable from one data type to another. In Pine Script, this mechanism is particularly useful for handling operations and functions that require specific data types.

Automatic Type Casting

Pine Script simplifies programming by automatically converting int values to float when necessary. This auto-casting ensures that variables or expressions designated to hold float values can seamlessly accept int values, given that integers can be represented as floating-point numbers with their fractional part being zero.

From Numeric to Boolean

For backward compatibility, Pine Script extends its auto-casting capabilities to include the conversion of int and float values to bool (boolean). This automatic conversion comes into play when numeric values are passed to parameters expecting boolean types. However, relying on this auto-casting to bool is not recommended due to potential compiler warnings. Instead, the explicit use of the bool() function for conversion is advised for clarity and to avoid warnings.

Example of Deprecated Auto-Casting Behavior

Consider the following code snippet that illustrates deprecated auto-casting behavior:

indicator("Auto-casting demo", overlay = true)
float randomVal = math.round(math.random(-1, 1))
color bgColor = na

if randomVal
    bgColor := color.new(color.blue, 60)
if bool(randomVal)
    bgColor := color.new(color.blue, 60)


In this example, randomVal is a series float that gets automatically cast to bool in certain conditions, despite the potential for compiler warnings. The use of bool(randomVal) showcases the recommended explicit casting to improve code readability.

Explicit Type Casting

When auto-casting rules are insufficient, Pine Script offers a variety of type-casting functions such as int(), float(), bool(), color(), string(), line(), linefill(), label(), box(), and table(). These functions allow for explicit conversion between data types, which is especially useful in situations where the required data type is not automatically inferred.

Example of Explicit Casting Requirement

The need for explicit casting is evident in the following scenario:

indicator("Explicit casting demo", overlay = true)
float LENGTH = 10.0
float sma = ta.sma(close, LENGTH) // Compilation error

Here, attempting to use a const float value as the length argument in ta.sma() results in a compilation error because the function expects an int. To resolve this, explicit casting using the int() function is necessary:

float sma = ta.sma(close, int(LENGTH)) // Successful compilation

Key Features and Takeaways

  • Automatic vs. Explicit Casting: Pine Script automatically casts int to float and numeric values to bool for backward compatibility. However, explicit casting using specific functions like bool(), int(), etc., is recommended for clarity and to avoid compiler warnings.
  • Explicit Casting Functions: Pine Script provides several functions for explicit type casting, facilitating precise control over data types in your scripts.
  • Best Practices: Always prefer explicit casting over relying on automatic type casting, especially when converting numeric values to boolean. This approach enhances code readability and maintainability.

By understanding and applying type casting in Pine Script, developers can write more robust, readable, and maintainable scripts for TradingView, ensuring that their custom indicators and strategies perform as intended.

Leave a Comment