Parsing
Parsing is the analysis of input according to syntactic or format rules to identify its structure and produce a structured representation or value.
Functional Programming in Scala, Second Edition
Parsing is the process of analyzing an input sequence according to a grammar or other syntactic rules to recognize its structure and produce a result.
- How it is used
- Builds structured recognizers from primitive parsers while using parsing to practice algebraic API design.
- How deep it goes
- Develops laws, combinators, JSON construction, error behavior, and stateful implementation details rather than stopping at grammar notation.
- Examples
- Uses repeated letters, magic-word alternatives, JSON documents, digit-counted `a` sequences, and CSV date-temperature rows.
- What you can do after
- Build it from scratch: design a parser algebra, compose a JSON parser, and implement parsers with errors, consumption, and backtracking.
Read how Functional Programming in Scala, Second Edition explains parsing →
Logs and Telemetry
Parsing is the transformation of textual or encoded content into a structured representation according to its syntax.
- How it is used
- Uses extracted log values to enrich payloads, route events, protect sensitive data, and support remediation.
- How deep it goes
- Explains operational purposes and Fluent Bit configuration, but defers detailed filter capabilities and parser-specific attributes.
- Examples
- Uses regex parser definitions, Java-style error logs, and Fluent Bit input-filter-output configurations.
- What you can do after
- Apply it via Fluent Bit by defining parsers, attaching them through a parser filter, and routing the resulting events.
Write Powerful Rust Macros
Parsing is the process of analyzing an input sequence according to a grammar and constructing its syntactic structure.
- How it is used
- Turns procedural-macro and DSL token input into custom structs before code generation or infrastructure work.
- How deep it goes
- Works through hierarchical Parse implementations, lookahead, custom keywords, diagnostics, and validation while deferring cloud-resource creation.
- Examples
- Uses Hello-derived macro input, a bucket-and-lambda infrastructure DSL, parsed structs, and compiler error outputs.
- What you can do after
- Build it from scratch by implementing Parse for nested DSL structs with token checks, errors, and post-parse validation.
Build Financial Software with Generative AI (From Scratch)
Parsing is the process of analyzing structured input and converting it into accessible data elements according to its format.
- How it is used
- Uses parsing to turn ACH payment records into fields for file processing and database storage.
- How deep it goes
- Builds record-specific parsers and tests incrementally, then proposes validation and error handling for malformed files.
- Examples
- Uses ACH file headers, entry details, and international addenda records, including a sample file and expected-result tests.
- What you can do after
- Builds record parsers from scratch and tests their extracted fields against expected results.
Read how Build Financial Software with Generative AI (From Scratch) explains parsing →
The Quick Python Book, Fourth Edition
- How it is used
- Extracts usable fields from text records and delimited data files.
- How deep it goes
- Works through splitting, named regex groups, and CSV readers, including optional fields and quoted delimiters.
- Examples
- Uses name-and-phone records and pipe- or comma-delimited temperature observations.
- What you can do after
- Apply it via Python’s split, re, and csv tools to extract fields from records.
Read how The Quick Python Book, Fourth Edition explains parsing →
Build AI-Enhanced Web Apps
Document parsing is the extraction and structural interpretation of content from files such as PDFs or DOCX documents.
- How it is used
- Prepares document content for summarization and retrieval-based conversations.
- How deep it goes
- Explains extraction difficulties and cleanup remedies, with a normalization example and security considerations, but does not detail parser internals.
- Examples
- Uses PDF and DOCX uploads and a JavaScript document-normalization function to illustrate ingestion and cleanup.
- What you can do after
- Evaluate extraction limitations and apply cleanup steps before summarizing document content.
Refactoring to Rust
parse is a Rust string operation that converts textual data into a value of an inferred or specified target type.
- How it is used
- Uses string parsing to convert RPN calculator operands into integers before evaluation.
- How deep it goes
- Explains generic target selection and parse-error handling, but stops short of parsing internals.
- Examples
- Demonstrates parsing operands such as `3` and `4`, rejecting `hello`, and feeding valid values into an RPN stack.
- What you can do after
- Build it from scratch by parsing calculator operands and propagating invalid-number errors.
Type-Driven Development with Idris
The process of converting textual input into a structured representation according to a grammar or format.
- How it is used
- Separates recognition of datastore commands and schema-directed entries from their processing.
- How deep it goes
- Works through typed command and schema parsers, including prefix consumption, failure propagation, and complete-input checks.
- Examples
- Uses add, get, and quit commands, a mixed integer-and-string entry, and user-supplied schema descriptions.
- What you can do after
- Build parsers from scratch in Idris that produce typed commands or schema-directed values and report invalid input.
Read how Type-Driven Development with Idris explains parsing →
Vibe Engineering
String parsing is the process of interpreting character sequences and extracting their structured components.
- How it is used
- Prepares structured fields from strings for data analysis and feature engineering.
- How deep it goes
- Specifies extracted columns and diagnostic output, but does not detail the parsing implementation in the supplied excerpt.
- Examples
- Extracts ingredient names, dosage values, and units from medicine compositions, including a sample with a missed compound dosage.
- What you can do after
- Evaluate parsing results using extraction counts and sample rows, while checking for missing or incorrect values.
High Performance Unity Game Development
Analyzing encoded or structured input and converting it into program-readable values.
- How it is used
- Converts editable game balance into binary data for a build to load.
- How deep it goes
- Walks through byte-array output and binary field loading, while treating validation and versioning as adjacent concerns.
- Examples
- Uses a Unity Editor balance parser, a Resources binary file, and a BinaryReader-based balance loader.
- What you can do after
- Build it from scratch as a tool-time balance conversion and runtime loading workflow.
Read how High Performance Unity Game Development explains parsing →
Designing AI Systems
Parsing is the analysis of structured or semi-structured input to identify and extract its meaningful components.
- How it is used
- Routes organizational documents through format-specific extraction so their content can enter a searchable knowledge pipeline.
- How deep it goes
- Defines a parser interface, structured output, and format routing, while describing rather than implementing format-specific extraction internals.
- Examples
- Contrasts PDF layout issues, Markdown structure, HTML boilerplate removal, and plain text represented as one section.
- What you can do after
- Build format support by implementing and registering a parser that returns the shared extracted-document structure.
Julia as a Second Language
Parsing is the process of interpreting a textual representation to produce a value of a specified type.
- How it is used
- Turns file and keyboard input into typed values for calculations and data loading.
- How deep it goes
- Demonstrates type selection, Boolean and numeric parsing, numeric bases, and a simple CSV-loading loop.
- Examples
- Uses pizza prices, Boolean strings, and the numeral "101" in different bases.
- What you can do after
- Apply it via Julia’s parse function to interpret text as numbers or Boolean values.
Go by Example
Parse is a book-specific function that parses a URL into a URL value and reports an error when the URL lacks a scheme.
- How it is used
- Converts URL strings into fields for a small package client and its tests.
- How deep it goes
- Works through a two-step strings.Cut implementation and error path, without handling missing paths separately.
- Examples
- Uses https://github.com/inancgumus and https://github.com to parse fields and test URL reassembly.
- What you can do after
- Build it from scratch with strings.Cut, returning a URL pointer on success and an error for a missing scheme.
Natural Language Processing in Action, Second Edition
A parser is a software component that analyzes text to identify its structural parts and the relationships among them.
- How it is used
- Helps natural-language software identify sentence structure and relationships for downstream NLP tasks.
- How deep it goes
- Defines structural analysis and its purpose, but stops short of describing parsing algorithms or implementation details.
- Examples
- Contrasts natural-language sentences with programming-language instructions and executable machine code.
- What you can do after
- Evaluate/understand how parsers expose sentence structure without treating them as complete natural-language compilers.
Read how Natural Language Processing in Action, Second Edition explains parsing →
Kotlin in Action, 2E
- How it is used
- Uses parsing as the middle stage of JSON deserialization, between lexical analysis and reflective object construction.
- How deep it goes
- Explains token categories, semantic elements, and callback behavior while leaving final object creation to deserialization.
- Examples
- Uses nested book-and-author JSON and a JsonObject callback interface to illustrate parsed values, objects, and arrays.
- What you can do after
- Understand how JSON text progresses from characters to tokens, semantic structures, and final Kotlin objects.
API Design Patterns
Parsing is the process of analyzing a serialized or textual representation according to syntax rules to produce a structured or executable form.
- How it is used
- Uses parsing to interpret string-based API filters before evaluating matching resources.
- How deep it goes
- Contrasts server parsing with client-constructed schemas and shows equivalent transformations, but stops short of parser implementation.
- Examples
- Demonstrates ChatRoom SQL and MongoDB filters covering equality, comparison, conjunction, membership, and disjunction.
- What you can do after
- Evaluate equivalent string and structured filter designs against usability and future flexibility.
Learn PowerShell in a Month of Lunches: Fourth Edition, Covers Windows, Linux, and macOS
Text parsing is the process of analyzing textual content to identify, extract, or transform structured information.
- How it is used
- Supports administrative work by extracting actionable information from command output and textual files.
- How deep it goes
- Contrasts text parsing with PowerShell objects and introduces regular expressions without covering regex comprehensively.
- Examples
- Uses process listings, process identifiers, command output, and log files as parsing examples.
- What you can do after
- Apply it via regular expressions and shell text tools to extract information from command output or log files.
Also covered in
- Learn Haskell by Example
- 100 SQL Server Mistakes and How to Avoid Them
- Learn C++ by Example
- How Large Language Models Work
- Rust in Action: Systems programming concepts and techniques
- Machine Learning for Tabular Data: XGBoost, Deep Learning, and AI
- WordPress Power Toolkit: Harness AI to build next-level websites
- Go in Action, Second Edition
- AI-Powered Search
- Data Analysis with LLMs
- Building User-Friendly DSLs
- Practical Automation with PowerShell: Effective scripting from the console to the cloud
What to know first
- stringA string is a programming-language value representing textual data as an ordered sequence of characters or encoded units.
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
- language modelA language model is a computational model that represents patterns in linguistic sequences to assign probabilities, predict, generate, or evaluate language.
- PythonPython is a high-level, general-purpose, dynamically typed programming language with readable syntax and support for multiple programming paradigms.
Related concepts
- custom keywordimplemented by · A custom keyword is a syntax token declared through syn's custom_keyword macro that implements parsing and lookahead support for a DSL-specific keyword.
- projectional editingcontrasts with · A language-editing technique that manipulates and presents a structured language model directly rather than parsing text into that model.
- http request parsingincludes · HTTP request parsing is the process of interpreting an HTTP request representation and extracting its method, path, version, headers, and body.
Questions about parsing
What is parsing?
Parsing is the analysis of input according to syntactic or format rules to identify its structure and produce a structured representation or value.
Which Manning books explain parsing?
Functional Programming in Scala, Second Edition, Logs and Telemetry, Write Powerful Rust Macros, Build Financial Software with Generative AI (From Scratch), The Quick Python Book, Fourth Edition, Build AI-Enhanced Web Apps, Refactoring to Rust, Type-Driven Development with Idris and 9 more.
What should I know before learning parsing?
Manning books that teach parsing usually introduce string, JSON, language model and Python first.
What is the difference between parsing and projectional editing?
Parsing is the analysis of input according to syntactic or format rules to identify its structure and produce a structured representation or value. A language-editing technique that manipulates and presents a structured language model directly rather than parsing text into that model.
What kinds of parsing are there?
Kinds of parsing include address parsing, HTML parsing, http request parsing and JSON parsing.
What is parsing also called?
Parsing is also called parse.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.
















