The London Perl and Raku Workshop takes place on 26th Oct 2024. If your company depends on Perl, please consider sponsoring and/or attending.


Tie::LazyList - Perl extension for lazy lists growing on demand


  use Tie::LazyList;

  my ( @arr, @arr2 );

  # lazy list of factorials
  tie @arr,  'Tie::LazyList', [ 1 ], 'FACT';
  tie @arr2, 'Tie::LazyList', 1, sub { my ( $array_ref, $n ) = @_; $array_ref->[ $n - 1 ] * $n };
  print "$_\n" for @arr;   # prints ( eternally ) 1!, 2!, 3! ..
  print "$_\n" for @arr2;  # the same

  # lazy list of powers of 2
  tie @arr,  'Tie::LazyList', 2, 'POW';
  tie @arr2, 'Tie::LazyList', 1, sub { my ( $array_ref, $n ) = @_; $array_ref->[ $n - 1 ] * 2 };
  print $arr [ 10 ], "\n", # prints 1024 = 2^10
        $arr2[ 10 ], "\n"; # the same

  # lasy lists of Fibonacci numbers, arithmetical/geometrical progressions and their sums, etc ..


Tie::LazyList allows you to create lazy lists ( "infinite lists, whose tail remain unevaluated", Watt ) growing on demand with user-defined generation function.

What you have is a usual Perl array whose elements are generated by some function and which may be accessed by $arr[x] as any other, but actually grows under the hood if the element you're accessing isn't generated yet. This way, the amount of memory wasted for the list is no more ( and no less, unfortunately ) then you need. Think about it as dynamically growing factorials ( Fibonacci numbers, arithmetic progression .. ) table which you can access for any element without need to explicitly build and maintain it.

All you need to specify is the initial list elements, generation function and .. that's it, actually - go and work with it ! See the example above - I think, they demonstrate the simplicity.

So, here are the rules : you create the new lazy list by

tie @array, 'Tie::LazyList', list init, generation function


list init

Initial elements of your list. It may be a single scalar variable ( number, usually ) or an array reference ( if you'd like to initialize more then one element ). Examples : 1 or 2 or [ 1, 2, 3 ]

generation function

Reference to the function which will be called to generate new list elements. When called it'll be passed the following parameters :

  • reference to the array filled from index 0 upto n-1

  • n - index of the element to generate

The function should return the value of the n-th array element.

In order to make our life a bit easier there is a number of, what I call, code abbreviations. It means that generation function may be not the code reference, but something much simpler - string, having one of the predefined values. Those values tells the module which generation function to use and they are :


Means arithmetic progression, list init should contain at least two elements in order to calculate progression's factor.


Means geometric progression, list init has the same restriction as in APROG.


Means arithmetic progression's summary, list init should contain, again, at least two elements, but of the original progression !


Means geometric progression's summary, list init has the same restriction as in APROG_SUM.


Means Fibonacci numbers, list init should contain at least two elements ( [ 0, 1 ], as you know )


Means factorials, list init should contain one element at least ( 1, as you know )


Means power - arising x to any power, list init should contain only numbers.


I'm not a mathematician .. may be you have more ideas ? Send them to !


  # lazy list of fractions 1/(2^n) - 1, 1/2, 1/4, 1/8 ..
  tie @array, 'Tie::LazyList', 1, sub { my( $array_ref, $n ) = @_; $array_ref->[ $n - 1 ] / 2 };
  # the same
  tie @array, 'Tie::LazyList', [ 1, 0.5 ], 'GPROG';
  # lazy list of above geometric progression's summary : arr[ n ] = 1 + 1/2 + 1/4 + .. + 1/(2^n)
  tie @array, 'Tie::LazyList', [ 1, 0.5 ], 'GPROG_SUM';
  # prints 1.99999904632568 = 1 + 1/2 + 1/4 + .. + 1/(2^20)
  print $array[ 20 ];

  # lazy list of Fibonacci numbers
  tie @array, 'Tie::LazyList', [ 0, 1 ], 'FIBON';
  # prints 13 = 5 + 8
  print $array[ 7 ];

  # lazy list of factorials
  tie @array, 'Tie::LazyList', 1, 'FACT';
  # prints 1.19785716699699e+100 = 70!
  print $array[ 70 ];

  # lazy list of powers of e
  tie @array, 'Tie::LazyList', 2.718281828, 'POW';
  # prints 148.413158977261 = e^5
  print $array[ 5 ];


Having tied an array what operations can you do with it ? Does it support a usual array operations like pop, push and splice ? The answer to the first question - not so many, actually. The answer to the second question is shorter - no, it doesn't.

The only operations an array tied to Tie::LazyList currently supports are element access $arr[x] and for ( @array ) eternal iteration ( isn't it great already ? ). Trying to apply anything else is a fatal error. Some functions ( like storing ) doesn't have any sense in lazy lists, others ( like filtering via grep ) may be implemented later ..


There's a $Tie::LazyList::locality variable stating how many additional list elements should be evaluated when expanding it. It's default value is 10 and it means whenever list should grow to index n it'll actually grow to index n + 10. You may set it to any number you like - my benchmarks showed that locality equal to 0 makes iteration from arr[0] to arr[1e6] much slower then iteration from arr[1e6] to arr[0] ( which is, obviously, the fastest in the total time ) Locality equal to 100 and 1000 didn't bring any further speedup when iterating over one million elements list, so 10 looks Ok.


  1. Apply map and grep on lazy lists

  2. Copy constructor for lazy lists ?


Not found yet



Object Oriented Perl by Damian Conway ( yeap, I've mentioned it too now )


Goldin Evgeny <>


Copyright (c) Goldin Evgeny. All rights reserved.

This library is free software. You can redistribute it and/or modify it under the same terms as Perl itself.