perl 5.0 alpha 6
[perl.git] / Quick
1 #!/usr/local/bin/perl5
2 #
3 # This document is in the public domain.
4 #
5 # The purpose is to document by example some of the new Perl5 features.
6 # It also functions as a mini test suite; you can extracted the
7 # expected output using:
8 #     perl -ne 'm/.*prints ``(.*)..$/ && print $1,"\n";'
9 # There are a couple of places that print out internal address so it's
10 # not perfect yet, those should be fixed.
11 #
12 # Thanks to the following for their input:
13 #     Johan.Vromans@NL.net
14 #     Daniel Faken <absinthe@viva.chem.washington.edu>
15 #     Tom Christiansen <tchrist@wraeththu.cs.colorado.edu>
16 #     Dean Roehrich <roehrich@ferrari.cray.com>
17 #     Larry Wall <lwall@netlabs.com>
18 #
19 # TODO when I get perl5a6 to play with
20 #       *foo = \&func;                  # replaces only function (etc)
21 #       AUTOLOAD { ...; }               # called if method not found
22 #       goto &func;                     # goto's a function
23 #       require FOOBAR;                 # loads FOOBAR.pm
24 #       @ISA
25 #
26 #       import()/@EXPORT/etc
27
28 #   my
29         # static scoping
30         sub samp1 { print $z,"\n"; }
31         sub samp2 { my($z) = "world"; &samp1; }
32         $z = "hello"; &samp2;           # prints ``hello''
33
34 #   package;
35         # for catching non-local variable references
36         sub samp3 {
37             my $x = shift;              # local() would work also
38             package;                    # empty package
39             $main::count += $x;         # this is ok.
40             # $y = 1;                   # compile time error
41         }
42
43 #   =>
44         # works like comma (,); use for key/value pairs
45         # sometimes used to disambiguate the final expression in a block
46         # might someday supply warnings if you get out of sync
47         %foo = ( abc => foo );
48         print $foo{abc},"\n";           # prints ``foo''
49
50 #   ::
51         # works like tick (') (use of ' is deprecated in perl5)
52         print $main::foo{abc},"\n";     # prints ``foo''
53
54 #   bless ref;
55         # Bless takes a reference and returns an "object"
56         $oref = bless \$scalar;
57
58 #   ->
59         # dereferences an "object"
60         $x = { def => bar };            # $x is ref to anonymous hash
61         print $x->{def},"\n";           # prints ``bar''
62
63         # method derefs must be bless'ed
64         {
65             package sample;
66             sub samp4 { my($this) = shift; print $this->{def},"\n"; }
67             sub samp5 { print "samp5: @_\n"; }
68             $main::y = bless $main::x;  # $x is ref, $y is "object"
69         }
70         $y->samp4();                    # prints ``bar''
71
72         # indirect object calls
73         samp5 $y arglist;               # prints ``samp5: sample=HASH(0xa85e0) arglist''
74
75         # static method calls (often used for constructors, see below)
76         samp5 sample arglist;           # prints ``samp5: sample arglist''
77
78 #   function calls without &
79         sub samp6 { print "look ma\n"; }
80         samp6;                          # prints ``look ma''
81
82 #   ref
83         # returns "object" type
84         {
85             package OBJ1;
86             $x = bless \$y;             # returns "object" $x in "class" OBJ1
87             print ref $x,"\n";          # prints ``OBJ1''
88         }
89
90         # and non-references return undef.
91         $z = 1;
92         print "non-ref\n" if !defined(ref $z);          # prints ``non-ref''
93
94         # ref's to "builtins" return type
95         print ref \$ascalar,"\n";               # prints ``SCALAR''
96         print ref \@array,"\n";                 # prints ``ARRAY''
97         print ref \%hash,"\n";                  # prints ``HASH''
98         sub func { print shift,"\n"; }
99         print ref \&func,"\n";                  # prints ``CODE''
100         print ref \\$scalar,"\n";               # prints ``REF''
101
102 #   tie
103         # bind a variable to a package with magic functions:
104         #     new, fetch, store, delete, firstkey, nextkey (XXX: others???)
105         # Usage: tie variable, PackageName, ARGLIST
106         {
107             package TIEPACK;
108             sub new { print "NEW: @_\n"; my($class, $x) = @_; bless \$x }
109             sub fetch { print "fetch @_\n"; my($this) = @_; ${$this} }
110             sub store { print "store @_\n"; my($this, $x) = @_; ${$this} = $x }
111             sub DESTROY { print "DESTROY @_\n" }
112         }
113         tie $h, TIEPACK, "black_tie";   # prints ``NEW: TIEPACK black_tie''
114         print $h, "\n";                 # prints ``fetch TIEPACK=SCALAR(0x882a0)''
115                                         # prints ``black_tie''
116         $h = 'bar';                     # prints ``store TIEPACK=SCALAR(0x882a0) bar''
117         untie $h;                       # DESTROY (XXX: broken in perl5a5???)
118
119 #   References and Anonymous data-structures
120         $sref = \$scalar;               # $$sref is scalar
121         $aref = \@array;                # @$aref is array
122         $href = \%hash;                 # %$href is hash table
123         $fref = \&func;                 # &$fref is function
124         $refref = \$fref;               # ref to ref to function
125         &$$refref("call the function"); # prints ``call the function''
126
127         %hash = ( abc => foo );         # hash (just like perl4)
128         print $hash{abc},"\n";          # prints ``foo''
129         $ref = { abc => bar };          # reference to anon hash
130         print $ref->{abc},"\n";         # prints ``bar''
131
132         @ary = ( 0, 1, 2 );             # array (just like perl4)
133         print $ary[1],"\n";             # prints ``1''
134         $ref = [ 3, 4, 5 ];             # reference to anon array
135         print $ref->[1],"\n";           # prints ``4''
136
137 #   Nested data-structures
138         @foo = ( 0, { name => foobar }, 2, 3 );         # $#foo == 3
139         $aref = [ 0, { name => foobar }, 2, 3 ];        # ref to anon array
140         $href = {                                       # ref to hash of arrays
141             John => [ Mary, Pat, Blanch ],
142             Paul => [ Sally, Jill, Jane ],
143             Mark => [ Ann, Bob, Dawn ],
144         };
145         print $href->{Paul}->[0], "\n";                 # prints ``Sally''
146         print $href->{Paul}[0],"\n";                    # shorthand version, prints ``Sally''
147
148 #   Multiple Inheritence (get rich quick :-)
149         {
150             package OBJ2; sub abc { print "abc\n"; }
151             package OBJ3; sub def { print "def\n"; }
152             package OBJ4; @ISA = ("OBJ2", "OBJ3");
153             $x = bless { foo => bar };
154             $x->abc;                                    # prints ``abc''
155             $x->def;                                    # prints ``def''
156         }
157
158 #   Packages, Classes, Objects, Methods, Constructors, Destructors, etc.
159         # XXX: I'll add more explinations/samples about the above here
160         {
161             package OBJ5;
162             sub new { print "NEW: @_\n"; my($x) = "empty"; bless \$x }
163             sub DESTROY { print "DESTROY\n" }
164             sub output { my($this) = shift; print "value = $$this\n"; }
165         }
166         # Constructors are often written as static method calls:
167         $x = new OBJ5;          # prints ``NEW: OBJ5''
168         $x->output;             # prints ``value = empty''
169         # The destructor is responsible for calling any base class destructors.
170         undef $x;