Michael Lazzaro:
# OK, let's start on the first section (calling them 
# "Sections", not "Chapters").  As our first experiment, we 
# will assume a treelike style (section 1 --> 1.1, 1.2, 1.2.1, 
# etc.); look at http://www.mysql.com/documentation/ for an 
# example of a good, detailed documentation tree.

I'm finding (as I write a perlvar/perldata-like document) that things
are so interconnected that it's hard to come up with a fairly flat
structure.  Therefore, I'm suggesting this structure.  (The first one is
very fleshed-out because I've thought a lot about how to structure it.)

Variables and Subroutines
        Basic Data Types
                Scalars
                Arrays
                Hashes
                Subroutines
        Variable Names
                Sigils
                The Rest
        Subscripting and Calling
                Retrieving Array Elements
                        Individual Elements
                        Slices
                Retrieving Hash Elements
                        Individual Elements
                        Slices
                Calling Subroutines
        Multi-Dimensional Arrays and Hashes
                MD Arrays
                MD Hashes
                References: Simulating Mixed MD
        Contexts
                List Contexts
                        Array Context
                                N-ary Context
                        Hash Context
                Scalar Contexts
                        String Context
                        Numeric Context
                        Boolean Context
                        (whatever else) Context
                        Void Context
                Creating A Context
                        Implicit Ways
                        scalar() and list()
                        context()
                Detecting The Context
        Declaring Variables
                Global
                Lexical
        Declaring Subroutines
                Unprototyped
                Prototyped
        Typed Variables
                Reference Types
                Context Types
                Compact Types
        References
                Taking References
                Dereferencing References
                Testing References
                Why Use References?
                Autovivification
                Soft References
        Properties
                Names, Variables and Values
                        Names
                        Variables
                        Values
                Variable and Value Properties
                        Variable Properties
                        Value Properties
                Tainting
        Reference: Reference Types
        Reference: Context Types
        Reference: Compact Types
        Reference: Variable Properties
                Subroutines
                Scalars, Arrays and Hashes
        Reference: Value Properties

Operators and Built-In Functions
        Expressions and Statements
        Operators
                Unary
                Binary
        Hyper-Operators
        Built-In Functions

Pattern Matching

Modules and Classes
        Modules
        Classes
        Grammars
        Standard Library
                Pragmas
                IO
                ...

--Brent Dax <[EMAIL PROTECTED]>
@roles=map {"Parrot $_"} qw(embedding regexen Configure)

Wire telegraph is a kind of a very, very long cat. You pull his tail in
New York and his head is meowing in Los Angeles. And radio operates
exactly the same way. The only difference is that there is no cat.
    --Albert Einstein (explaining radio)

Reply via email to