Re: Declarations of constants

[Adam Kennedy]

Ingo Blechschmidt wrote:

Hi,

  # Way 1
  my $MEANING_OF_LIFE is constant = 42;


Forgive my ignorance here, but for all of these different ways of doing 
constants, will they all optimize (including partial 
evaluation/currying) at compile/build/init/run-time?


my $gravity is constant = 10; # One significant figure

sub time_to_ground ($height, $accel) {
...acceleration math...
}

my $time = time_to_ground( 500, $gravity );

... thus simplifying internally to

my $time = 1234;

Adam K

Re: Declarations of constants

[Simon Cozens]

[EMAIL PROTECTED] (Adam Kennedy) writes:
 Forgive my ignorance here, but for all of these different ways of
 doing constants, will they all optimize (including partial
 evaluation/currying) at compile/build/init/run-time?

Gosh, I hope not.

 my $gravity is constant = 10; # One significant figure
 sub time_to_ground ($height, $accel) {
   ...acceleration math...
 }

The ability to play around with the working of time_to_ground before it
runs is one of the things I like about Perl.

-- 
A language that doesn't have everything is actually easier to program
in than some that do.
-- Dennis M. Ritchie

Re: Declarations of constants

[Damian Conway]

Adam Kennedy wrote:

Forgive my ignorance here, but for all of these different ways of doing 
constants, will they all optimize (including partial 
evaluation/currying) at compile/build/init/run-time?


my $gravity is constant = 10; # One significant figure

sub time_to_ground ($height, $accel) {
...acceleration math...
}

my $time = time_to_ground( 500, $gravity );

... thus simplifying internally to

my $time = 1234;


No. But you could get the effect by explicitly asking for time_to_ground() to 
be called at compile-time:


  my $gravity is constant = 10; # One significant figure

  macro time_to_ground ($height, $accel) {
 ...acceleration math...
  }

  my $time = time_to_ground( 500, $gravity );

Damian

Declarations of constants

[Ingo Blechschmidt]

Hi,

  # Way 1
  my $MEANING_OF_LIFE is constant = 42;


  # Way 2
  my MEANING_OF_LIVE = - () { 42 };
  # or
  sub MEANING_OF_LIVE () { 42 }

  # Then one can use sigilless constants:
  say MEANING_OF_LIVE;


  # Way 3 (still possible?)
  use constant MEANING_OF_LIVE = 42;


  # Way 4 (evil?)
  macro MEANING_OF_LIVE { 42 }


  # Way 5 (overloading of the numification of Class -- evil)
  Class does role {
method *prefix:+ (MEANING_OF_LIVE $class:) {
  42;
}
  }
  class MEANING_OF_LIVE {}
  
  say +MEANING_OF_LIVE;


  # Please add more ways :)


--Ingo

-- 
Linux, the choice of a GNU | Black holes result when God divides the
generation on a dual AMD   | universe by zero.  
Athlon!|

Re: Declarations of constants

[TSa (Thomas Sandlaß)]

Ingo Blechschmidt wrote:

  # Please add more ways :)


enum MEANING_OF_LIVE:(42);

my MEANING_OF_LIVE = 42; # But might be considered evil sigilless mode
--
TSa (Thomas Sandlaß)

Re: Declarations of constants

[Ingo Blechschmidt]

Hi,

TSa (Thomas Sandla) wrote:
 my MEANING_OF_LIVE = 42; # But might be considered evil sigilless
 mode

is that allowed (as 42 is a Num (or an Int), not a Code)?

Do (most of) the basic types morph themselves into Codes, when needed?
  say 42();# 42?
  say Perl();# Perl?
  say [1,2,3].does(Code)   # true?

Or did you simply forget the braces around 42? :)


--Ingo

-- 
Linux, the choice of a GNU | Wer die Freiheit aufgibt, um Sicherheit zu 
generation on a dual AMD   | gewinnen, der wird am Ende beides
Athlon!| verlieren -- Benjamin Franklin  

Re: Declarations of constants

[TSa (Thomas Sandlaß)]

Ingo Blechschmidt wrote:

is that allowed (as 42 is a Num (or an Int), not a Code)?


I don't know, but guess not.



Do (most of) the basic types morph themselves into Codes, when needed?


I don't consider it type morphing. If your examples parse
at all they will be dispatched as usual


  say 42();# 42?


postfix:.( ):( Int :)


  say Perl();# Perl?


postfix:.( ):( Str :)


  say [1,2,3].does(Code)   # true?


Depends on the type of [] which is Ref of Array or so.
But I think it should be false.


Or did you simply forget the braces around 42? :)


No, it was intented for seeing what the reactions will be :)
Just using foo as unsigiled variable. This might need

my foo is rw;

But then I presume you could say:

foo = 17;
if foo  8
{
   @a[foo] = 8;
}

We could call that a codeless lvalue sub ;)
--
TSa (Thomas Sandla)

Re: Declarations of constants

[Ingo Blechschmidt]

Hi,

TSa (Thomas Sandla) wrote:
 Ingo Blechschmidt wrote:
 Or did you simply forget the braces around 42? :)
 
 No, it was intented for seeing what the reactions will be :)

:)

 Just using foo as unsigiled variable. This might need
 
 my foo is rw;

I don't think this will DWYW, as firstly is rw is the default
on vars declared with my(), and secondly foo will be undef, not some
kind of Proxy object. To do what you want, you'd have to write (I
think):
  my foo = new_codeless_lvalue_sub();

  sub new_codeless_lvalue_sub {
my $var;
return {
  new Proxy: FETCH = { $var }, STORE = - $new { $var = $new };
};
  }

 But then I presume you could say:
 
 foo = 17;
 if foo  8
 {
 @a[foo] = 8;
 }
 
 We could call that a codeless lvalue sub ;)

This indeed looks very slick! I wouldn't use it for normal vars, though.


--Ingo

-- 
Linux, the choice of a GNU | The next statement is not true.
generation on a dual AMD   | The previous statement is true.  
Athlon!|