liveBook · Manning

Parsing

Also called parse

Parsing is the analysis of input according to syntactic or format rules to identify its structure and produce a structured representation or value.

How 17 Manning books explain it

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.

Read how Logs and Telemetry explains parsing →

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.

Read how Write Powerful Rust Macros explains parsing →

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.

Read how Build AI-Enhanced Web Apps explains parsing →

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.

Read how Refactoring to Rust explains parsing →

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.

Read how Vibe Engineering explains parsing →

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.

Read how Designing AI Systems explains parsing →

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.

Read how Julia as a Second Language explains parsing →

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.

Read how Go by Example explains parsing →

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.

Read how Kotlin in Action, 2E explains parsing →

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.

Read how API Design Patterns explains parsing →

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.

Read how Learn PowerShell in a Month of Lunches: Fourth Edition, Covers Windows, Linux, and macOS explains parsing →

Also covered in

What to know first

Related concepts

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.