There are several differences between sigilless and sigilled variables, which are already documented in the Raku docs. This is simply my attempt at consolidating them in a single place.
At the surface, a sigil or lack thereof is the most apparent difference between sigilless and sigilled variables. As their names imply, sigilless variable don't have sigils while sigilled variables do.
my \degrees = pi / 180;
my $angle = 90;
Sigilless variables are declared using the \
prefix, which is dropped when using the variables. For sigilled variables, the sigil is part of the variable's name and thus must be used when both declaring a variable and using it.
say degrees;
say $angle;
Sigilless variables are bound by default. You can bind sigilless variables with both the binding operator :=
and the assignment operator =
; both operators have the same effect.
my \a = 42;
my \b := 42;
In order to bind to a sigilled variable, you must use the binding operator :=
.
my $c := 42;
Unlike sigilless variables, you can always re-bind sigilled variables.
my $c := 42;
$c := 45; # Ok!
To prevent re-binding to a sigilled variable, you can declare it as a constant
.
my constant $d := 42;
$d := 45; # Cannot bind to '$d' because it was bound in a signature and variables
# bound in signatures cannot be rebound unless they were declared with the
# 'is rw' or 'is copy' traits
A more striking difference between sigilless and sigilled variables is the fact sigilless variables do not have associated containers.
my \a = 42;
my $b = 42;
say a.VAR.^name; # 42
say $b.VAR.^name; # Scalar
If the value bound to the sigilless variable is containerized, then its container will be the variable's container.
my \c = [1, 2];
my @d = [1, 2];
say c.VAR.^name; # Array
say @d.VAR.^name; # Array
Whether or not you can assign to a sigilless variable ultimately depends on what's bound to it. If it's an immutable structure (i.e., no container), as shown here with an Int
, then you cannot assign to it once it's been declared.
my \a = 42;
a = 84; # Error: Cannot modify an immutable Int (42)
If you bind a mutable structure to the sigilless variable, you can assign to the variable once it's been bound.
my \f = [1, 2];
say f; # [1, 2]
f = [4, 5];
say f; # [4, 5]
Here, the circumfix operator []
creates an Array
, which is mutable by design and thus allows for assignments.
With assignment sigilled variables create containers by default, thus you can update a variable's value through subsequent assignment.
my $b = 42;
$b = 21;
Unlike sigilled variables, sigilless variables don't enforce context.
my \list = (1, 2, 3);
for list { .say }
# OUTPUT:
# 1
# 2
# 3
my $item = (1, 2, 3);
for $item { .say }
# OUTPUT:
# (1 2 3)
Assigning to a scalar variable $
means the content is itemized (i.e., a single thing), shown by $item
which when looped produces a single item, i.e., the list (1, 2, 3)
itself. In contrast, the list in list
isn't itemized and the for
loops over its elements.
-
Lizmat on why you can assign to a
constant
sigilless variable declared to a mutable structure, namelymy constant \foo = [42]; say foo; # [42] foo = 99; say foo; # [99]
From lizmat, "Yes, because in at least all current language versions of Raku,
[]
is a circumfix operator creating anArray
. AndArray
s are mutable by design." -
vrurg's clarification about sigilled variables being alias as much as sigilless variable, and that containers are created with assignment, instead of always being there. From vrurg: "Any symbol in Raku is an alias. Sigilled ones are no exception." From theangryepicbanana: "I just meant "alias" as in "it directly references the rhs", as opposed to a sigilled variable which creates a container [with assignment]".