JSON Parser 100% From Scratch in Haskell (only 111 lines)

The video begins with the presenter's intention to create a JSON parser from scratch in Haskell without relying on third-party dependencies, using only the base library. The idea originated from a development stream and aims to demonstrate the simplicity of implementing parsers in Haskell, specifically parser combinators. The presenter emphasizes the benefits of not depending on external libraries for increased maintainability and control over the code.

The presenter proceeds to set up a new Haskell project specifically for the JSON parser, navigating through the file system to create a dedicated folder. They initiate Emacs within the project directory and start GHCi, the interactive Haskell environment. The presenter also discusses the need for a main module and an entry point, hinting at the structure of Haskell projects and the importance of the main function.

The presenter outlines the process of defining an AST for JSON, which includes various JSON value types such as null, boolean, numbers, strings, arrays, and objects. They decide to simplify the parser by only supporting integers and not floats, and discuss the challenges of implementing a map without using third-party dependencies. The presenter also mentions the intention to derive interfaces like 'Show' and 'Eq' for the JSON types.

The presenter delves into the concept of parser combinators, explaining how they can be used to create small, composable parsers that can be combined to parse more complex structures. They introduce the idea of a 'parser' type that takes a string and returns a value along with the remaining input. The presenter also discusses error handling in parsers, considering the use of 'Maybe' for simplicity.

The presenter begins coding by implementing a basic character parser, which takes a single character as input and returns it wrapped in a 'Maybe' type. They demonstrate the use of Haskell's 'holes' feature for guided development and pattern matching to handle different input scenarios. The video illustrates the fundamental steps in creating a parser in Haskell and the importance of managing the remaining input for subsequent parsers.

The presenter discusses the concept of parser composition, introducing the idea of turning a list of parsers into a single parser using the 'sequenceA' function from the 'Applicative' typeclass. They explain the need to prove that the parser is an 'Applicative' functor, which includes implementing 'fmap' and 'pure' functions, and demonstrate the use of 'sequenceA' to combine parsers.

The presenter works on implementing the 'Functor' and 'Applicative' instances for the parser type. They define 'fmap' for the parser, allowing functions to be applied within the parser context. Then, they begin implementing 'Applicative' by defining the 'pure' function, which creates a parser that always returns a given value, ignoring the input.

The presenter advances the JSON parser by implementing 'Alternative' instances, allowing for the creation of parsers that can try multiple options and return the first successful result. They discuss the 'empty' function as a parser that always fails and the '(<|>)' function for combining parsers, which is crucial for implementing boolean values in JSON.

The presenter tackles the parsing of JSON numbers by implementing a custom parser combinator that applies a predicate to a sequence of characters. They introduce the 'spanP' function, which parses characters as long as the predicate holds, and use it to parse sequences of digits, converting them into integers and wrapping them into JSON number values.

The presenter moves on to parsing JSON strings, utilizing applicative functor operations to create a parser that expects a string literal enclosed in double quotes. They discuss the limitations of their implementation, noting that it does not support escape characters for simplicity, and demonstrate how to wrap the parser's output in a JSON string value.

The presenter explains how to parse JSON arrays by creating a recursive parser that expects a sequence of JSON values enclosed in square brackets and separated by commas. They introduce the concept of 'many' to handle multiple elements and discuss the challenges of parsing nested structures within the JSON array.

The presenter tackles the parsing of JSON objects, which involve key-value pairs enclosed in curly braces. They discuss the structure of JSON pairs and the need to parse string literals, colons, and separators. The presenter outlines the steps to combine these elements into a parser for JSON objects.

The presenter tests the JSON parser with a complex real-world JSON data from a schedule page. They encounter issues with parsing due to the lack of support for escaped quotes and work through debugging the parser to handle the real data. The presenter demonstrates the parser's ability to extract specific information from the JSON data.

In the conclusion, the presenter reflects on the process of implementing the JSON parser from scratch in Haskell. They discuss the challenges and learnings from the experience, emphasizing the educational value of the exercise. The presenter also highlights the simplicity of creating a basic parser using Haskell's typeclasses and combinators.