Table of contents

Now that the book is done I have the table of contents (PDF). That’s quite a feat considering I re-ordered some chapters only a couple of months ago! The end of this post also contains a text version that’s slightly outdated since it comes from my original sources before the editors adjusted some things. The content is essentially the same though.

Since I’ve just finished the last quality control cycle with O’Reilly, I expect that the print version will ship in three weeks (but that’s merely a historical expectation, not a promise).

  • Preface
    • The Backstory of Perl 6
    • What You Should Already Know
    • Getting Rakudo
    • How to Use This Book
    • How to Get Help
    • Typographical Conventions
    • Code Examples
    • SafariĀ® Books Online
    • How to Contact Us
    • Acknowledgments
  • Introduction
    • Why Perl 6?
    • First steps with the REPL
    • Reading the Documentation
    • Basic Syntax
      • Terms
      • Operators and Expressions
        • Before, after, and around
        • Precedence
      • Statements
      • Blocks
      • Comments
      • Unspace
      • Objects and Classes
    • Variables
      • Simple Output
      • Lexical Scope
      • Pre-Defined Variables
    • Making and Running a Program
    • Summary
  • number Guessing
    • Binding & Assignment
    • A MAIN program
      • Program Arguments
      • Prompting for Values
    • Literal Numbers
      • Formatting Numbers
    • Numeric Operations
    • Conditional Execution
      • Boolean Values
        • Shortcircuit operators
      • Comparing Things
        • Chained comparisons
        • Conditionally running a statement
      • Conditional Branching
    • Putting It All Together
    • Summary
  • Numbers
    • Number Types
    • Integers
      • Type Constraints
      • Smart Matching
    • Rational Numbers
    • Imaginary and Complex Numbers
    • Numbers Small and Large
    • The Numeric Hierarchy
    • Summary
  • Strings
    • Literal Quoting
    • Escaped Strings
      • Adverbs for Quoting
      • String Operators and Methods
      • Looking Inside Strings
      • Normal Form Grapheme
      • String Comparisons
      • Prompting for Input
      • Number to String Conversions
      • String to Number Conversions
    • Interpolated Strings
    • Here Docs
    • Shell Strings
      • Shell Safety
    • Fancier Quoting
    • Summary
  • Blocks
    • Blocks
      • Lexical Scope
      • Control Structures
      • Phasers
      • The while structure
      • Storing Blocks
      • Blocks with Parameters
      • Implicit parameters
      • Explicit signatures
      • Type constraints
    • Simple Subroutines
      • Named Subroutines
    • Whatever Code
      • Subsets
    • Summary
  • Positionals
    • Constructing a List
      • Iterating All the Elements
      • Reading lines of input
    • Ranges
      • The @ Coercer
    • Sequences
      • Infinte Lazy Lists
      • Gathering Values
    • Single Element Access
      • Changing a Single Element
      • Multiple Element Access
    • Arrays
      • Constructing an Array
      • Interpolating Arrays
      • Array Operations
      • Lists of Lists
      • Flattening Lists
      • Interesting Sublists
    • Combining Lists
      • The Zip Operator, Z
      • The Cross Operator, X
      • The Hyperoperators
      • The Reduction Operator
    • Filtering Lists
    • Transforming a List
    • Sorting Lists
    • Sorting on Multiple Comparisons
    • Summary
  • Failures
    • Exceptions
      • Catching Exceptions
      • Backtraces
      • Rethrowing Errors
      • Throwing Your Own Exceptions
      • Defining Your Own Exception Types
    • Failures
    • Warnings
    • The Wisdom of Exceptions
    • Summary
  • Files and Directories
    • File Paths
      • File Test Operators
      • File Metadata
      • File times
      • Linking and Unlinking Files
      • Renaming and Copying Files
    • Manipulating Directories
      • Directory Listings
      • Creating Directories
      • Removing Directories
    • Formatted Output
      • Common formatting tasks
    • The Standard Filehandles
      • Standard Output
      • Standard Error
      • Standard Input
    • Reading Input
      • Reading Lines
      • Reading a File
    • Writing Output
      • Opening a File for Writing
    • Binary Files
      • Moving Around
      • Writing Binary Files
    • Summary
  • Associatives
    • Pairs
      • Adverbs
      • Modifying a Pair
    • Map
      • Checking Keys
      • Creating from a Positional
      • Checking Allowed Values
    • Hashes
      • Accumulating with a Hash
    • Multi-Level Hashes
    • Summary
  • Using Modules
    • Installing Modules
    • Loading Modules
      • Finding the Module
        • The lib pragma
        • The environment
        • The -I switch
      • Lexical Effect
      • Loading a Module at Runtime
      • Interpolating module names
  • Fetching Data from the Web
  • Running Perl 5 in Perl 6
  • Summary
  • Subroutines
    • A Basic Subroutine
      • Extra Arguments
      • Explicit Returns
    • Recursing
      • Iterating Instead of Recursing
    • Storing Subroutines in Libraries
      • Exporting Subroutines
    • Positional Parameters
      • Slurpy parameters
      • Have it both ways
      • Combining slurpies
      • Optional and Default Arguments
      • Parameter Traits
      • Parameter Constraints
    • Same Name, Different Signature
      • Literal Value Parameters
      • Number of Arguments
      • Parameter Types
    • Named Parameters
      • Required Named Parameters
      • Named Parameters For Free
      • Mixed Parameters
    • Return Types
    • Summary
  • Classes
    • Your First Class
    • Defining Methods
      • Private Methods
      • Defining Subroutines
    • Objects
      • Private Attributes
      • Public Attributes
    • Multi Methods
    • Inheriting Types
      • Checking inheritance
      • Stub Methods
    • Controlling Object Creation
      • Building Objects
      • Tweaking Objects
    • Private Classes
    • Summary
  • Roles
    • Adding Behavior to Classes
      • Applying Multiple Roles
    • Methods in Roles
    • De-conflicting Roles
    • Anonymous Roles
    • Summary
  • Junctions
    • Junctions
      • Any
      • All
      • One
      • None
      • Some Junctive Tricks
    • Sets
      • Set Operations
    • Summary
  • Regexes
    • The Match Operator
      • Match Operator Syntax
      • Succesful Matches
      • Defining a Pattern
      • Predefined Patterns
    • Match Nonliteral Characters
      • Match Any Character
        • Escaping characters
        • Matching literal spaces
      • Matching types of characters
        • Unicode properties
        • Combining properties
      • User-Defined Character Classes
        • Character class ranges
        • Negated character classes
    • Match Adverbs
      • Matching Either Case
      • Ignoring Marks
      • Global Matches
    • Things That Use Patterns
      • Substitutions
    • Summary
  • Fancier Regexes
    • Quantifiers
      • Zero or More
      • Greediness
      • Zero or One
      • Minimal and Maximal
    • Controlling Quantifiers
      • Turning Off Backtracking
    • Captures
      • Named Captures
      • A Capture Tree
      • Backreferences
    • Surrounders and Separators
    • Assertions
      • Anchors
      • Conditions
      • Code Assertions
        • Matching an IPv4 address
    • Alternations
      • First Match
      • Longest Token Matching
    • Summary
  • Grammars
    • A Simple Grammar
    • Multiple Rules
    • Debugging Grammars
      • Grammar::Tracer
      • Grammar::Debugger
    • A Simple Action Class
      • Creating an Abstract Syntax Tree
    • Ratcheting
    • Parsing JSON
    • Parsing CSV
      • Adjusting the Grammar
      • Using Roles in Grammars
    • Summary
  • Supplies
    • Supplies
      • Multiple Taps
      • Live Supply
    • Channels
    • Promises
      • Waiting for Promises
      • Waiting for Multiple Promises
      • Managing Your Own Promises
      • Promise Junctions
    • Reactive Programming
      • Reacting in the Background
    • Summary
  • Interprocess
    • Quick and Easy
      • Quoted Commands
      • Safer Commands
      • Writing to a Proc
    • Procs
    • Asynchronous Control
    • Summary
  • Advanced Topics
    • One liners
    • Declarator Block Comments
    • Feed Operators
    • Destructuring Signatures
    • Defining Your Own Operators
    • Perl 5 Patterns
    • Shaped Arrays
    • Typed Containers
    • NativeCall
    • The with Topicalizer
  • Conclusion
  • Glossary
  • Exercise Answers
  • Leave a Reply

    Your email address will not be published. Required fields are marked *