What is the difference between `state` and `const`?

Question

It seems similar to write:

use Const::Fast;
const $xx, 77;
sub test {
    do_something_with( $xx );    
}

or

sub test {
    state $xx =  77;
    do_something_with( $xx );    
}

What is the better way to accomplish this: via const or via state?

sub get_ip_country {
    my ($ip_address) = @_;
    my $ip_cc_database = GeoIP2::Database::Reader->new(file => '/etc/project/GeoLite2-Country.mmdb');
    ...
}

UPD
At this sub I do not change pointer togeoip database, so it should be const. But I not want recreate object each time when sub is called (this is slow). So I suppose it will be faster to use state, despite pointer is not changed.

It seems it should be const state $ip_cc_database

I don't think they have the same funcionality. [state](https://perldoc.perl.org/perlsub#Persistent-variables-via-state()) creates a variable that persist between function calls (and the value can change) and [const](https://metacpan.org/pod/Const::Fast) create read-only variables. — Giuliani Sanches, Jan 24 '22 at 13:17
@TedLyngmo: `GeoIP2::Database::Reader->new()` creates object — Eugen Konkov, Jan 25 '22 at 12:01
@EugenKonkov Yeah, but they are all objects in a sense. Re: `const state`: I don't think that works. Try it out but I don't think so. Since it's expensive to create the object, I'd go for `state` - or make a new class, containing a `const $ip_cc_database` that you instantiate with `state` — Ted Lyngmo, Jan 25 '22 at 12:07

Ted Lyngmo · Accepted Answer · 2022-01-24T13:42:34.477

8

They do not do the same thing.

state declares a variable that will only be initialized the first time you enter the function. It's mutable though, so you can change its value, but it will keep the value between calls to the same function. This program would for example print 78 and 79:
```
sub test {
    state $xx = 77;     # initialization only happens once
    print ++$xx . "\n"; # step the current value and print it
}
test; # 78
test; # 79
```
const declares an immutable (readonly) variable that, if declared in a function, would be reinitialized every time the function is called.

edited Jan 24 '22 at 13:42

answered Jan 24 '22 at 13:17

Ted Lyngmo

93,841
5
60
108

What is the best choice to use instead `my` at my example? – Eugen Konkov Jan 25 '22 at 10:58
@EugenKonkov I'm afraid that's not possible to tell from your example. You'll have to decide from the differences between `state` and `const` and decide from that. Is it supposed to be a constant (readonly) variable or not? If it's not supposed to be a constant, make it `const`. `state` as you can see is used for keeping state between calls to a function. Not at all the same thing. – Ted Lyngmo Jan 25 '22 at 11:49

score 4 · Answer 2 · answered Jan 24 '22 at 15:17

4

If you want a value that is constant, then you should use something like Const::Fast.

But if you want a value that can be changed, but which retains its value between calls to a function, then you need a state variable.

So running, this:

sub test {
  state $x = 1;

  say $x++;
}

test() for 1 .. 10;

Gives this:

But running this:

use Const::Fast;

sub test {
  const my $x, 1;

  say $x++;
}

test() for 1 .. 10;

Gives a runtime error:

Modification of a read-only value attempted at const_test line 12.

answered Jan 24 '22 at 15:17

Dave Cross

68,119
3
51
97

What is the best choice to use instead `my` at my example? – Eugen Konkov Jan 25 '22 at 10:58
1

@EugenKonkov: If your value is constant, then use a constant. If it varies, then use a variable. – Dave Cross Jan 25 '22 at 11:43
I updated question. It does not varies, but I do not want recreate object each time when sub is called. – Eugen Konkov Jan 25 '22 at 11:58

score 1 · Answer 3 · answered Jan 25 '22 at 15:34

As @TedLyngmo points out in a comment to your OP, const state is not valid Perl. const is a pragma, so works at compile time, while state is a runtime construct.

In terms of your efficiency requirement, that the GeoIP2::Database::Reader constructor is called only once, either will work. If you further want it to be read-only so that you cannot inadvertently invalidate the reference, you can still use both. const does it for you automatically, but you can duplicate that behavior with state with a layer of indirection:

sub ip_cc_database {
   state $db = GeoIP2::Database::Reader->new(file => '/etc/project/GeoLite2-Country.mmdb');
}
sub get_ip_country {
    my ($ip_address) = @_;
    my $ip_cc_database = ip_cc_database();
    ...
}

The answer to your question about when to use one over the other is a bit more nuanced.

The real difference between the two approaches is when the constructor is called. Using const it's during the compile phase, with state it's during runtime.

If you're application always calls get_ip_country, and you don't care about amortizing startup costs over the lifetime of the process, const is simpler.

However, if you don't always call get_ip_country, and creating the GeoIP2::Database::Reader object is expensive, then using state means you only pay for that cost if you need it.

There's also the user experience to consider. If your program is interactive or if it starts generating output before you need to call get_ip_country, delaying creating the object until its actually needed means your program doesn't just sit there seemingly doing nothing until all of the startup has completed.

What is the difference between `state` and `const`?

3 Answers3