The following types are supported: boolean, integer, float, string, list, hash and the PHP types NULL and handle (resource).
Rulz introduces several other types such as file and argument — which are similar to barewords. See #Argument Literals.
Basic variables are like $var where "var" is one or more lowercase letters, and, PHP-like, can be assigned any type. Variable assignment is Bash-like with the $ not used.
Like Bash and Perl all variables are global and there are "my" and "local" attributes for subroutines.
There are Perl-like special variables of the format: $[0-9[:punct:]]$0 and $_, differ from their Perl counterparts and are used as defaults for most Builtins and Commands and for some Functions.
See Variables for Rulz special variables.
TRUE boolean TRUE
FALSE boolean FALSE
NULL NULL
CONST constant
123 decimal
0.123 float
1e4 float
0123 octal
0x1A hexadecimal
1Ah hexadecimal
0b0001 binary
0001b binary
(a,b,c) list
(a b c) list
(a=1,b=2,c=3) hash
{a,1,b,2,c,3} hash
simple bareword
-a --help program argument
lib/test.php file name
*.txt file glob - list of matching files
\n \t escape sequence
"" '' empty string
"double quotes" string; variables, escape sequences expanded
'single quotes' string; variables not expanded; escape sequences \' and \\
The hexadecimal extension (trailing [hH]) must have a leading digit.
14:25'36" sexagesimal 2% percent
Variables can be arguments by themselves or within double quotes. As arguments they are passed by value. To pass by reference the notation is \. (The use of $var$ is to avoid ambiguities with escape sequences, allowing for single letter variables.)
$var variable \$var reference
References are like in PHP and not like Perl references.
Variable variables are sort of supported.
=a b assign $a with 'b' +=$a increments $b ($a is interpolated to 'b') ^$b displays "1"
= var foobar $var 'foobar' $[0]var 'f' (index) $[-1]var 'r' (rindex) $[0:3]var 'foo' (sub string) $[3:]var 'bar' (sub string) $[0,3]var 'fb' (index concatenation)
String expansion has been based on Bash shell expansion.
= foo foobar $foo = "foobar"
${foo} same as $foo "foobar"
${#foo} length 6
${^foo} uppercase first "Foobar"
${^^foo} uppercase "FOOBAR"
${,foo} lowercase first "foobar"
${,,foo} lowercase "foobar"
${[0]foo} character index "f"
${[5]foo} character index "r"
${[6]foo} character index "r"
${0:3:foo} substr "foo"
${3::foo} substr "bar"
${fo#foo} delete from start "obar"
${ar%foo} delete from end "foob"
Lists can have any types, even other lists though not explicitly. List constructors have four formats.
() empty list (1,2,3) list of three integers (1 2 3) same (1..3) same
Non-integer elements and variable interpolation is supported.
(a..z) letters 'a' through 'z' ($a,$b) interpolation
Nested lists can occur through interpolation.
= a (a,b)
= b ($a,c) (('a','b'),'c')
List elements can be assigned, either implicitly.
= []a 1 = []a 2
Or explicitly.
= [0]a 1 = [1]a 2
= var (a b c)
^ $var result is ('a','b','c')
$[0]var 'a' (index)
$[-1]var 'c' (index)
$[0:1]var (a,b) (slice)
$[0,3]var (a,c) (index concatenation)
Hashes can have any types, even lists and other hashes though not explicitly. Hash constructors have two formats.
(a=1,b=2,c=3) hash with three key/value pairs
{a,1,b,2,c,3} same
Keys can only be of lowercase letters and quotes are not used. A hash cannot be empty, as it will then be an empty list.
= foo (a='b') hash 'foo' element 'a' set to 'b' = bar (a=$foo) hash 'bar' element 'a' is hash 'foo'
Like lists hash elements can be assigned.
= [a]foo b hash 'foo' element 'a' set to 'b'
= [b]foo (a,b) hash 'foo' element 'b' set to ('a','b')
Hashes are also $ variables.
= var {a,1,b,2,c,3}
$[a]var 1 (index)
$[a:b]var (1,2) (slice)
$[a,c]var (1,3) (index concatenation)
Hash slices and index concatenation result in lists.
Lists and hashes can be combined in the PHP way.
= [0]a 1 = [1]a 2 = [a]a a = [b]a b result is ( 0 = 1, 1 = 2, a = a, b = b )
There are ways to construct complex lists and hashes, with complex string keys for example...
\n linefeed \r carriage return \t tab \e escape \\ backslash \$ dollar sign \" double quote \' single quote (within a single quoted string) \@ to escape parameter variables
\N null \T true \F false
Though not within double quoted strings.
\l lowercase next character \u uppercase next character \E end \L \U \q \Q \L lowercase to \E \U uppercase to \E \q single quote to \E \Q double quote to \E
Perl's quote-like operators are supported with extensions.
q/string/ like single quotes qq/string/ like double quotes qw/string/ like list qx/string/ like exec qm/string/ quote meta
qs/string/ wrap string in single quotes qd/string/ wrap string in double quotes
^ qs/have "3" 4's/ same as ^ "'have \"3\" 4's'" ^ qd/have "7" 9's/ same as ^ "\"have \"7\" 9's\""
Unlike Perl both interpolate variables and some escape sequences.