Sidef/Optimizer.pm untested

filter: Statementstmt 0.0% 0 / 488 Branchbran 0.0% 0 / 164 Conditioncond 0.0% 0 / 95 MC/DCmcdc 0.0% 0 / 51 Subroutinesub 0.0% 0 / 12 Podpod 0.0% 0 / 7 totaltotal 0.0% 0 / 817 CC 83 SCAR 86.5
CC
83
Cov
0%
optimize_expr
6642.0
optimize
12.0
methods
2.0
CRAP 5724.0
1 package Sidef::Optimizer;
2  
3 use utf8;
4 use 5.016;
5 use Scalar::Util qw(refaddr);
6  
7 use constant {
8 STRING => 'Sidef::Types::String::String',
9 NUMBER => 'Sidef::Types::Number::Number',
10 MOD => 'Sidef::Types::Number::Mod',
11 GAUSS => 'Sidef::Types::Number::Gauss',
12 FRACTION => 'Sidef::Types::Number::Fraction',
13 QUADRATIC => 'Sidef::Types::Number::Quadratic',
14 QUATERNION => 'Sidef::Types::Number::Quaternion',
15 REGEX => 'Sidef::Types::Regex::Regex',
16 BOOL => 'Sidef::Types::Bool::Bool',
17 ARRAY => 'Sidef::Types::Array::Array',
18 RANGENUM => 'Sidef::Types::Range::RangeNumber',
19 RANGESTR => 'Sidef::Types::Range::RangeString',
20 DIR_DT => 'Sidef::DataTypes::Glob::Dir',
21 FILE_DT => 'Sidef::DataTypes::Glob::File',
22 PIPE_DT => 'Sidef::DataTypes::Glob::Pipe',
23 NUMBER_DT => 'Sidef::DataTypes::Number::Number',
24 STRING_DT => 'Sidef::DataTypes::String::String',
25 COMPLEX_DT => 'Sidef::DataTypes::Number::Complex',
26 REGEX_DT => 'Sidef::DataTypes::Regex::Regex',
27 GAUSS_DT => 'Sidef::DataTypes::Number::Gauss',
28 MOD_DT => 'Sidef::DataTypes::Number::Mod',
29 FRACTION_DT => 'Sidef::DataTypes::Number::Fraction',
30 QUADRATIC_DT => 'Sidef::DataTypes::Number::Quadratic',
31 QUATERNION_DT => 'Sidef::DataTypes::Number::Quaternion',
32 RANGENUM_DT => 'Sidef::DataTypes::Range::RangeNumber',
33 RANGESTR_DT => 'Sidef::DataTypes::Range::RangeString',
34 BACKTICK_DT => 'Sidef::DataTypes::Glob::Backtick',
35 PERL_DT => 'Sidef::DataTypes::Perl::Perl',
36 };
37  
38 my %dt_table = (
39 qw(
40 Sidef::DataTypes::Bool::Bool Sidef::Types::Bool::Bool
41 Sidef::DataTypes::Array::Array Sidef::Types::Array::Array
42 Sidef::DataTypes::Array::Pair Sidef::Types::Array::Pair
43 Sidef::DataTypes::Array::Matrix Sidef::Types::Array::Matrix
44 Sidef::DataTypes::Hash::Hash Sidef::Types::Hash::Hash
45 Sidef::DataTypes::Set::Set Sidef::Types::Set::Set
46 Sidef::DataTypes::Set::Bag Sidef::Types::Set::Bag
47 Sidef::DataTypes::Regex::Regex Sidef::Types::Regex::Regex
48 Sidef::DataTypes::String::String Sidef::Types::String::String
49 Sidef::DataTypes::Number::Number Sidef::Types::Number::Number
50 Sidef::DataTypes::Number::Complex Sidef::Types::Number::Complex
51 Sidef::DataTypes::Number::Fraction Sidef::Types::Number::Fraction
52 Sidef::DataTypes::Number::Gauss Sidef::Types::Number::Gauss
53 Sidef::DataTypes::Number::Mod Sidef::Types::Number::Mod
54 Sidef::DataTypes::Number::Quadratic Sidef::Types::Number::Quadratic
55 Sidef::DataTypes::Number::Quaternion Sidef::Types::Number::Quaternion
56 Sidef::DataTypes::Range::RangeNumber Sidef::Types::Range::RangeNumber
57 Sidef::DataTypes::Range::RangeString Sidef::Types::Range::RangeString
58 Sidef::DataTypes::Glob::Backtick Sidef::Types::Glob::Backtick
59 Sidef::DataTypes::Glob::Socket Sidef::Types::Glob::Socket
60 Sidef::DataTypes::Glob::Pipe Sidef::Types::Glob::Pipe
61 Sidef::DataTypes::Glob::Dir Sidef::Types::Glob::Dir
62 Sidef::DataTypes::Glob::File Sidef::Types::Glob::File
63 Sidef::DataTypes::Perl::Perl Sidef::Types::Perl::Perl
64 )
65 );
66  
67 my %cache;
68 {
69  
70 sub methods {
71 my ($package, @names) = @_;
72 my $module = ($cache{$package} //= (($package =~ s{::}{/}gr) . '.pm'));
73 exists($INC{$module}) || require($module);
74 map {
75 $cache{join(' ', $package, $_)} //= do {
76 defined(my $method = UNIVERSAL::can($package, $_))
77 or die "[ERROR] Invalid method $package: $_";
78 $method;
79 }
80 } @names;
81 }
82  
83 sub dtypes {
84 my ($type, @names) = @_;
85  
86 exists($dt_table{$type}) || die "[ERROR] Non-existent data type: $type";
87  
88 my $package = $dt_table{$type};
89 my $module = ($cache{$package} //= (($package =~ s{::}{/}gr) . '.pm'));
90  
91 exists($INC{$module}) || require($module);
92  
93 map {
94 $cache{join(' ', $type, $_)} //= do {
95 defined(my $method = UNIVERSAL::can($package, $_))
96 or die "[ERROR] Invalid method $package: $_";
97 $method;
98 }
99 } @names;
100 }
101 }
102  
103 sub table {
104 [@_];
105 }
106  
107 sub build_tree {
108 my (@data) = @_;
109  
110 require Algorithm::Loops;
111  
112 my %tree;
113 foreach my $node (@data) {
114 my $ref = ($tree{$node->[0]} //= {});
115 $ref = $ref->{$#{$node->[1]}} //= {};
116 my $orig = $ref;
117 my $iter = Algorithm::Loops::NestedLoops($node->[1]);
118 while (my @list = $iter->()) {
119 $ref = $orig;
120 foreach my $key (@list) {
121 $ref = $ref->{$key} //= {};
122 }
123 }
124 }
125  
126 \%tree;
127 }
128  
129 my %rules = (
130 (STRING) => build_tree(
131  
132 # String.method(String)
133 (
134 map { [$_, [table(STRING)]] } methods(
135 STRING, qw(
136 to
137 downto
138  
139 pack
140 concat
141 prepend
142  
143 gt lt le ge cmp
144  
145 xor and or
146 eq ne
147  
148 index
149 crypt
150  
151 levenshtein
152 jaro
153 contains
154 overlaps
155 begins_with
156 ends_with
157 count
158 range
159  
160 sprintf
161 sprintlnf
162  
163 encode
164 decode
165 )
166 )
167 ),
168  
169 # String.method()
170 (
171 map { [$_, []] } methods(
172 STRING, qw(
173 lc uc fc tc wc tclc lcfirst
174  
175 pop
176 chop
177 chomp
178  
179 chars_len
180 bytes_len
181 graphs_len
182  
183 pipe
184 chars
185 bytes
186 lines
187 words
188 backtick
189 graphemes
190  
191 ord
192 oct
193 hex
194 bin
195 num
196 not
197  
198 first
199 last
200  
201 repeat
202 reverse
203 clear
204 sort
205 split
206 range
207  
208 is_empty
209 is_palindrome
210  
211 trim
212 trim_beg
213 trim_end
214  
215 encode_utf8
216 decode_utf8
217  
218 sprintf
219 sprintlnf
220  
221 dump to_s
222 apply_escapes
223 unescape
224 quotemeta
225 looks_like_number
226 )
227 )
228 ),
229  
230 # String.method(Number)
231 (
232 map { [$_, [table(NUMBER)]] } methods(
233 STRING, qw(
234 eq ne
235  
236 mul
237 div
238 repeat
239 char
240 slice
241  
242 sprintf
243 sprintlnf
244  
245 shift_left
246 shift_right
247 )
248 )
249 ),
250  
251 # String.method(String | Number | Regex)
252 (map { [$_, [table(STRING, NUMBER, REGEX)]] } methods(STRING, qw(split))),
253  
254 # String.method(String, String)
255 (
256 map { [$_, [table(STRING), table(STRING)]] } methods(
257 STRING, qw(
258 tr
259 )
260 )
261 ),
262  
263 # String.method(String, String, String)
264 (
265 map { [$_, [table(STRING), table(STRING), table(STRING)]] } methods(
266 STRING, qw(
267 tr
268 )
269 )
270 ),
271  
272 # String.method(Number, Number)
273 (
274 map { [$_, [table(NUMBER), table(NUMBER)]] } methods(
275 STRING, qw(
276 slice
277 )
278 )
279 ),
280  
281 # String.method(String, Number)
282 (
283 map { [$_, [table(STRING), table(NUMBER)]] } methods(
284 STRING, qw(
285 index
286 contains
287 sprintf
288 sprintlnf
289 )
290 )
291 ),
292  
293 # String.method(String, Bool)
294 (
295 map { [$_, [table(STRING), table(BOOL)]] } methods(
296 STRING, qw(
297 range
298 )
299 )
300 ),
301 ),
302  
303 (MOD) => build_tree(
304  
305 # Mod.method()
306 (
307 map { [$_, []] } methods(
308 MOD, qw(
309 abs dump fib lucas inv
310 is_inf is_mone is_nan
311 is_neg is_ninf is_one
312 is_pos is_real is_zero
313 lift neg norm pretty
314 re sqr sqrt to_s znorder
315 not chinese factorial
316 inc dec eval
317 )
318 )
319 ),
320  
321 # Mod.method(Mod | Number)
322 (
323 map { [$_, [table(MOD, NUMBER)]] } methods(
324 MOD, qw(
325 + - / * %
326  
327 lt gt le ge cmp
328 eq ne
329 and or xor
330  
331 eval ChebyshevT ChebyshevU cyclotomic
332 )
333 )
334 ),
335  
336 # Mod.method(Number)
337 (
338 map { [$_, [table(MOD, NUMBER)]] } methods(
339 MOD, qw(
340 << >> **
341 ChebyshevT ChebyshevU cyclotomic
342 )
343 )
344 ),
345  
346 # Mod.method(Mod)
347 (
348 map { [$_, [table(MOD)]] } methods(
349 MOD, qw(
350 chinese
351 )
352 )
353 ),
354  
355 # Mod.method(Number, Number, Number)
356 (
357 map { [$_, [table(NUMBER), table(NUMBER)]] } methods(
358 MOD, qw(
359 LucasU LucasV
360 )
361 )
362 ),
363 ),
364  
365 (FRACTION) => build_tree(
366  
367 # Fraction.method()
368 (
369 map { [$_, []] } methods(
370 FRACTION, qw(
371 nu de abs ceil floor trunc dump
372 float inv inc dec
373 is_mone is_nan is_one
374 is_real is_zero lift neg
375 parts pretty round eval
376 sgn sqr to_s to_n not
377 )
378 )
379 ),
380  
381 # Fraction.method(Fraction | Number)
382 (
383 map { [$_, [table(FRACTION, NUMBER)]] } methods(
384 FRACTION, qw(
385 + - / * % ** << >>
386  
387 lt gt le ge cmp
388 eq ne
389 and or xor
390  
391 eval invmod round
392 )
393 )
394 ),
395  
396 # Fraction.method(Number, Number)
397 (
398 map { [$_, [table(NUMBER), table(NUMBER)]] } methods(
399 FRACTION, qw(
400 powmod
401 )
402 )
403 ),
404 ),
405  
406 (GAUSS) => build_tree(
407  
408 # Gauss.method()
409 (
410 map { [$_, []] } methods(
411 GAUSS, qw(
412 a b abs ceil conj dump
413 float floor i iabs inv inc dec
414 is_imag is_mone is_one is_prime
415 is_real is_zero lift neg
416 norm parts pretty round
417 sgn sqr to_c to_s not eval
418 )
419 )
420 ),
421  
422 # Gauss.method(Gauss | Number)
423 (
424 map { [$_, [table(GAUSS, NUMBER)]] } methods(
425 GAUSS, qw(
426 + - / * % ** << >>
427  
428 lt gt le ge cmp
429 eq ne
430 and or xor
431  
432 gcd gcd_norm eval
433 invmod is_coprime round
434 )
435 )
436 ),
437  
438 # Gauss.method(Number, Gauss | Number)
439 (
440 map { [$_, [table(NUMBER), table(GAUSS, NUMBER)]] } methods(
441 GAUSS, qw(
442 powmod
443 )
444 )
445 ),
446 ),
447  
448 (QUADRATIC) => build_tree(
449  
450 # Quadratic.method()
451 (
452 map { [$_, []] } methods(
453 QUADRATIC, qw(
454 a b abs ceil conj dump
455 float floor inv inc dec not
456 is_mone is_one is_zero eval
457 lift neg norm parts trace
458 pretty round sgn sqr to_c to_s
459 )
460 )
461 ),
462  
463 # Quadratic.method(Quadratic | Number)
464 (
465 map { [$_, [table(QUADRATIC, NUMBER)]] } methods(
466 QUADRATIC, qw(
467 + - / * % ** << >>
468  
469 lt gt le ge cmp
470 eq ne
471 and or xor
472  
473 eval invmod is_coprime round divmod
474 )
475 )
476 ),
477  
478 # Quadratic.method(Number, Number)
479 (
480 map { [$_, [table(NUMBER), table(NUMBER)]] } methods(
481 QUADRATIC, qw(
482 powmod
483 )
484 )
485 ),
486 ),
487  
488 (QUATERNION) => build_tree(
489  
490 # Quaternion.method()
491 (
492 map { [$_, []] } methods(
493 QUATERNION, qw(
494 a b c d abs ceil conj dump
495 float floor inv inc dec not
496 is_mone is_one is_zero
497 lift neg norm parts
498 pretty round sgn sqr to_c to_s
499 to_gauss eval
500 )
501 )
502 ),
503  
504 # Quaternion.method(Quaternion | Number)
505 (
506 map { [$_, [table(QUATERNION, NUMBER)]] } methods(
507 QUATERNION, qw(
508 + - / * % ** << >>
509  
510 lt gt le ge cmp
511 eq ne
512 and or xor
513  
514 eval invmod is_coprime round
515 )
516 )
517 ),
518  
519 # Quaternion.method(Number, Number)
520 (
521 map { [$_, [table(NUMBER), table(NUMBER)]] } methods(
522 QUATERNION, qw(
523 powmod
524 )
525 )
526 ),
527 ),
528  
529 (NUMBER) => build_tree(
530  
531 # Number.method(Number)
532 (
533 map { [$_, [table(MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION)]] } methods(
534 NUMBER, qw(
535 + - * /
536 )
537 )
538 ),
539  
540 # Number.method(Number)
541 (
542 map { [$_, [table(NUMBER)]] } methods(
543 NUMBER, qw(
544 + - / * % %% **
545  
546 lt gt le ge cmp
547 eq ne
548 and or xor
549  
550 sigma
551 usigma
552  
553 prime_sigma
554 prime_usigma
555  
556 is_power
557  
558 complex
559 root iroot
560 log
561 next_pow
562 prev_pow
563 max min
564 roundf
565 binomial
566 subfactorial
567 invmod
568 isub
569 iadd
570 imul
571 idiv
572 ipow
573 imod
574 range
575 to xto
576 downto xdownto
577  
578 shift_right
579 shift_left
580 )
581 )
582 ),
583  
584 # Number.method()
585 (
586 map { [$_, []] } methods(
587 NUMBER, qw(
588 inc dec not range
589  
590 factorial
591 subfactorial
592 superfactorial
593 hyperfactorial
594 lnsuperfactorial
595 lnhyperfactorial
596 sqrt isqrt
597 abs int rat float complex
598 norm conj sqr cube
599  
600 zeta
601 eta
602 beta
603 gamma
604 Ai
605 Li
606 Li2
607 Ei
608  
609 sigma
610 sigma0
611  
612 usigma
613 usigma0
614  
615 prime_sigma
616 prime_usigma
617  
618 divisors
619 udivisors
620  
621 factor
622 factor_exp
623  
624 exp
625 exp2
626 exp10
627  
628 cos sin
629  
630 ln
631 log
632 log2
633 log10
634  
635 sin
636 asin
637 sinh
638 asinh
639  
640 cos
641 acos
642 cosh
643 acosh
644  
645 tan
646 atan
647 tanh
648 atanh
649  
650 cot
651 acot
652 coth
653 acoth
654  
655 sec
656 sech
657 asec
658 asech
659  
660 csc
661 csch
662 acsc
663 acsch
664  
665 cot
666 acot
667 coth
668 acoth
669  
670 inf
671 neg
672 sign
673 nan
674 chr
675  
676 i pi tau
677 e ln2 phi
678 EulerGamma
679 CatalanG
680  
681 is_zero
682 is_one
683 is_nan
684 is_pos
685 is_neg
686 is_even
687 is_odd
688 is_inf
689 is_ninf
690 is_int
691  
692 is_prime
693 is_square
694 is_power
695  
696 sgn
697 ceil
698 floor
699 length
700  
701 ilog
702 ilog2
703 ilog10
704  
705 isqrt
706 icbrt
707  
708 numerator
709 denominator
710  
711 digits
712  
713 as_bin
714 as_oct
715 as_hex
716 as_rat
717 as_frac
718  
719 dump
720 eval
721 commify
722 )
723 )
724 ),
725  
726 # Number.method(Number, Number)
727 (
728 map { [$_, [table(NUMBER), table(NUMBER)]] } methods(
729 NUMBER, qw(
730 powmod
731 range
732 )
733 )
734 ),
735 ),
736  
737 (BOOL) => build_tree(
738 (
739 map { [$_, []] } methods(
740 BOOL, qw(
741 not
742 is_true
743 true
744 false
745 to_bool
746 dump
747 )
748 )
749 ),
750 ),
751  
752 (ARRAY) => build_tree(
753 (
754 map { [$_, []] } methods(
755 ARRAY, qw(
756 first
757 last
758  
759 freq
760 len end
761 is_empty
762 min max
763  
764 sum
765 prod
766  
767 zip
768 cartesian
769 permutations
770 derangements
771 circular_permutations
772  
773 sort
774 reverse
775  
776 unique
777 last_unique
778 flatten
779  
780 to_s
781 dump
782 )
783 )
784 ),
785  
786 (
787 map { [$_, [table(NUMBER)]] } methods(
788 ARRAY, qw(
789 count
790 index
791 rindex
792 exists
793 defined
794 contains
795  
796 subsets
797 partitions
798 variations
799 variations_with_repetition
800 combinations
801 combinations_with_repetition
802  
803 nth_permutation
804  
805 div
806 mul
807  
808 rotate
809  
810 first
811 last
812 item
813 slice
814  
815 sum
816 prod
817  
818 take_right
819 take_left
820 )
821 )
822 ),
823  
824 (
825 map { [$_, [table(ARRAY)]] } methods(
826 ARRAY, qw(
827 and
828 or
829 xor
830 concat
831  
832 eq ne
833 contains_type
834 contains_any
835 contains_all
836 )
837 )
838 ),
839  
840 (
841 map { [$_, [table(STRING)]] } methods(
842 ARRAY, qw(
843 pack
844 join
845 index
846 rindex
847 count
848 contains
849 contains_type
850 reduce
851 reduce_operator
852 )
853 )
854 ),
855  
856 (map { [$_, [table('')]] } methods(ARRAY, qw(reduce_operator))),
857 ),
858  
859 (RANGENUM) => build_tree(
860  
861 # RangeNum.method(Number)
862 (
863 map { [$_, [table(NUMBER)]] } methods(
864 RANGENUM, qw(
865 from to by
866 sum add sub mul div
867 )
868 )
869 ),
870  
871 # RangeNum.method()
872 (
873 map { [$_, []] } methods(
874 RANGENUM, qw(
875 first last reverse
876 min max step flip
877 sum length neg
878 )
879 )
880 ),
881 ),
882  
883 (RANGESTR) => build_tree(
884  
885 # RangeStr.method(Number)
886 (
887 map { [$_, [table(NUMBER)]] } methods(
888 RANGESTR, qw(
889 by add sub mul div
890 )
891 )
892 ),
893  
894 # RangeStr.method()
895 (
896 map { [$_, []] } methods(
897 RANGESTR, qw(
898 first last reverse
899 min max step flip
900 length neg
901 )
902 )
903 ),
904 ),
905  
906 (NUMBER_DT) => build_tree(
907  
908 # Number.method()
909 (
910 map { [$_, []] } dtypes(
911 NUMBER_DT, qw(
912 pi
913 tau
914 ln2
915 EulerGamma
916 CatalanG
917 e i
918 phi
919 nan
920 inf
921 ninf
922 )
923 )
924 ),
925  
926 # Number.method(STRING|NUMBER)
927 (
928 map { [$_, [table(STRING, NUMBER)]] } dtypes(
929 NUMBER_DT, qw(
930 new
931 call
932 )
933 )
934 ),
935  
936 # Number.method(NUMBER, NUMBER)
937 (
938 map { [$_, [table(NUMBER), table(NUMBER)]] } dtypes(
939 NUMBER_DT, qw(
940 new
941 call
942 )
943 )
944 ),
945  
946 # Number.method(STRING, NUMBER)
947 (
948 map { [$_, [table(STRING), table(NUMBER)]] } dtypes(
949 NUMBER_DT, qw(
950 new
951 call
952 )
953 )
954 ),
955 ),
956  
957 (STRING_DT) => build_tree(
958  
959 # String.method(STRING|NUMBER)
960 (
961 map { [$_, [table(STRING, NUMBER)]] } dtypes(
962 STRING_DT, qw(
963 new
964 call
965 )
966 )
967 ),
968 ),
969  
970 (REGEX_DT) => build_tree(
971  
972 # Regex.method(STRING)
973 (
974 map { [$_, [table(STRING)]] } dtypes(
975 REGEX_DT, qw(
976 new
977 call
978 )
979 )
980 ),
981  
982 # Regex.method(STRING, STRING)
983 (
984 map { [$_, [table(STRING), table(STRING)]] } dtypes(
985 REGEX_DT, qw(
986 new
987 call
988 )
989 )
990 ),
991 ),
992  
993 (FILE_DT) => build_tree(
994  
995 # File.method(STRING)
996 (
997 map { [$_, [table(STRING)]] } dtypes(
998 FILE_DT, qw(
999 new
1000 call
1001 )
1002 )
1003 ),
1004 ),
1005  
1006 (PIPE_DT) => build_tree(
1007  
1008 # Pipe.method(STRING)
1009 (
1010 map { [$_, [table(STRING)]] } dtypes(
1011 PIPE_DT, qw(
1012 new
1013 call
1014 )
1015 )
1016 ),
1017 ),
1018  
1019 (BACKTICK_DT) => build_tree(
1020  
1021 # Backtick.method(STRING)
1022 (
1023 map { [$_, [table(STRING)]] } dtypes(
1024 BACKTICK_DT, qw(
1025 new
1026 call
1027 )
1028 )
1029 ),
1030 ),
1031  
1032 (PERL_DT) => build_tree(
1033  
1034 # Perl.method(STRING)
1035 (
1036 map { [$_, [table(STRING)]] } dtypes(
1037 PERL_DT, qw(
1038 new
1039 call
1040 )
1041 )
1042 ),
1043 ),
1044  
1045 (DIR_DT) => build_tree(
1046  
1047 # Dir.method(STRING)
1048 (
1049 map { [$_, [table(STRING)]] } dtypes(
1050 DIR_DT, qw(
1051 new
1052 call
1053 )
1054 )
1055 ),
1056 ),
1057  
1058 (GAUSS_DT) => build_tree(
1059  
1060 # Gauss.method(NUMBER)
1061 (
1062 map { [$_, [table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION)]] } dtypes(
1063 GAUSS_DT, qw(
1064 new call
1065 )
1066 )
1067 ),
1068  
1069 # Gauss.method(NUMBER, NUMBER)
1070 (
1071 map { [$_, [table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION), table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION)]] } dtypes(
1072 GAUSS_DT, qw(
1073 new call
1074 )
1075 )
1076 ),
1077 ),
1078  
1079 (MOD_DT) => build_tree(
1080  
1081 # Mod.method(NUMBER, NUMBER)
1082 (
1083 map { [$_, [table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION), table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION)]] } dtypes(
1084 MOD_DT, qw(
1085 new call
1086 )
1087 )
1088 ),
1089 ),
1090  
1091 (FRACTION_DT) => build_tree(
1092  
1093 # Fraction.method(NUMBER)
1094 (
1095 map { [$_, [table(NUMBER)]] } dtypes(
1096 FRACTION_DT, qw(
1097 new call
1098 )
1099 )
1100 ),
1101  
1102 # Fraction.method(NUMBER, NUMBER)
1103 (
1104 map { [$_, [table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION), table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION)]] } dtypes(
1105 FRACTION_DT, qw(
1106 new call
1107 )
1108 )
1109 ),
1110 ),
1111  
1112 (QUADRATIC_DT) => build_tree(
1113  
1114 # Quadratic.method(NUMBER, NUMBER, NUMBER)
1115 (
1116 map {
1117 [$_, [table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION), table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION), table(NUMBER)]]
1118 } dtypes(
1119 QUADRATIC_DT, qw(
1120 new call
1121 )
1122 )
1123 ),
1124  
1125 # Quadratic.method(NUMBER, NUMBER, NUMBER, NUMBER)
1126 (
1127 map {
1128 [$_,
1129 [table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION), table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION),
1130 table(NUMBER), table(NUMBER),
1131 ]
1132 ]
1133 } dtypes(
1134 QUADRATIC_DT, qw(
1135 new call
1136 )
1137 )
1138 ),
1139 ),
1140  
1141 (QUATERNION_DT) => build_tree(
1142  
1143 # Quaternion.method(NUMBER, NUMBER, NUMBER, NUMBER)
1144 (
1145 map {
1146 [$_,
1147 [table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION),
1148 table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION),
1149 table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION),
1150 table(NUMBER, MOD, GAUSS, QUADRATIC, QUATERNION, FRACTION)
1151 ]
1152 ]
1153 } dtypes(
1154 QUATERNION_DT, qw(
1155 new call
1156 )
1157 )
1158 ),
1159 ),
1160  
1161 (RANGENUM_DT) => build_tree(
1162  
1163 # RangeNum.method(NUMBER, NUMBER)
1164 (
1165 map { [$_, [table(NUMBER), table(NUMBER)]] } dtypes(
1166 RANGENUM_DT, qw(
1167 new call
1168 )
1169 )
1170 ),
1171  
1172 # RangeNum.method(NUMBER, NUMBER, NUMBER)
1173 (
1174 map { [$_, [table(NUMBER), table(NUMBER), table(NUMBER)]] } dtypes(
1175 RANGENUM_DT, qw(
1176 new call
1177 )
1178 )
1179 ),
1180 ),
1181  
1182 (RANGESTR_DT) => build_tree(
1183  
1184 # RangeStr.method(STRING, STRING)
1185 (
1186 map { [$_, [table(STRING), table(STRING)]] } dtypes(
1187 RANGESTR_DT, qw(
1188 call
1189 )
1190 )
1191 ),
1192  
1193 # RangeStr.method(NUMBER, NUMBER)
1194 (
1195 map { [$_, [table(NUMBER), table(NUMBER)]] } dtypes(
1196 RANGESTR_DT, qw(
1197 new
1198 )
1199 )
1200 ),
1201  
1202 # RangeStr.method(STRING, STRING, NUMBER)
1203 (
1204 map { [$_, [table(STRING), table(STRING), table(NUMBER)]] } dtypes(
1205 RANGESTR_DT, qw(
1206 call
1207 )
1208 )
1209 ),
1210  
1211 # RangeStr.method(NUMBER, NUMBER, NUMBER)
1212 (
1213 map { [$_, [table(NUMBER), table(NUMBER), table(NUMBER)]] } dtypes(
1214 RANGESTR_DT, qw(
1215 new
1216 )
1217 )
1218 ),
1219 ),
1220  
1221 (COMPLEX_DT) => build_tree(
1222  
1223 # Complex.method()
1224 (
1225 map { [$_, []] } dtypes(
1226 COMPLEX_DT, qw(
1227 i
1228 e
1229 pi
1230 phi
1231 new
1232 call
1233 )
1234 )
1235 ),
1236  
1237 # Complex.method(STRING|NUMBER)
1238 (
1239 map { [$_, [table(STRING, NUMBER)]] } dtypes(
1240 COMPLEX_DT, qw(
1241 new call
1242 )
1243 )
1244 ),
1245  
1246 # Complex.method(NUMBER|STRING, NUMBER|STRING)
1247 (
1248 map { [$_, [table(STRING, NUMBER), table(STRING, NUMBER)]] } dtypes(
1249 COMPLEX_DT, qw(
1250 new call
1251 )
1252 )
1253 ),
1254 ),
1255 );
1256  
1257 my %addr;
1258  
1259 sub new {
1260 my (undef, %opts) = @_;
1261 undef(%addr); # reset the %addr hash
1262 bless \%opts, __PACKAGE__;
1263 }
1264  
1265 sub optimize_expr {
1266 my ($self, $expr) = @_;
1267  
1268 if (ref($expr) ne 'HASH') {
1269 return $expr; # already an object
1270 }
1271  
1272 my $obj = $expr->{self};
1273  
1274 # Self obj
1275 my $ref = ref($obj);
1276 if ($ref eq 'HASH') {
1277 $obj = $self->optimize($obj);
1278 }
1279 elsif ($ref eq 'Sidef::Variable::Variable') {
1280 if ($obj->{type} eq 'var') {
1281 ## ok
1282 }
1283 elsif ($obj->{type} eq 'func' or $obj->{type} eq 'method') {
1284 if ($addr{refaddr($obj)}++) {
1285 ## ok
1286 }
1287 else {
1288 $obj->{value} = $self->optimize_expr({self => $obj->{value}});
1289 }
1290 }
1291 }
1292 elsif (($ref eq 'Sidef::Variable::Static' or $ref eq 'Sidef::Variable::Const' or $ref eq 'Sidef::Variable::Define')
1293 and exists($obj->{value})) {
1294 if ($addr{refaddr($obj)}++) {
1295 ## ok
1296 }
1297 else {
1298 $obj->{value} = {$self->optimize($obj->{value})};
1299 }
1300 }
1301 elsif ($ref eq 'Sidef::Variable::Init') {
1302 if ($addr{refaddr($obj)}++) {
1303 ## ok
1304 }
1305 else {
1306 if (exists $obj->{args}) {
1307 $obj->{args} = {$self->optimize($obj->{args})};
1308 }
1309 }
1310 }
1311 elsif ( $ref eq 'Sidef::Variable::ClassInit'
1312 or $ref eq 'Sidef::Types::Block::Do'
1313 or $ref eq 'Sidef::Types::Block::Loop'
1314 or $ref eq 'Sidef::Types::Block::Given'
1315 or $ref eq 'Sidef::Types::Block::Gather'
1316 or $ref eq 'Sidef::Types::Block::When'
1317 or $ref eq 'Sidef::Types::Block::Case'
1318 or $ref eq 'Sidef::Types::Block::Default') {
1319 if ($addr{refaddr($obj)}++) {
1320 ## ok
1321 }
1322 else {
1323 $obj->{block}{code} = {$self->optimize($obj->{block}{code})};
1324 }
1325 }
1326 elsif ($ref eq 'Sidef::Types::Block::Try') {
1327 if ($addr{refaddr($obj)}++) {
1328 ## ok
1329 }
1330 else {
1331 $obj->{try}{code} = {$self->optimize($obj->{try}{code})};
1332 $obj->{catch}{code} = {$self->optimize($obj->{catch}{code})} if defined($obj->{catch});
1333 }
1334 }
1335 elsif ($ref eq 'Sidef::Types::Block::BlockInit') {
1336 if ($addr{refaddr($obj)}++) {
1337 ## ok
1338 }
1339 else {
1340 $obj->{code} = {$self->optimize($obj->{code})};
1341 }
1342 }
1343 elsif ($ref eq 'Sidef::Types::Array::HCArray') {
1344  
1345 #~ my $has_expr = 0;
1346  
1347 foreach my $i (0 .. $#{$obj}) {
1348 if (ref($obj->[$i]) eq 'HASH') {
1349 $obj->[$i] = $self->optimize_expr($obj->[$i]);
1350  
1351 #~ $has_expr ||= ref($obj->[$i]) eq 'HASH';
1352 }
1353 }
1354  
1355 # Has no expressions, so let's convert it into an Array
1356 #~ if (not $has_expr) {
1357 #~ #$obj = Sidef::Types::Array::Array->new(@{$obj});
1358 #~ bless $obj, 'Sidef::Types::Array::Array';
1359 #~ }
1360 }
1361 elsif ($ref eq 'Sidef::Types::Block::If') {
1362 foreach my $i (0 .. $#{$obj->{if}}) {
1363 $obj->{if}[$i]{block}{code} = {$self->optimize($obj->{if}[$i]{block}{code})};
1364 $obj->{if}[$i]{expr} = {$self->optimize($obj->{if}[$i]{expr})};
1365 }
1366 if (exists $obj->{else}) {
1367 $obj->{else}{block}{code} = {$self->optimize($obj->{else}{block}{code})};
1368 }
1369 }
1370 elsif ($ref eq 'Sidef::Types::Block::With') {
1371 foreach my $i (0 .. $#{$obj->{with}}) {
1372 $obj->{with}[$i]{block}{code} = {$self->optimize($obj->{with}[$i]{block}{code})};
1373 $obj->{with}[$i]{expr} = {$self->optimize($obj->{with}[$i]{expr})};
1374 }
1375 if (exists $obj->{else}) {
1376 $obj->{else}{block}{code} = {$self->optimize($obj->{else}{block}{code})};
1377 }
1378 }
1379 elsif ($ref eq 'Sidef::Types::Block::ForIn') {
1380 foreach my $loop (@{$obj->{loops}}) {
1381 $loop->{expr} = {$self->optimize($loop->{expr})};
1382 }
1383  
1384 $obj->{block}{code} = {$self->optimize($obj->{block}{code})};
1385 }
1386 elsif ( $ref eq 'Sidef::Types::Block::While'
1387 or $ref eq 'Sidef::Types::Block::ForEach') {
1388 $obj->{expr} = {$self->optimize($obj->{expr})};
1389 $obj->{block}{code} = {$self->optimize($obj->{block}{code})};
1390 }
1391 elsif ($ref eq 'Sidef::Types::Block::CFor') {
1392 foreach my $i (0 .. $#{$obj->{expr}}) {
1393 $obj->{expr}[$i] = {$self->optimize($obj->{expr}[$i])};
1394 }
1395 $obj->{block}{code} = {$self->optimize($obj->{block}{code})};
1396 }
1397 elsif ($ref eq 'Sidef::Variable::NamedParam') {
1398 $obj->{value} = [map { {main => [$self->optimize_expr({self => $_})]} } @{$obj->{value}}];
1399 }
1400 elsif ($ref eq 'Sidef::Meta::PrefixMethod') {
1401 $obj->{expr} = {$self->optimize($obj->{expr})};
1402 }
1403 elsif ($ref eq 'Sidef::Types::Block::Take') {
1404 $obj->{expr} = {$self->optimize($obj->{expr})};
1405 }
1406 elsif ($ref eq 'Sidef::Meta::Assert') {
1407 $obj->{arg} = {$self->optimize($obj->{arg})};
1408 }
1409 elsif ($ref eq 'Sidef::Meta::Module') {
1410 $obj->{block}{code} = {$self->optimize($obj->{block}{code})};
1411 }
1412 elsif ($ref eq 'Sidef::Meta::Included') {
1413 foreach my $info (@{$obj->{included}}) {
1414 $info->{ast} = {$self->optimize($info->{ast})};
1415 }
1416 }
1417 elsif ($ref eq 'Sidef::Types::Bool::Ternary') {
1418 $obj->{cond} = {$self->optimize($obj->{cond})};
1419 $obj->{true} = {$self->optimize($obj->{true})};
1420 $obj->{false} = {$self->optimize($obj->{false})};
1421 }
1422  
1423 if (not exists($expr->{ind}) and not exists($expr->{call})) {
1424 return (ref($obj) eq 'HASH' ? {self => $obj} : $obj);
1425 }
1426  
1427 $obj = {
1428 self => $obj,
1429 (exists($expr->{ind}) ? (ind => []) : ()),
1430 (exists($expr->{call}) ? (call => []) : ()),
1431 };
1432  
1433 # Array and hash indices
1434 if (exists $expr->{ind}) {
1435 foreach my $i (0 .. $#{$expr->{ind}}) {
1436 my $ind = $expr->{ind}[$i];
1437 if (exists $ind->{array}) {
1438 $obj->{ind}[$i]{array} = [map { ref($_) eq 'HASH' ? $self->optimize_expr($_) : $_ } @{$ind->{array}}];
1439 }
1440 else {
1441 $obj->{ind}[$i]{hash} = [map { ref($_) eq 'HASH' ? $self->optimize_expr($_) : $_ } @{$ind->{hash}}];
1442 }
1443 }
1444 }
1445  
1446 # Method call on the self obj (+optional arguments)
1447 if (exists $expr->{call}) {
1448  
1449 my $count = 0;
1450 my $ref_obj = ref($obj->{self});
1451  
1452 foreach my $i (0 .. $#{$expr->{call}}) {
1453  
1454 my $call = $expr->{call}[$i];
1455  
1456 # Method call
1457 my $method = $call->{method};
1458  
1459 if (defined $method) {
1460 if (ref($method) eq 'HASH') {
1461 $method = $self->optimize_expr($method) // {self => {}};
1462  
1463 # Optimize `obj.("method")` to `obj.method`
1464 if (ref($method) eq 'Sidef::Types::String::String') {
1465 $method = $$method;
1466 }
1467 }
1468  
1469 if (ref($obj) ne 'HASH') {
1470 $obj = {self => $obj};
1471 }
1472  
1473 $obj->{call}[$i] = {method => $method};
1474 }
1475 elsif (exists $call->{keyword}) {
1476 $obj->{call}[$i] = {keyword => $call->{keyword}};
1477 }
1478  
1479 # Method arguments
1480 if (exists $call->{arg}) {
1481  
1482 state $unary_methods = {
1483 '-' => 'neg',
1484 '√' => 'sqrt',
1485 '~' => 'not',
1486 '^' => 'range',
1487 '+' => undef,
1488 };
1489  
1490 my $unary_optimized = 0;
1491  
1492 if ( defined($ref_obj)
1493 and $ref_obj eq 'Sidef::Operator::Unary'
1494 and exists($unary_methods->{$method})
1495 and scalar(@{$call->{arg}}) == 1) {
1496 my $arg = $call->{arg}[0];
1497 my $opt_obj = $self->optimize_expr(
1498 {
1499 self => $arg,
1500 (defined($unary_methods->{$method}) ? (call => [{method => $unary_methods->{$method}}]) : ())
1501 }
1502 );
1503 if (($method eq '+') ? (ref($opt_obj) ne 'HASH') : 1) {
1504 $obj = $opt_obj;
1505 $unary_optimized = 1;
1506 }
1507 }
1508  
1509 if (!$unary_optimized) {
1510 foreach my $j (0 .. $#{$call->{arg}}) {
1511 my $arg = $call->{arg}[$j];
1512 push @{$obj->{call}[$i]{arg}},
1513 ref($arg) eq 'HASH' ? {$self->optimize($arg)}
1514 : ref($arg) ? $self->optimize_expr({self => $arg})
1515 : $arg;
1516 }
1517 }
1518 }
1519  
1520 # Block
1521 if (exists $call->{block}) {
1522 foreach my $j (0 .. $#{$call->{block}}) {
1523 my $arg = $call->{block}[$j];
1524 push @{$obj->{call}[$i]{block}},
1525 ref $arg eq 'HASH' ? {$self->optimize($arg)}
1526 : ref($arg) ? $self->optimize_expr({self => $arg})
1527 : $arg;
1528 }
1529 }
1530  
1531 #
1532 ## Constant folding support
1533 #
1534 my $optimized = 0;
1535 if ( defined($ref_obj)
1536 and exists($rules{$ref_obj})
1537 and !ref($method)) {
1538  
1539 my $code = ($cache{join(' ', $ref_obj, $method)} //= UNIVERSAL::can($ref_obj, $method));
1540  
1541 if (defined $code) {
1542 my $obj_call = $obj->{call}[$i];
1543  
1544 my $ref = $rules{$ref_obj};
1545 if (exists($ref->{$code}) and (exists($obj_call->{arg}) ? ($#{$obj_call->{arg}} == 0) : 1)) {
1546 $ref = $ref->{$code};
1547  
1548 my @args = (
1549 exists($obj_call->{arg})
1550 ? ref($obj_call->{arg}[0]) eq 'HASH'
1551 ? @{(values(%{$obj_call->{arg}[0]}))[0]}
1552 : $obj_call->{arg}[0]
1553 : ()
1554 );
1555  
1556 if (exists $ref->{$#args}) {
1557 $ref = $ref->{$#args};
1558 my $ok = 1;
1559 foreach my $arg (@args) {
1560 if (exists $ref->{ref($arg)}) {
1561 $ref = $ref->{ref($arg)};
1562 }
1563 else {
1564 $ok = 0;
1565 last;
1566 }
1567 }
1568  
1569 if ($ok) {
1570 if (exists $dt_table{$ref_obj}) {
1571 $obj->{self} = $dt_table{$ref_obj};
1572 }
1573 $obj->{self} = $obj->{self}->$code(@args);
1574 $ref_obj = ref($obj->{self});
1575 $optimized = 1;
1576 }
1577 }
1578 }
1579 }
1580 }
1581  
1582 if ($optimized) {
1583 ++$count;
1584 }
1585 else {
1586 undef $ref_obj;
1587 }
1588 }
1589  
1590 if ($count > 0) {
1591 if ($count == @{$obj->{call}}) {
1592 if (not exists $expr->{ind}) {
1593 return $obj->{self};
1594 }
1595 else {
1596 delete $obj->{call};
1597 }
1598 }
1599 else {
1600 splice(@{$obj->{call}}, 0, $count);
1601 }
1602 }
1603 }
1604  
1605 # Concept for converting small RangeNumber objects into arrays
1606 # (disabled for now, as it breaks some code)
1607 if (0 and ref($obj->{self}) eq RANGENUM) {
1608 state $range_len_limit = Sidef::Types::Number::Number::_set_int(100);
1609 if ($obj->{self}->len->le($range_len_limit)) {
1610 $obj->{self} = $obj->{self}->to_a;
1611 }
1612 }
1613  
1614 return $obj;
1615 }
1616  
1617 sub optimize {
1618 my ($self, $struct) = @_;
1619  
1620 my %opt_struct;
1621 my @classes = keys %{$struct};
1622  
1623 foreach my $class (@classes) {
1624 foreach my $i (0 .. $#{$struct->{$class}}) {
1625 push @{$opt_struct{$class}}, scalar $self->optimize_expr($struct->{$class}[$i]);
1626 }
1627 }
1628  
1629 wantarray ? %opt_struct : ($#{$opt_struct{$classes[-1]}} > 0) ? \%opt_struct : $opt_struct{$classes[-1]}[-1];
1630 }
1631  
1632 1;