Wing Programming Language
Wing Next


A function (also known as "coroutine", "subroutine" or "procedure") is a piece of code that is meant to be repeated multiple times throughout a program's lifetime. To prevent duplicating code, a function is used instead.
Without using functions, you would have the following code:
$test = 1
print test is $test
$test = 2
print test is $test
$test = 3
print test is $test
Look at how the print test is $test line is repeated multiple times. With a function, we can optimise this code:
function showtest $test
print test is $test
showtest 1
showtest 2
showtest 3
Now all of the lines in our program are different, which is much more efficient.
You can define functions in two different ways with Wing:
function name $argument
function name $argument do
Both are valid syntaxically speaking, although the developers recommend you use the former. Function definitions support the do keyword only for consistency purposes with other blocks.

Declaring functions

Functions are declared with the function keyword, followed by the name of the function. All code below is considered part of the function until the keyword end is used.
function hello
-- This is running inside of the function
print Hello!
-- This is running outside of the function
print Hi!
While naming a function with a reserved keyword (e.g. if or end) will not give an error, you will not be able to execute that function.

Calling a function

"Calling" a function means executing the code it contains. Without specifically calling a function, its code is never executed or even read by the interpreter.
Let's take the hello function we declared above. To call it, you will have to run:
This runs the hello function and then continues running any potential code below it. Variables set from the function remain after the function has finished (for more details, read the Variables and personalities pages).

Function parameter

Each function can take a single parameter. A parameter is a variable that is set specifically at the time the function is called. To indicate a function needs a parameter, you simply add a variable name after the name of the function, like this:
function goodbye $name
-- Your code goes here
goodbye Me
This is equivalent to doing this:
function othergoodbye
-- Your code goes here
$name = Me
Parameters passed to functions remain even after the function has completed. If your function takes a $variable parameter, the $variable variable will remain after running the function.
Following the functions declared above, these lines of code will give errors:
hello Me -- Will give an error because 'hello' doesn't take a parameter
goodbye -- Will give an error because 'goodbye' requires a paremeter
Functions that require more than one parameter can have them set before calling the function, like this:
function complicatedcode
-- Your code here
$complicatedcode_value1 = Potato
$complicatedcode_value2 = Carrot
$complicatedcode_value3 = Tomato

Classes and methods

You might be wondering how to use classes with Wing. The answer is simple: you can't. Wing is not an object-oriented language, therefore does not support object-oriented paradigms. This means you cannot use classes and methods in Wing.
Take this JavaScript class:
class Apple {
constructor() {
this.sugar = 10;
eat() {
console.log("Ate an apple");
It can easily be reimplemented like this in Wing:
function apple_create
$apple_created = 1
$apple_sugar = 10
function apple_eat
if defined $apple_created do -- This is to check if 'apple_create' has been called before
print Ate an apple

Available functions

Wing comes with a number of functions that can get basic tasks done. Obviously, for more advanced tasks, you will need to import additional functions.
The list of built-in functions is in the Built-in modules category.