Literals¶

String Literals¶

Lasso supports two kinds of string literals: quoted and ticked. Quoted strings can contain escape sequences, while ticked strings cannot. Both quoted and ticked string literals can contain line breaks, and produce the same type of string objects. The differences between the two types of literals are handled entirely during parsing. All strings in Lasso are Unicode strings, which means that a string can contain any of the characters available in Unicode.

'This is a string literal'
"This is also a string literal"

'This is a \'string literal\' with quotes'
"This is also a \"string literal\" with quotes"

"Escaping this single quote isn't required"

'This string literal has a backslash \\ in it'

'This string \
       had a break in it'
// => This string had a break in it

`This is a ticked string`
`A ticked string can contain 'single quotes', "double quotes",
\backslash characters\ and more - anything except backticks!`

Boolean Literals¶

A boolean is an object that is either “true” or “false”. Lasso supports the creation of these objects by using the word true or false directly in the source code.

true
false

type boolean¶

boolean()

boolean(obj::any)

Casts a value to a boolean value. Only the following objects and values evaluate to “false”; all others are “true”:

• integer zero: 0
• decimal zero: 0.0
• null and void
• calling boolean with no parameter
• empty string: '', "", ``

Note

Although the empty string evaluates to “false”, this functionality is deprecated. Instead, call string->size to check for empty strings.

Integer Literals¶

An integer is a whole number. Integers can be positive or negative, and Lasso puts no limit on the size of an integer. Integers consist of the digits 0 through 9 and can be written directly into the source code.

1
-4
+937
11801705635790

Integers can also be written using hexadecimal notation. Hexadecimal integers begin with a zero followed by an upper or lowercase “x” followed by one or more hexadecimal digits (0–9 and A–F). Either upper or lowercase letters are permitted. A hexadecimal integer literal is always interpreted as a positive integer.

0x1
0x04
0x3A9
0x11F018BE6

Both numeric and hexadecimal integer literals produce the same integer type with the same set of member methods.

See the Math chapter for more information on the integer type.

Decimal Literals¶

A decimal is a fractional number. Decimal numbers contain a decimal point and therefore are called “decimals”. Lasso supports 64-bit decimals. This gives Lasso’s decimal numbers a range from approximately negative to positive 2x10^300 and with precision down to 2x10^-300. A decimal literal begins with an optional “-” or “+” character followed by zero or more digits, a decimal point, one or more additional digits, and ending with an optional exponent. A decimal exponent begins with an upper or lowercase “E”, followed by an optional “-” or “+” character followed by one or more digits. Lasso also supports decimal literals for NaN (not a number) as well and positive and negative infinity. (Note that case is irrelevant when using the NaN and infinity literals.)

.1
-.89
1.0
-93.42e-4
+93.42e4
NaN
infinity
-infinity

See the Math chapter for more information on the decimal type.

Tag Literals¶

A tag is an object that uniquely represents a particular string of characters. Unlike strings, tags cannot be modified. Tags are used to represent type and method names as well as variable names. A tag should begin with a letter or underscore, followed by zero or more letters, numbers, underscores, or period characters. Tags cannot contain spaces.

Tags are commonly used when applying type constraints to methods, data members, and variables; though they have other purposes as well, such as type and object introspection.

A tag literal consists of two colons followed by the tag’s characters.

// Creates a tag object representing "name"
::name

In Lasso, the tag type is used in many different locations. For example, when asking an object what type it is with type, it will reply with a tag object representing its name. Since there will be only one tag object for every individual name, comparing tags for equality is very fast.

tag_exists(value::string)¶

Checks if a tag matching the given string value exists without attempting to create a tag. Returns the tag if it exists or “void” if it does not.

Staticarray Literals¶

Lasso’s staticarray type is an efficient, non-resizable collection for holding any series of object types which is used in many places in Lasso. Staticarrays are created in the same way as any object, but Lasso supports a shortcut syntax to produce staticarrays. This expression begins with an open parenthesis immediately followed by a colon, then zero or more comma-delimited expressions, ending with the closing parenthesis.

// Creates a staticarray containing 1, 2, and "hello"
(: 1, 2, 'hello')

See the Collections chapter for more information on the staticarray type.

Series Literals¶

Lasso’s generateSeries type is a quick and efficient way to create a series or range of integers for use with query expressions. The shortcut syntax for creating a series consists of a starting integer and ending integer separated by the word “to”. An optional integer specifying the step size, which defaults to 1, can be added after the word “by”.

0 to 10 by 2
// => 0, 2, 4, 6, 8, 10

See the Query Expressions chapter for more information on the generateSeries type.

Null and Void¶

type null¶

A null represents a blank or empty value, specified in code by the word null. All types inherit from null , so its member methods (listed under Type/Object Introspection Methods in the Types chapter) can be used by any type.

type void¶

A type specified in code by void which is similar to null in that it is only ever equal to itself, but indicates a non-existent rather than an empty value.

Comments¶

Lasso supports three types of comments: single line comments, block comments, and doc comments. Single line and block comments are ignored, having no effect on the execution of any nearby code. Doc comments are saved with the adjacent method, type, or trait, as explained below.

local(n) = 123 // This is the first comment
// This is another comment
#n += 456

local(n) = 123
/* this is a block comment
it has multiple lines */
#n += 456

/**!
    This doc comment is associated with this method
*/
define foo->xyz() => { ... }

/**!
    This doc comment is associated with this type definition
*/
define foo => type {
   /**!
       Doc comment for the type's xyz() method
   */
   public xyz() => { ... }
}

/**!
    This doc comment is associated with this trait
*/
define tBar => trait {
   /**!
       Doc comment for the trait's doIt() method
   */
   provide doIt() => { ... }
}

$> env LASSO9_RETAIN_COMMENTS=1 lasso9 -s "::array->docComment"
/**!
An array is an object that can hold multiple values…

$> env LASSO9_RETAIN_COMMENTS=1 lasso9 -s "
::boolean->docComment = 'Boolean objects are either true or false.'
::boolean->docComment
"
Boolean objects are either true or false.