Text

Text sits at the boundary of almost every application: it arrives from users and protocols, moves through parsers and validators, and leaves again as formatted or encoded output. Erbsland Core gives these tasks a shared Unicode model, safe owning values, and focused tools for the places where text must be edited or constructed.

Start with Text in Erbsland Core for a guided tour of the domain. It connects the individual topics and helps you find the page that matches the problem you are solving.

• Text in Erbsland Core
  • Using Strings as Everyday Values
  • Understanding String Attributes
  • Transforming Read-only Strings
  • Editing One Working Value in Place
  • Managing StringEditor Storage
  • Finding Text Positions
  • Slicing and Splitting Strings
  • Accessing Characters and Writing Parsers
  • Converting Text and Scalar Values
  • Comparing Whole and Partial Text
  • Normalizing Unicode Strings
  • Working with Character Sets
  • Building Strings Efficiently
  • Formatting Structured Text
  • Describing Values with Named Format Specifications
  • Maintaining Compact Compatibility Specifications
  • Recognizing Small Text Patterns
  • Converting Strings and Encoded Data
  • Encoding Internationalized Names
• Using Strings
  • One Parameter for Ordinary Read-only Text
  • Values That Are Safe to Store and Return
  • Let Literals Stay Literal
  • Cheap Copies and Long-lived Slices
• String Attributes
  • Empty Text and Well-formed Encodings
  • Two Lengths That Answer Different Questions
  • Hash the Text, Not Its Encoding
  • Know Whether a Position Belongs to This Storage
• Transforming Strings
  • A New Value or One Mutable Working Copy?
  • Where New Character Storage Is Needed
  • Give Each Meaningful Result a Name
  • Replace or Remove Without Losing the Source
  • Changes That Depend on Unicode Text
• Editing Strings in Place
  • Follow One Value Through a Sequence of Edits
  • Narrow the Working Text by Range
  • Remove What the Text Contains
  • Insert and Replace at Known Positions
  • Fit Text into a Character Width
  • Reuse an Editor for Another Pass
  • Normalize as Part of the Edit
• Managing StringEditor Storage
  • Measure Capacity in the Encoding’s Native Unit
  • The First Write to Shared Storage
  • Pay for Detachment at a Deliberate Point
  • Keep Capacity for Reuse or Give It Back
  • Diagnose Retained and Shared Storage
• Finding Text Positions
  • Begin with the Shape of the Match
  • Keep Search Results in Native Coordinates
  • Search for a Class of Characters
  • Follow a Match Across a Character Run
  • Continue Searching Without Starting Over
  • Turn Positions into Useful Slices
• Slicing and Splitting Strings
  • Describe a Boundary in the Right Coordinate System
  • Keep the Beginning, End, or Middle
  • Turn One Value into Shared Fields
• Character Access and Parsing of Strings
  • Start with the Way Your Algorithm Reads Text
  • Understand the Coordinate Systems
  • Keep Parser State in StringCharReader
  • Walk Through Every Decoded Character
  • Read Sequentially Without Parser State
  • Use Indexed Access When a Position Already Matters
  • Why UTF-32 Changes the Cost of Indexed Access
  • Choose the Simplest Access Pattern That Fits
• Converting Text and Scalar Values
  • Choose What Invalid Input Means
  • Read and Write Boolean Values
  • Read Integer Syntax Deliberately
  • Format Integers for Their Destination
  • Read and Write Floating-Point Values
  • The Same Model at Every String Width
• Comparing Whole and Partial Strings
  • Begin with Exact Equality and Ordering
  • Change the Rule, Not the Stored Text
  • Ask a Smaller Question Than Whole-string Equality
  • Validate Untrusted Encodings Before Comparison
• Normalizing Unicode Strings
  • Choose the Equivalence Your Data Needs
  • Normalize a Value or a Mutable Workflow
  • Normalize After Joining Text
• Working with Character Sets
  • Know What One Set Element Represents
  • Validate the Encoding Before the Character Policy
  • Build Expensive Policies Once and Reuse Them
  • Compose Larger Policies from Smaller Sets
  • Ask Whether Text Satisfies a Character Policy
  • Trim a Policy from the Edges
  • Remove Unwanted Characters Throughout the Text
  • Transform the Characters Selected by a Set
• Building Strings
  • When an Editor Is Already the Working Value
  • When Every Fragment Is Known
  • When Fragments Arrive Dynamically
  • When One Builder Must Serve Every String Width
  • Seeing the Trade-offs Side by Side
  • Let a Format Describe Structured Output
• Formatting Text Patterns
  • Create the Pattern Once
  • Let Empty Placeholders Follow the Arguments
  • Reorder and Reuse Values with Positions
  • Pass Values Without Preparing Temporary Strings
• Format Specifications
  • Select the Kind of Value First
  • Write Options for People First
  • Lay Out Text, Numbers, and Booleans Consistently
  • Shape and Escape Text
  • Describe Integer Output in Its Own Vocabulary
  • Choose Floating-Point Notation Explicitly
  • Give Booleans the Words Your Interface Uses
  • Keep Byte Diagnostics Bounded
• Compatibility Format Specifications
  • Read the Compact Grammar from Left to Right
  • Format Integers with Familiar Presentation Letters
  • Limit and Align Text
  • Select Floating-Point Notation
  • Recognize the Compact Escaping Extension
  • Know Where Compatibility Stops
• Recognizing Text Patterns
  • Describe a Small Shape in One Pattern
  • Build the Same Shape from Typed Elements
  • Ask Whether the Boundary Matches
  • Remove a Recognized Boundary
  • Split Where the Pattern Places Its Divider
  • Reuse the Native Match Position
• Converting Strings
  • Start by Identifying the Boundary
  • Move Between String Representations
  • Turn Text into an Encoded Byte Sequence
  • Carry Read-only Text Without Choosing Its Width
  • Keep Conversion at the Boundary
• Encoding Internationalized Names
  • Use Raw Punycode Only Where a Protocol Defines It
  • Apply the Complete IDNA2008 Rules to Domain Names
  • Preserve Useful Failure Information