Wing Programming Language
Wing Next

Variable personalities

Short introduction

Personalities inheritence

  • string
    • char
    • number
      • infinity
      • boolean
        • true
        • false
      • big
        • pbig
        • nbig
      • int
        • u64
        • i64
      • float
    • list
    • errnumber

Personality cohesion

blah blah

List of personalities

Below is a complete list of all the variable personalities in Wing.


string is the base personality of all variables in Wing. All variables have the string personalities, and all personalities extend from string.
Hello world is a variable that has only the string personality.


char is a subset of string. It represents a single character within a string.
W is a char, and also a string (since personalities are inherited from parents). It is possible to get a char from a string, for example with the following code:
$var = Hello
$letter = 0
$letter < item $var 0
print $letter -- This will display "H"
list_personalities letter -- This will display "char, string"


number is a personality that designates all variables that can be used against mathematical operations without returning a variable with the errnumber personality.
43 is a number, -39 is a number, 3.14159 is a number, inf is also a number (see infinity).
Variables with the number personality generaly have additional child personalities (e.g. int) to better specify the exact type of number they contain.


list is a personality for variables that hold multiple values. The values the list contains can have different personalities, and special operations can be run only on list variables. list variables can be compared to arrays in other programming languages.
Due to the fact the list personality is inherited from string, all list variables have a string representation, which looks like this: [List 'e475bf4f-b5d5-430f-9413-bf7825354fdd']. It is also possible to copy a reference to a specific list variable, using the following code:
$l1 = 0
$l2 = 0
$l1 < list
$l2 = $l1
print $l1 $l2 -- You can see that both $l1 and $l2 point to the same 'list'
To work around this behavior, it is possible to make a copy of the list variable itself instead:
$l1 = 0
$l2 = 0
$l1 < list
$l2 < listcopy $l1
print $l1 $l2 -- You can now see that $l1 and $l2 point to different 'list's


errnumber is a special variable personality that designates a variable that was intended to be a number but cannot because of an error.
This could be, for example, trying to do the sum of variables that do not have the number personality. The errnumber personality is represented as a string as NaN.


infinity, in general, designates all numbers that are infinite. This includes the infinity notation (∞) and may include other numbers. Note that non-real numbers (for example roots of negative numbers) are represented as errnumber instead.
infinity variables are represented as inf in a string form.


boolean are binary values that can be either true or false. The boolean personality alone is never used.


true is a value that is considered a logical yes, and a binary 1. The u64, int, number and string representation of true is 1.
Note, however, that -1 is not considered a boolean. Only natural integer 1 is considered a boolean.


false is a value that is considered a logical no, and a binary 0. The u64, int, number and string representation of false is 0.


big is a subset of number for all numbers that are bigger than the maximum 64-bit integer length. They can contain as many digits as storage permit. Note, however, that they cannot be used for regular mathematical operations due to their differences with regular int or float values.


pbig is a positive big number. 1234567890123456789 is a pbig value.


nbig is a negative big number. -1234567890123456789 is an nbig value.


int is a number that does not contain decimals. An int can be either signed (i64) or unsigned (u64). All int values are coded on 64-bit due to Wing running only on 64-bit platforms.


u64 is an unsigned int. That is, an int that does not contain a sign. 0 is considered an u64 value as well.


i64 is a signed int, it contains a sign. In most cases, this means the value is negative (e.g. -5). It is worth noting that signed int values take up more memory than unsigned int values.


float values are numbers that contain decimals. Again, they are coded on 64-bit, meaning their total value (including what is before and after the decimal point) must not exceed that of a 64-bit integer.