<identifier>([<parameter_name>[=<default_value>]], ...) =>  <local_block>  <function_result>

// single-line function
f1(x, y) => x + y
// multi-line function
f2(x, y) => 
	sum = x + y
	sumChange = ta.change(sum, 10)
	// Function automatically returns the last expression used in it

//@version=5
//@description Library of debugging functions.
library("Debugging_library", overlay = true)
//@function Displays a string as a table cell for debugging purposes.
//@param txt String to display.
//@returns Void.
export print(string txt) => 
	var table t = table.new(position.middle_right, 1, 1)
	table.cell(t, 0, 0, txt, bgcolor = color.yellow)
// Using the function from inside the library to show an example on the published chart.
// This has no impact on scripts using the library.
print("Library Test")

import {username}/{libraryName}/{libraryVersion} as {alias}

//@version=5
indicator("num_methods import")
// Import the first version of the username’s "num_methods" library and assign it to the "m" namespace",
import username/num_methods/1 as m
// Call the “sinh()” function from the imported library
y = m.sinh(3.14)
// Plot value returned by the "sinh()" function",
plot(y)

export <functionName>([[series] <type>] <arg1>[ = <default_value>])

export smaCustom(series float source, series int length) =>
	sma(source, length)

export <functionName>([[simple] <type>] <arg1>[ = <default_value>])

export emaWrong(float source, int length) =>
	// By default, both `source` and `length` will expect values of the `series` type form: `series float` for `source`, `series int` for `length`.
	// This function will not compile because `ema()` does not support a "series int" argument for `length`. A "simple int" is required.
	ema(source, length)

export emaRight(float source, simple int length) =>
	// This function requires an argument of "simple int" type for its `length` parameter.
	ema(source, length)

[variable_declaration = ] switch expression  value1 => local_block  value2 => local_block  …  => default_local_block[variable_declaration = ] switch  boolean_expression1 => local_block  boolean_expression2 => local_block  …  => default_local_block

//@version=5
indicator("Switch using an expression")

string i_maType = input.string("EMA", "MA type", options = ["EMA", "SMA", "RMA", "WMA"])

float ma = switch i_maType
	"EMA" => ta.ema(close, 10)
	"SMA" => ta.sma(close, 10)
	"RMA" => ta.rma(close, 10)
	// Default used when the three first cases do not match.
	=> ta.wma(close, 10)

plot(ma)
//@version=5
strategy("Switch without an expression", overlay = true)

bool longCondition  = ta.crossover( ta.sma(close, 14), ta.sma(close, 28))
bool shortCondition = ta.crossunder(ta.sma(close, 14), ta.sma(close, 28))

switch
	longCondition  => strategy.entry("Long ID", strategy.long)
	shortCondition => strategy.entry("Short ID", strategy.short)

variable_declaration = while boolean_expression  …  continue  …  break  …  return_expression

//@version=5
indicator("")
// This is a simple example of calculating a factorial using a while loop.
int i_n = input.int(10, "Factorial Size", minval=0)
int counter   = i_n
int factorial = 1
while counter > 0
	factorial := factorial * counter
	counter   := counter - 1

plot(factorial)

indicator(title, shorttitle, overlay, format, precision, scale, max_bars_back, timeframe, timeframe_gaps, explicit_plot_zorder, max_lines_count, max_labels_count, max_boxes_count) → void

indicator(title='MyScriptindicator')
indicator(title="MyScriptindicator", shorttitle="MSS", precision=6, overlay=true)

library(title, overlay) → void

//@version=5
// @description Math library
library("num_methods", overlay = true)
// Calculate "sinh()" from the float parameter `x`
export sinh(float x) =>
	(math.exp(x) - math.exp(-x)) / 2.0
plot(sinh(0))