(Identifier) terms vs. constants vs. null signature routines

Question

Identifier terms are defined in the documentation alongside constants, with pretty much the same use case, although terms compute their value in run time while constants get it in compile time. Potentially, that could make terms use global variables, but that's action at a distance and ugly, so I guess that's not their use case. OTOH, they could be simply routines with null signature:

sub term:<þor> { "Is mighty" }
sub Þor { "Is mighty" }

say þor, Þor;

But you can already define routines with null signature. You can sabe, however, the error when you write:

say Þor ~ Þor;

Which would produce a many positionals passed; expected 0 arguments but got 1, unlike the term. That seems however a bit farfetched and you can save the trouble by just adding () at the end.

Another possible use case is defying the rules of normal identifiers

sub term:<✔> { True }
say ✔; # True

Are there any other use cases I have missed?

timotimo · Accepted Answer · 2019-03-22 10:23:47Z

5

Making zero-argument subs work as terms will break the possibility to post-declare subs, since finding a sub after having parsed usages of it would require re-parsing of earlier code (which the perl 6 language refuses to do, "one-pass parsing" and all that) if the sub takes no arguments.

answered Mar 22, 2019 at 10:23

timotimo

4,43421 silver badges23 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Elizabeth Mattijsen · Accepted Answer · 2019-03-22 10:13:25Z

4

Terms are useful in combination with the ternary operator:

$ perl6 -e 'sub a() { "foo" }; say 42 ?? a !! 666'
===SORRY!=== Error while compiling -e
Your !! was gobbled by the expression in the middle; please parenthesize

$ perl6 -e 'sub term:<a> { "foo" }; say 42 ?? a !! 666'
foo

answered Mar 22, 2019 at 10:13

Elizabeth Mattijsen

27.1k3 gold badges77 silver badges106 bronze badges

Comments

Brad Gilbert · Accepted Answer · 2019-03-22 17:30:45Z

Constants are basically terms. So of course they are grouped together.

constant foo = 12;

say foo;

constant term:<bar> = 36;

say bar;

There is a slight difference because term:<…> works by modifying the parser. So it takes precedence.

constant fubar = 38;
constant term:<fubar> = 45;

say fubar; # 45

The above will print 45 regardless of which constant definition comes first.

Since term:<…> takes precedence the only way to get at the other value is to use ::<fubar> to directly access the symbol table.

say ::<fubar>; # 38
say ::<term:<fubar>>; # 45

There are two main use-cases for term:<…>.

One is to get a subroutine to be parsed similarly to a constant or sigilless variable.

sub fubar () { 'fubar'.comb.roll }

# say( fubar( prefix:<~>( 4 ) ) );
say fubar ~ 4; # ERROR

sub term:<fubar> () { 'fubar'.comb.roll }

# say( infix:<~>( fubar, 4 ) );
say fubar ~ 4;

The other is to have a constant or sigiless variable be something other than an a normal identifier.

my \✔ = True; # ERROR: Malformed my

my \term:<✔> = True;

say ✔;

Of course both use-cases can be combined.

sub term:<✔> () { True }

Perl 5 allows subroutines to have an empty prototype (different than a signature) which will alter how it gets parsed. The main purpose of prototypes in Perl 5 is to alter how the code gets parsed.

use v5;

sub fubar () { ord [split('','fubar')]->[rand 5] }

# say( fubar() + 4 );
say fubar + 4; # infix +

use v5;

sub fubar { ord [split('','fubar')]->[rand 5] }

# say( fubar( +4 ) );
say fubar + 4; # prefix +

Perl 6 doesn't use signatures the way Perl 5 uses prototypes. The main way to alter how Perl 6 parses code is by using the namespace.

use v6;

sub fubar ( $_ ) { .comb.roll }
sub term:<fubar> () { 'fubar'.comb.roll }

say fubar( 'zoo' ); # `z` or `o` (`o` is twice as likely)
say fubar; # `f` or `u` or `b` or `a` or `r`


sub prefix:<✔> ( $_ ) { "checked $_" }

say ✔ 'under the bed'; # checked under the bed

Note that Perl 5 doesn't really have constants, they are just subroutines with an empty prototype.

use v5;

use constant foo => 12;

use v5;

sub foo () { 12 } # ditto

(This became less true after 5.16)

As far as I know all of the other uses of prototypes have been superseded by design decisions in Perl 6.

use v5;
sub foo (&$) { $_[0]->($_[1]) }

say foo { 100 + $_[0] } 5; # 105;

That block is seen as a sub lambda because of the prototype of the foo subroutine.

use v6;
# sub foo ( &f, $v ) { f $v }
sub foo { @_[0].( @_[1] ) }

say foo { 100 + @_[0] }, 5; # 105

In Perl 6 a block is seen as a lambda if a term is expected. So there is no need to alter the parser with a feature like a prototype.

You are asking for exactly one use of prototypes to be brought back even though there is already a feature that covers that use-case.

Doing so would be a special-case. Part of the design ethos of Perl 6 is to limit the number of special-cases.
Other versions of Perl had a wide variety of special-cases, and it isn't always easy to remember them all.

Don't get me wrong; the special-cases in Perl 5 are useful, but Perl 6 has for the most part made them general-cases.

Collectives™ on Stack Overflow

(Identifier) terms vs. constants vs. null signature routines

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related