Document not found (404)
+This URL is invalid, sorry. Please use the navigation bar or search to continue.
+ +":e:f.tabReplace?e.replace(/\t/g,f.tabReplace):e):e}function E(e){let n=null;const t=function(e){var n=e.className+" ";n+=e.parentNode?e.parentNode.className:"";const t=f.languageDetectRe.exec(n);if(t){var r=T(t[1]);return r||(console.warn(g.replace("{}",t[1])),console.warn("Falling back to no-highlight mode for this block.",e)),r?t[1]:"no-highlight"}return n.split(/\s+/).find(e=>p(e)||T(e))}(e);if(p(t))return;S("before:highlightBlock",{block:e,language:t}),f.useBR?(n=document.createElement("div")).innerHTML=e.innerHTML.replace(/\n/g,"").replace(/
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/mark.min.js b/guide/mark.min.js
new file mode 100644
index 0000000..1636231
--- /dev/null
+++ b/guide/mark.min.js
@@ -0,0 +1,7 @@
+/*!***************************************************
+* mark.js v8.11.1
+* https://markjs.io/
+* Copyright (c) 2014–2018, Julian Kühnel
+* Released under the MIT license https://git.io/vwTVl
+*****************************************************/
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):e.Mark=t()}(this,function(){"use strict";var e="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},t=function(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")},n=function(){function e(e,t){for(var n=0;n
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parser Combinators
+Practical Parsing for Pragmatic Programmers
+You are looking at the guide accompanying a workshop about parser combinators.
+Parser combinators is an interesting topic that allows a developer to parse complex input into rich data-structures in a modular fashion. This form of parsing is possible in any language that supports higher order functions. Luckily that includes a lot of languages, like Java, Python, JavaScript and many more.
+We believe in learning by doing, so you can expect to be asked to open your favourite editor or integrated development environment and gain first-hand practical experience with parser combinators, by following along this guide. Exercises along the way help cement your new found knowledge making parser combinators a valuable tool in your toolkit.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/prelimenaries/languages.html b/guide/prelimenaries/languages.html
new file mode 100644
index 0000000..8292400
--- /dev/null
+++ b/guide/prelimenaries/languages.html
@@ -0,0 +1,250 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Grammars and EBNF
+Before diving in EBNF (Extended Backus-Naur Form), we need to have a simple understanding on grammars.
+Grammars
+A grammar is a set of rules a language adheres to. Commonly languages can be described by grammars, natural languages +(e.g. Dutch or English) but also computer languages (Java, Haskell, etc.). The rules for computer languages are +stricter than the rules for natural languages. In general computer languages don't allow for ambiguities whereas +natural languages are filled with ambiguities.
+A grammar for a computer language (from now on just language) is normally described using EBNF.
+EBNF
+EBNF (Extended Backus-Naur Form) is a way to describe a grammar. For example:
+non zero digit ::= "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+digit ::= "0" | non zero digit ;
+natural number ::= non zero digit digit* ;
+integer ::= "0" | "-"? natural number ;
+This can be interpreted as follows.
+-
+
- A non zero digit is a 1
ora 2ora 3or... 9
+ - A digit is a 0
ora non zero digit
+ - A natural number is a non zero digit
concatenatedwith arepetitionof digits
+ - An integer is a 0
oranoptional-concatenatedwith a natural number
+
Someone familiar with regular expressions might recognise the following operators:
+| Operator | Meaning |
|---|---|
| * (Kleene star) | 0 or more occurrences |
| + (Kleene cross) | 1 or more occurrences |
| ? | 0 or 1 occurrences |
| ( ) (parentheses) | grouping |
| invisible | concatenation |
Exercises
+-
+
- Write a grammar for a simple expression e.g. addition only +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/prelimenaries/parser.html b/guide/prelimenaries/parser.html
new file mode 100644
index 0000000..f074fe7
--- /dev/null
+++ b/guide/prelimenaries/parser.html
@@ -0,0 +1,271 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Languages
+When we are studying the topic of parsing, it is inevitable to discuss languages. There is a large body of work on formal languages and ways to work with them. The reason for this is that programming languages are examples of formal languages. Knowing how to efficiently transform a member of one programming language into instructions for a computer is what a compiler does.
+Definition
+For our use case it is enough to have working knowledge about languages. In this workshop we will be a bit vague and define a language as follows.
+++A language is any collection of strings.
+
An element in a language is called a word.
+Some examples of languages are
+-
+
- The language consisting of the authors names:
{"daan", "geert"}.
+ - The language consisting of one of the authors childrens names:
{"sophie", "robin", "hannah"}.
+ - The language of all english words:
{"ape", "avacado", ... }.
+ - The language of words solely consisting of any number of
'a's:{"", "a", "aa", "aaa", ... }.
+
Categories
+There are languages in all shapes and sizes. Some languages are finite, such as the language consisting of the authors names. Other languages are infinite.
+Some languages have a lot of structure which can be captured in a grammar, which will be the subject of our next chapter.
+Exercises
+-
+
- Give your own example of a language. +
- It the English language finite or infinite? What about other natural languages? +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/prelimenaries/style.html b/guide/prelimenaries/style.html
new file mode 100644
index 0000000..6dca9e3
--- /dev/null
+++ b/guide/prelimenaries/style.html
@@ -0,0 +1,238 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ What is a Parser
+Before we start out creating a parser combinator framework, it is good to consider the question
+++What is a parser?
+
In this workshop a parser is a "function" that takes as input a string that describes some structure, and returns a representation of that structure in memory.
For example, say that we are handed the string "37". If we are told that the string contains a description of an integer, we might wan to use a parser to turn that description into an actual integer. I.e. the integer 37.
There is a problem though. What if we are told that the input contains a description of an integer in base 10 and we are handed the string "teapot"? Even with the best will in the world, it is impossible for a parser to turn "teapot" into an integer in a meaningfull way.
So we need a way for parsers to signal that they could fail.
+Signature
+We need a way to distuingish between a parser that fails and a parser that succeeds. We will use a list for that. If a parser fails we return an empty list. If a parser succeeds we return a non-empty list. But what should we return in the list?
+First thought
+As a first thought you might guess that we should return the structure for which the input is a description. This would work in the example above. Unfortunatly, that choice is not very composable.
+For this to make sense we have to understand our overal goal. What we would like is to create complex parsers that our build up from simpler parsers. But how would you combine simpler parser if your parser returns just the success or failure of parsing a certain structure? The complex parser would than have to keep track of how many characters are consumed.
+Keeping track of the which part of the input is consumed is tedious, especially if it has to be done anew for each parser we create.
+Second thought
+An other option is to not only return the structure, but also the part of the input that is unprocessed. For example, say that we have an input that represents a tuple of a age and a name. I.e. "41 daan". We could use our parser that parses an integer for the age part. If it only returned the integer, it would be hard to combine with other parsers.
Instead if the integer parser would return [(41, " daan")], an other parser could pick up where the integer parser left off.
Final Form
+So the final form of our parser is as follows. It is a function that accepts a string and returns a list of pairs. The first component of the pair is the structure that the parser has parsed, the second component of the pair is the remaining part of the input.
The above sentence can be succintly described by the type for a parser
+++string -> [(T, string)]
+
Caveats
+There are a lot of caveats in the above "definition" and we will discuss some of them here. Some others are discussed in the exercises. And there are probably some that we aren't even aware of. So don't hesitate to come and discuss them with us.
+"Function"
+We have put the term function in quotes. The reason for this is that we are not in control of which programming language you use. You are free to use any language you like.
+Some language have functions as first class citizen. You are in luck if you are using such a language. You could use actual functions as parsers.
+If the language of your choice does not have good support for functions, don't worry. You could mimic the technique in this workshop. It might be a bit verbose at some points, but the ideas are still worthwhile.
+Returning List
+We opted to have a list as return type. This is a choice and you could take a different route here.
+The choice isn't without thought. One of the first descriptions of parser combinators also used list in their return type. This allows to signal failure to parse with an empty list and to signal success with a singleton list.
+But other possibilities are open to us as well. For example, it allows one to return multiple succesfull results. This is helpfull when the grammar is ambiguous. Instead of working hard to remove the ambiguity in the grammar or in the implementation, we just return all possible parsings.
+Error information
+A good parser would also provide hints on what went wrong. The minimum of good error reporting is the row and column information of where the parser got stuck.
+We will not concentrate on error reporting in this workshop. There are some hints in the exercises how one could handle this.
+Exercises
+-
+
- What is the smallest base in which
"teapot"could be a description of a valid integer? Assume that 'a' corresponds with 10, 'b' with 11 etcetera.
+ - If your language of choice does not support first class functions, how could you remedy that? Discuss your ideas with a participant or the guides. +
- How would you model the success and failure states of a parser? +
- How would you enrich the return type to fascilitate error reporting? +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/prelimenaries/types.html b/guide/prelimenaries/types.html
new file mode 100644
index 0000000..561fd65
--- /dev/null
+++ b/guide/prelimenaries/types.html
@@ -0,0 +1,272 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Style
+There are various programming languages, each with their own style or paradigm.
+For this workshop it is not particularly important which style to use. The important property is that one should be able to create complex constructs from simpler building blocks.
+This can be done in the object oriented style by composing objects. In a functional style one would compose functions.
+We leave it at your own discretion how best to implement the ideas in this workshop. That does not mean that you are on your own. There is always room to discuss your ideas with other participants or with the workshop guide before commiting to a certain style.
+Exercises
+-
+
- What is your favorite programming language and what style does it use? +
- What styles do you like? +
- What style are you going to use for the workshop? +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/print.html b/guide/print.html
new file mode 100644
index 0000000..7eddc54
--- /dev/null
+++ b/guide/print.html
@@ -0,0 +1,1084 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Types
+Not every programming language is the same. Among the characteristics in which programming languages can differ, we will highlight types in this section.
+Type System
+A type system is
+++a logical system comprising a set of rules that assigns a property called a type to the various constructs of a computer program, such as variables, expressions, functions or modules.
+
which isn't really helpful, if you don't already know what a type is.
+One could say that types are used to prevent certain mistakes. For example, a type system could prevent the addition of a number with a string, something that does not make sense in every situation. If you want to know more about types and how they are used we recommend Types and Programming Languages by Benjamin Pierce.
+Not every programming language uses types, and the programming languages that do aren't always explicit about it. Even though this workshop is language agnostic, meaning that we don't use a concrete language to express the ideas, we can benefit from discussing types.
+In order to fascilitate the discussion we will introduce a type notation. This is a description of a certain type.
+Notation
+In order get start the discussion we need to be able to express certain base types. Since we are talking a lot about languages, which are just a collection of strings we are going to include those in are notation.
+Base
+The notation for base types include string, integer, boolean etcetera. These will form building blocks for more complex types. The are written with all lower-case letters.
Type Variables
+Sometimes we need a type, but aren't interested in which concrete type it is. We will use type variables for that. For example T is a type variable. It could be a string, integer or any other type. The are written with a starting capital letter. Often we will use a single letter. When we want to convey intent on how the type is used we could use words.
Functions
+Functions are important and we will want to discuss them and their types. For example, the length of a string is a function. It accepts an argument of type string and return a value of type integer. We denote the type of the length function with string -> integer.
In general if we have types S and T, a functions that maps values of type S into values of type T is denoted by S -> T.
Pair
+We sometimes want to combine to pieces of information. For example, you could keep track of your age. At the moment that would be ("daan", 41). Notice that the first part is a value of type string. The second part is a value of type integer. The pair has type (string, integer).
For types S and T, the type of a pair of these values is denoted by (S, T).
List
+Sometimes we want discuss lists of things. An example would be a list of the names of your friends. The type of a list of strings is denoted by [string].
We can generalize that for an arbitrary type T. A list of Ts is denoted by [T].
Summary
+In order to clearly express our thoughts we introduce types. There is a concrete notation to denote type, which consist of the following rules.
+-
+
- We have some basic types like
string,integer, etcetera.
+ - For a type variable
T, we denote lists ofTas[T].
+ - For type variables
SandT, a pair ofSandTis denoted with(S, T).
+ - For type variables
SandT, a function is denoted byS -> T.
+
Exercises
+-
+
- Describe the following type in your own words. +
string -> [(string,integer)]
+-
+
- The function that counts the occurences of a certain character in a string could be denoted by
(string, character) -> integer. A different view of this function is would bestring -> character -> integer. This can be read as a function that accepts as argument a value of typestringand returns a function of typecharacter -> integer.
+
The process is called Currying after the computer scientist Haskell Curry.
+What is the type of the curried function type (S, T) -> U?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/project/expression.html b/guide/project/expression.html
new file mode 100644
index 0000000..b77e966
--- /dev/null
+++ b/guide/project/expression.html
@@ -0,0 +1,251 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+character
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parser Combinators
+Practical Parsing for Pragmatic Programmers
+You are looking at the guide accompanying a workshop about parser combinators.
+Parser combinators is an interesting topic that allows a developer to parse complex input into rich data-structures in a modular fashion. This form of parsing is possible in any language that supports higher order functions. Luckily that includes a lot of languages, like Java, Python, JavaScript and many more.
+We believe in learning by doing, so you can expect to be asked to open your favourite editor or integrated development environment and gain first-hand practical experience with parser combinators, by following along this guide. Exercises along the way help cement your new found knowledge making parser combinators a valuable tool in your toolkit.
+Languages
+When we are studying the topic of parsing, it is inevitable to discuss languages. There is a large body of work on formal languages and ways to work with them. The reason for this is that programming languages are examples of formal languages. Knowing how to efficiently transform a member of one programming language into instructions for a computer is what a compiler does.
+Definition
+For our use case it is enough to have working knowledge about languages. In this workshop we will be a bit vague and define a language as follows.
+++A language is any collection of strings.
+
An element in a language is called a word.
+Some examples of languages are
+-
+
- The language consisting of the authors names:
{"daan", "geert"}.
+ - The language consisting of one of the authors childrens names:
{"sophie", "robin", "hannah"}.
+ - The language of all english words:
{"ape", "avacado", ... }.
+ - The language of words solely consisting of any number of
'a's:{"", "a", "aa", "aaa", ... }.
+
Categories
+There are languages in all shapes and sizes. Some languages are finite, such as the language consisting of the authors names. Other languages are infinite.
+Some languages have a lot of structure which can be captured in a grammar, which will be the subject of our next chapter.
+Exercises
+-
+
- Give your own example of a language. +
- It the English language finite or infinite? What about other natural languages? +
Grammars and EBNF
+Before diving in EBNF (Extended Backus-Naur Form), we need to have a simple understanding on grammars.
+Grammars
+A grammar is a set of rules a language adheres to. Commonly languages can be described by grammars, natural languages +(e.g. Dutch or English) but also computer languages (Java, Haskell, etc.). The rules for computer languages are +stricter than the rules for natural languages. In general computer languages don't allow for ambiguities whereas +natural languages are filled with ambiguities.
+A grammar for a computer language (from now on just language) is normally described using EBNF.
+EBNF
+EBNF (Extended Backus-Naur Form) is a way to describe a grammar. For example:
+non zero digit ::= "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+digit ::= "0" | non zero digit ;
+natural number ::= non zero digit digit* ;
+integer ::= "0" | "-"? natural number ;
+This can be interpreted as follows.
+-
+
- A non zero digit is a 1
ora 2ora 3or... 9
+ - A digit is a 0
ora non zero digit
+ - A natural number is a non zero digit
concatenatedwith arepetitionof digits
+ - An integer is a 0
oranoptional-concatenatedwith a natural number
+
Someone familiar with regular expressions might recognise the following operators:
+| Operator | Meaning |
|---|---|
| * (Kleene star) | 0 or more occurrences |
| + (Kleene cross) | 1 or more occurrences |
| ? | 0 or 1 occurrences |
| ( ) (parentheses) | grouping |
| invisible | concatenation |
Exercises
+-
+
- Write a grammar for a simple expression e.g. addition only +
Types
+Not every programming language is the same. Among the characteristics in which programming languages can differ, we will highlight types in this section.
+Type System
+A type system is
+++a logical system comprising a set of rules that assigns a property called a type to the various constructs of a computer program, such as variables, expressions, functions or modules.
+
which isn't really helpful, if you don't already know what a type is.
+One could say that types are used to prevent certain mistakes. For example, a type system could prevent the addition of a number with a string, something that does not make sense in every situation. If you want to know more about types and how they are used we recommend Types and Programming Languages by Benjamin Pierce.
+Not every programming language uses types, and the programming languages that do aren't always explicit about it. Even though this workshop is language agnostic, meaning that we don't use a concrete language to express the ideas, we can benefit from discussing types.
+In order to fascilitate the discussion we will introduce a type notation. This is a description of a certain type.
+Notation
+In order get start the discussion we need to be able to express certain base types. Since we are talking a lot about languages, which are just a collection of strings we are going to include those in are notation.
+Base
+The notation for base types include string, integer, boolean etcetera. These will form building blocks for more complex types. The are written with all lower-case letters.
Type Variables
+Sometimes we need a type, but aren't interested in which concrete type it is. We will use type variables for that. For example T is a type variable. It could be a string, integer or any other type. The are written with a starting capital letter. Often we will use a single letter. When we want to convey intent on how the type is used we could use words.
Functions
+Functions are important and we will want to discuss them and their types. For example, the length of a string is a function. It accepts an argument of type string and return a value of type integer. We denote the type of the length function with string -> integer.
In general if we have types S and T, a functions that maps values of type S into values of type T is denoted by S -> T.
Pair
+We sometimes want to combine to pieces of information. For example, you could keep track of your age. At the moment that would be ("daan", 41). Notice that the first part is a value of type string. The second part is a value of type integer. The pair has type (string, integer).
For types S and T, the type of a pair of these values is denoted by (S, T).
List
+Sometimes we want discuss lists of things. An example would be a list of the names of your friends. The type of a list of strings is denoted by [string].
We can generalize that for an arbitrary type T. A list of Ts is denoted by [T].
Summary
+In order to clearly express our thoughts we introduce types. There is a concrete notation to denote type, which consist of the following rules.
+-
+
- We have some basic types like
string,integer, etcetera.
+ - For a type variable
T, we denote lists ofTas[T].
+ - For type variables
SandT, a pair ofSandTis denoted with(S, T).
+ - For type variables
SandT, a function is denoted byS -> T.
+
Exercises
+-
+
- Describe the following type in your own words. +
string -> [(string,integer)]
+-
+
- The function that counts the occurences of a certain character in a string could be denoted by
(string, character) -> integer. A different view of this function is would bestring -> character -> integer. This can be read as a function that accepts as argument a value of typestringand returns a function of typecharacter -> integer.
+
The process is called Currying after the computer scientist Haskell Curry.
+What is the type of the curried function type (S, T) -> U?
Style
+There are various programming languages, each with their own style or paradigm.
+For this workshop it is not particularly important which style to use. The important property is that one should be able to create complex constructs from simpler building blocks.
+This can be done in the object oriented style by composing objects. In a functional style one would compose functions.
+We leave it at your own discretion how best to implement the ideas in this workshop. That does not mean that you are on your own. There is always room to discuss your ideas with other participants or with the workshop guide before commiting to a certain style.
+Exercises
+-
+
- What is your favorite programming language and what style does it use? +
- What styles do you like? +
- What style are you going to use for the workshop? +
What is a Parser
+Before we start out creating a parser combinator framework, it is good to consider the question
+++What is a parser?
+
In this workshop a parser is a "function" that takes as input a string that describes some structure, and returns a representation of that structure in memory.
For example, say that we are handed the string "37". If we are told that the string contains a description of an integer, we might wan to use a parser to turn that description into an actual integer. I.e. the integer 37.
There is a problem though. What if we are told that the input contains a description of an integer in base 10 and we are handed the string "teapot"? Even with the best will in the world, it is impossible for a parser to turn "teapot" into an integer in a meaningfull way.
So we need a way for parsers to signal that they could fail.
+Signature
+We need a way to distuingish between a parser that fails and a parser that succeeds. We will use a list for that. If a parser fails we return an empty list. If a parser succeeds we return a non-empty list. But what should we return in the list?
+First thought
+As a first thought you might guess that we should return the structure for which the input is a description. This would work in the example above. Unfortunatly, that choice is not very composable.
+For this to make sense we have to understand our overal goal. What we would like is to create complex parsers that our build up from simpler parsers. But how would you combine simpler parser if your parser returns just the success or failure of parsing a certain structure? The complex parser would than have to keep track of how many characters are consumed.
+Keeping track of the which part of the input is consumed is tedious, especially if it has to be done anew for each parser we create.
+Second thought
+An other option is to not only return the structure, but also the part of the input that is unprocessed. For example, say that we have an input that represents a tuple of a age and a name. I.e. "41 daan". We could use our parser that parses an integer for the age part. If it only returned the integer, it would be hard to combine with other parsers.
Instead if the integer parser would return [(41, " daan")], an other parser could pick up where the integer parser left off.
Final Form
+So the final form of our parser is as follows. It is a function that accepts a string and returns a list of pairs. The first component of the pair is the structure that the parser has parsed, the second component of the pair is the remaining part of the input.
The above sentence can be succintly described by the type for a parser
+++string -> [(T, string)]
+
Caveats
+There are a lot of caveats in the above "definition" and we will discuss some of them here. Some others are discussed in the exercises. And there are probably some that we aren't even aware of. So don't hesitate to come and discuss them with us.
+"Function"
+We have put the term function in quotes. The reason for this is that we are not in control of which programming language you use. You are free to use any language you like.
+Some language have functions as first class citizen. You are in luck if you are using such a language. You could use actual functions as parsers.
+If the language of your choice does not have good support for functions, don't worry. You could mimic the technique in this workshop. It might be a bit verbose at some points, but the ideas are still worthwhile.
+Returning List
+We opted to have a list as return type. This is a choice and you could take a different route here.
+The choice isn't without thought. One of the first descriptions of parser combinators also used list in their return type. This allows to signal failure to parse with an empty list and to signal success with a singleton list.
+But other possibilities are open to us as well. For example, it allows one to return multiple succesfull results. This is helpfull when the grammar is ambiguous. Instead of working hard to remove the ambiguity in the grammar or in the implementation, we just return all possible parsings.
+Error information
+A good parser would also provide hints on what went wrong. The minimum of good error reporting is the row and column information of where the parser got stuck.
+We will not concentrate on error reporting in this workshop. There are some hints in the exercises how one could handle this.
+Exercises
+-
+
- What is the smallest base in which
"teapot"could be a description of a valid integer? Assume that 'a' corresponds with 10, 'b' with 11 etcetera.
+ - If your language of choice does not support first class functions, how could you remedy that? Discuss your ideas with a participant or the guides. +
- How would you model the success and failure states of a parser? +
- How would you enrich the return type to fascilitate error reporting? +
Succeed and Friends
+So we have established a signature for our parser
+string -> [(T, string)]
+In other words: a parser is a function that accepts a string and returns a list of pairs. Each pair in the list is a combination of a value of type T and a string, which is the remaining input.
What would the simplest parser be?
+succeed
+One of the simplest parser would not bother with the input and instead return a value we provide.
+Thinking hard about the signature we could come up with
+T -> string -> [(T, string)]
+Let's break this signature down. There are some arrows involved so this is a function. The part after the first arrow is the same as the signature for our parser.
+So this is a function that accepts an argument of type T and returns the parser.
Below you can find some examples of how we would use succeed
+| input | succeed(37) |
|---|---|
| "whatever" | [(37, "whatever")] |
| "input" | [(37, "input")] |
| "ABC" | [(37, "ABC")] |
With succeed under our belt, we can go on to an other simple parser. One could argue that it is even simpler then succeed.
fail
+Some parsers fail to turn the input into a meaningfull structure. fail is the quintessential example. It fails on any input, whatever that is.
Here are some examples.
+| input | fail() |
|---|---|
| "whatever" | [] |
| "input | [] |
| "ABC" | [] |
Why these parsers?
+The succeed and fail parser seem very simple. Certainly they can not have practical use, other then introducing you to the idea of parsers.
Although succeed and fail are simple parsers, the are powerful none the less. It can seem that these parsers would not amount to anything, but within a few chapters they allow you to wield tremendous power.
So don't dismiss them just yet, they will come in handy rather sooner then later.
+Exercises
+-
+
- Provide your own example to cement your understanding of
succeed. Discuss your example with somebody.
+ - Implement the
succeedfunction in your language of choice. You will have to choose how to represent functions.
+ - Make sure you are confident your implementation works as expected. You could write tests, use a read-eval-print-loop (REPL) or any other means to check. +
- What is the type of the
failfunction?
+ - Implement
failand test your implementation.
+
character A
+One of the simplest parsers that depends on any input to parse is a parser that succeeds if the input starts with the character 'A'.
For example, parserA is a parser that succeeds if the input starts with the character 'A'. Below we summarize our expectation for parserA.
| input | parserA() |
|---|---|
| "ABC" | [("A", "BC")] |
| "BC" | [] |
| "aBC" | [] |
Implementation
+Below you can find some pseudo code for the parserA function.
The implementation of the parserA function relies on the capabilities of your language to work with string. Here we assume that your language can tell you when a certain string start with an other character. See the exercises for some pointers on how to solve the problem if your language does not provide such functionality.
parserA() =
+ input => if input.startsWith('A') then
+ [("A", input[1:])]
+ else
+ []
+Here input[1:] means the rest of the input starting with the second character, since our lists indices are zero-based. People familiar with Python will feel comfortable with this notation.
Exercises
+-
+
- What is the type of
parserA?
+ - Implement
parserAin your favorite language. From now on, implement will also mean verify your implementation.
+ - If your language does not have a
startsWithfunction forstringhow would you implement it? What tools are provided for working withstring?
+
Any character
+The work we have done for the parsing of a character 'A', could also be done for other characters.
One could copy the implementation of parserA and change it into a parserB, a parserC or a parser^ for that matter.
+Instead we will define a character function that accepts the character to parse as an argument.
+That is, character is a parser that accepts a character as argument and returns a parser that succeeds if the input starts with that character. Below we summarize our expectation for character.
+| input | char | character(char) |
|---|---|---|
| "ABC" | 'A' | [("A", "BC")] |
| "BC" | 'A' | [] |
| "aBC" | 'A' | [] |
| "aBC" | 'a' | [("a", "BC")] |
Implementation
+The implementation of the character function has a lot in common with parserA.
character(char) =
+ input => if input.startsWith(char) then
+ [(char.toString(), input[1:])]
+ else
+ []
+Exercises
+-
+
- What is the type of the
characterfunction?
+ - Implement the
characterfunction.
+ - Implement
parserAin terms ofcharacter. This is a common practice in this workshop. When you notice a common pattern in parsers, generalize it.
+
Parse a token
+Instead of parsing a single character, we could try to parse a word or token.
+Assume we want to know if an input starts with a name, for example "Geert". But you yourself could be interested in a different name. So we would like to create a function that accepts a token and returns a parser that accepts input whenever it starts with that token.
Below you find some expectations we have for the token parser.
| input | t | token(t) |
|---|---|---|
| "Geert is a father" | "Geert" | [("Geert", " is a father")] |
| "if a == 1 then 1 else 2" | "if" | [("if", " a == 1 then 1 else 2")] |
| "Daan is a father" | "Geert" | [] |
| "while a == 1 do nothing" | "if" | [] |
Implementation
+The implementation of token is very similar to the character implementation. This is in part because we reuse our startsWith function. It magically accepts both characters and strings! Real languages might not be so flexible.
token(t) =
+ input => if input.startsWith(t) then
+ [(t, input[t.size:])]
+ else
+ []
+We use our Python inspired notation input[n:] to snip of the the length of the token t from our input.
Exercises
+-
+
- What is the type of the
tokenfunction?
+ - Implement
token.
+
Parse a Predicate
+Just like we generalized characterA into character, we are going to generalize character into something we will call satisfy.
The satisfy function will accept a predicate, and returns a parser that will succeed when the input starts with a character that fulfills the predicate. A predicate is a function that accepts a character and returns a boolean.
char -> boolean
+As an example how we would want to use the satisfy function, we could write the following equation.
characterA == satisfy(c => c == 'A')
+Here we have introduced the notation for a function without a name: c => c == 'A'. This notation can be read as follows
-
+
- The part before
=>names the parameter of the function.
+ - The part after
=>is the body of the function.
+
In our example we have denoted a function that accepts a character c and returns true when that character equals 'A'.
Our expectations for the satisfy function are
| input | predicate | satisfy(predicate) |
|---|---|---|
| "ABC" | c => c == 'A' | [('A', "BC")] |
| "aBC" | c => c == 'a' | [('a', "BC")] |
| "ABC" | c => c == '!' | [] |
Implementation
+The satisfy function is not that different from either the character or token functions. The difference are the clause in the if-expression, and how we return our input.
satisfy(predicate) =
+ input => if predicate(input[0]) then
+ [(input[0], input[1:])]
+ else
+ []
+Exercises
+-
+
- What is the type of the
satisfyfunction?
+ - Implement
satisfy.
+ - Implement the
characterfunction in terms of thesatisfyfunction.
+ - Does your implementation work correctly when the input is the empty string? +
Parse this or that
+With some basic parsers under our belt, we can start looking at a combinator. A combinator is a function that combines simpler things into a more complex thing. In our case, it combines simpler parsers into a more complex parser.
+Sometimes you find yourself at a cross road. Either we want to parse a number, or we want to parse a variable name. If we have simpler parser that can parse a number and another parser that can parse a variable name, we can combine them into a more complex parser that could parse either of the two.
+Assuming we have parsers A = character('A') and B = character('B'), below you find a table of our expectations for the or combinator.
| input | or(A, B) |
|---|---|
| "ABC" | [("A", "BC")] |
| "BAC" | [("B", "AC")] |
| "aBC" | [] |
Signature
+Remember, the type of a parser is string -> [(T, string)] where T is a type variable representing the structure that is returned for this parser.
A combinator is a higher order function. I.e.
+++a function that does at least one of the following:
++
+- takes one or more functions as arguments,
+- returns a function as its result.
+
In our case it does both. We accept two parsers, which themselves are functions and in turn returns a parser, again a function. The type of or is
or : (string -> [(T, string)]) -> (string -> [(T, string)]) -> (string -> [(T, string)])
+or, if we abbreviate string -> [(T, string)] to parser T, it could read
or : parser T -> parser T -> parser T
+I.e. or is a function that accepts two parsers and returns a third.
Implementation
+When we think about an implementation of or we need to consider the two parsers that are used to construct the result parser. If we have a parser A that produces output resultA on input I, and a parser B that produces output resultB on input I, parser or(A, B) should produce the concatenation of resultA and resultB on input I.
or(A, B) =
+ input => A(input).concat(B(input))
+Exercises
+-
+
- Implement the
orcombinator.
+ - If you want choose between multiple options to parse, how would you implement
orin that case?
+
Parse this and then that
+What we are going to combine in this chapter is two parsers with the intent of parsing with the first parser and then parse the remaining input with the second parser.
+Let's assume again that we have parser A = character('A') and B = character('B'). The expectations of the and combinator are
| input | and(A, B) |
|---|---|
| "ABC" | [(('A', 'B'), "C")] |
| "ABCD" | [(('A', 'B'), "CD")] |
| "aBC" | [] |
Note that when the parser accepts its input, it returns a pair as a result. In our example it is a pair of characters, but it depends on the parser that we are combining.
+Exercises
+-
+
- What is the type of the
andcombinator?
+ - Create the
andcombinator. Depending on your language it would be better to return a list of results instead of a pair.
+ - If you wanted to combine more than two consecutive parsers, how would you implement that? +
Just all
+Some parsers accept only a part of their input. This is generally fine for intermediate parsers, but you generally want to accept the entire input for top-level parsers.
+The just parser does just that. It accepts a parsers and will only succeed when the remaining input is empty.
| input | just(character('A')) |
|---|---|
| "ABC" | [] |
| "A" | [('A', "")] |
| "aBC" | [] |
Implementation
+Once we parsed our input, we need to remove the results that did not consume the entire input.
+just(p) =
+ input => filter ((r, rest) => rest == "") (p input)
+Here filter is a function that accepts a list and keeps all the elements in the list that satisfy the predicate.
Exercises
+-
+
- What is the type of the
justcombinator?
+ - Implement the
justcombinator.
+
Transform a result
+Sometimes you end up with a parser for a certain structure A, but you want to have a parser for an other structure B, which you now how to make from a structure A. For example, you have a parser that accepts a character '7', but you want to have a parser that accepts the corresponding number 7.
The map parser combinator will help you out in this situation. It will accept a parser string -> [(A, string)] and turn is into a parser string -> [(B, string)]. For this you need to provide a transform function A -> B.
| Input | parser | transform | map(transform, parser) |
|---|---|---|---|
| "123" | satisfy(isDigit) | toInt | [(1, "23")] |
| "ABC" | satisfy(isDigit) | toInt | [] |
Implementation
+For the map combinator we rely on the a function that can transform a list in the same way. We only need to change the first arguments of the tuples in our result list.
map(f, parser) =
+ input =>
+ listMap ((r, rest) => (f(r), rest)) (parser input)
+Exercises
+-
+
- What is the type of
map?
+ - Implement the
mapcombinator.
+ - If your languages does not have a
listMap, how would you implement that?
+
Being lazy
+Up until now, our parser combinators are not recursive. Every combinator accepts one or more parsers and use combine them into a more complex parser.
+What we are about to do is define parser combinators that are defined in terms of themselves.
+This can be problematic. The problem is that our combinators have to return a parser. They can't predict how deeply nested a parser needs to be called. Take a look at the following grammar.
+A ::= A | "a";
+This grammar accepts any number of the character 'a'. If we naively write a parser we would might write the following.
+A =
+ or(A(), character('a'))
+The thoughts are: Our parser A is either
-
+
- our parser
A
+ - a character
'a'.
+
The first part is problematic, because when it calls the A parser it will go down an infinite path. If we would try to call A we would need to repeatedly call A without bounds.
-
+
A()
+or(A(), character('a'))
+or(or(A(), character('a')), character('a'))
+or(or(or(A(), character('a')), character('a')), character('a'))
+or(or(or(or(A(), character('a')), character('a')), character('a')), character('a'))
+- ... +
Solution
+One way to solve this problem is to delay the call to yourself. What we instead would like to say is, when it is time to parse some input I will produce a the parser that is going to do the parsing. So there are two ingredients: a parser producer, and a combinator that works in the above manner.
+Parser producer
+We could use a function that accepts a dummy value as a producer. It's signature would be () -> string -> [(T, string)] or, using the parser alias, () -> parser T.
One could implement a producer with an anonymous function. Say we have a parser A, a producer of A could be implemented as
_ => A
+Here we use an underscore _ to signify that we are not interested in the actual argument.
combinator
+The last ingredient is a combinator that accepts a producer for a parser and returns a parser that uses it.
+lazy(p) =
+ input => (p ())(input)
+This might be hard to read. The first parenthesized part (p ()) calls the producer. It will return a parser. That parser is then called with the input to return the parse result.
Exercises
+-
+
- What is the type of the
lazycombinator?
+ - Implement the
lazycombinator.
+ - Is it possible not to use recursion? +
Parse many things
+Parsing a single character, or a single character and then an other, will only get you so far. Sometimes you want to accept many things. This chapter introduces a parser combinator that does exactly this.
+The many combinator accepts a parser p and returns a parser that accepts input precisely when p succeeds any number of times.
| Input | many(character('A')) |
|---|---|
| "" | [([], "")] |
| "A" | [(['A'], ""), ([], "A")] |
| "AA" | [(['A', 'A'], ""), (['A'], "A"), ([], "AA")] |
| "aAA" | [([], "aAA")] |
This is the first time that a parser returns multiple possible results. The different results correspond with the different options. Any number of times include
+-
+
- zero times +
- one time +
- two times +
- three times +
- etcetera +
This can be seen in our results. In the example with the input "AA" the parser many(character('A')) can parse
-
+
- Two 'A's, with no remaining input. +
- One 'A', with remaining input "A". +
- Zero 'A's, with remaining input "AA". +
All these results are returned, in the order from most input consumed to least input consumed.
+Implementation
+The implementation of the many combinator is defined in terms of itself. The lazy combinator allows a call to the parser you are defining without blowing the call stack. Our pseudo-code had this build in 😁.
many(p) =
+ or(map(combine, and(p, many(p))), succeed([]))
+We are relying on combinators from earlier chapters. Because of this the implementation is not as exact, leaving some ideas to be explored.
+Exercises
+-
+
- What is the type the
manycombinator?
+ - What is the type of the
combinefunction used to map the result of parserpand thenmany(p)?
+ - Implement the
combinefunction.
+ - Implement the
manycombinator. Don't forget to be lazy.
+ - The
manycombinator parses zero or more items. Create a combinatormany1that parser one or more items.
+
It does not end here
+We have created a number of basic parsers and combinators for them. But it does not end here.
+Not all combinators that could come in handy are already defined. Some of them are presented in the utilities section, others are only discovered after using the parser combinator framework.
+If you want to try your hand on creating other parser combinators that serve a certain purpose, stick around.
+If instead you would like to use them to parse an interesting structure, take a look at the projects section.
+Time to spread your wings
+In the preceding chapters there was pseudo code that provided hints on how to implement certain parser.
+Now is the time to spread your wings and take to the skies without our hints. You will not find pseudo code anymore. Partly because it allows you to cement the knowledge obtained from the workshop. Partly because the pseudo code is for all intents and purposes indistinct from an actual implementation.
+Ignore the result
+Sometimes you are not that interested in the result of a parser. For example, if you are parsing a tuple at one point you need to parse the character '('. But you don't really need the actual character. You just want to make sure that the parse succeeds.
This is where the ignore parser combinator comes in. It accepts a parser p and parses the same input as p would do. The only difference is that it ignores the resulting value. Instead it returns a dummy value.
Exercises
+-
+
- What is the signature of the
ignoreparser combinator?
+ - Implement the
ignoreparser.
+
Commit to the first result
+Sometimes you are not interested in all possible ways of parsing input into a data structure. You are happy with the first successful parse.
+The first parser does precisely that. Instead of returning all the possible parsing of an input, it only returns the first.
Exercises
+-
+
- What is the signature of the
firstparser?
+ - Implement the
firstparser.
+ - How does the order of alternatives influence the semantics of
first?
+
Greedy parsing
+There are times that you just want to be greedy. Take what every you can get and continue.
+The greedy parser is your friend. It will execute the task above for you.
Exercises
+-
+
- What is the signature of the
greedyparser?
+ - Implement the
greedyparser. Try to express it as a combination of other parsers.
+ - The companion to
manyismany1. Implement agreed1parser.
+
Consecutive parsers
+The and parser is a happy little parser combinator. It takes two parsers and runs them consecutively, feeding the remaining input of the first parse into the second parser, returning the pair of results.
The only problem with the and parser is that it only accepts two parsers. Often you find yourself wanting to parser any number of parsers consecutively. For example, in order to parse a pair of a name and an integer, you would have to parse the following structures
-
+
- Parse a character
'('.
+ - Parse any name. +
- Parse a character
','.
+ - Parse any integer. +
- Parse a character
')'.
+
And combine the result of the name parser and the integer parser into a pair of the two.
+The consecutive parser will be build for this task. It accepts a sequence of parsers and a way to combine the intermediate results into a final result.
Exercises
+-
+
- What is the signature of the
consecutiveparser? Depending on the language you are working with, this can be a tricky question. Don't be afraid to sacrifice generality for practicality.
+ - Implement the
consecutiveparser.
+ - Use the
consecutiveparser to parse the tuple from the example.
+
Oneof the following parsers
+What consecutive is to and, oneOf is to or.
Just like the case for the and parser combinator, the or parser combinator only accepts two parsers. Often there a multiple alternatives that you want to combine. For example, when you are creating a full-blown programming language, an expression could be a number of things. Among the options there would be
-
+
- an assignment +
- an arithmetical expression +
- a logical expression +
- a ternary expression +
Exercises
+-
+
- What is the signature of the
oneOfparser combinator?
+ - Implement the
oneOfparser combinator.
+
Whitespace
+When parsing certain input, we are often not interested in the whitespace that is present. For example, the following expression should all result in the same data structure.
+-
+
5*2+1
+5*2 + 1
+5 * 2 + 1
+5 * 2 + 1
+
What is whitespace?
+Depending on your use case whitespace could mean different things. It could be just a space, just a tab, just a newline or any combination of the mentioned, and possibly other, characters.
+But once a choice is made, one could create a parser for it. We will call this parser whitespace.
Ignore whitespace prefix
+If whitespace is not important for the input that you are parsing, it can be ignored. A usefull parser combinator in this case is the sp parser combinator. It accepts a parser p and parses everything that p parses, even if it is preceded by any amount of whitespace.
| input | character('A') | sp(character('A')) |
|---|---|---|
| "ABC" | [('A', "BC")] | [('A', "BC")] |
| " ABC" | [] | [('A', "BC")] |
| " ABC" | [] | [('A', "BC")] |
The above table provides an example of the sp parser combinator. Where character('A') would fail if the string starts with any number of whitespace, the sp(character('A')) ignores the whitespace prefix and returns the wanted result.
Exercises
+-
+
- What is the signature of the
whitespaceparser?
+ - Implement the
whitespaceparser.
+ - What is the signature of the
spparser combinator?
+ - Implement the
spparser combinator.
+
Packing parser
+Often we want to parse some data that is surrounded with some structure. For example, some programming languages delineate blocks of code by a matched pair of curly braces. A literal list of items starts with an opening bracket and is finished with a closing bracket.
+The pack parser combinator accepts three parser. It "packs" the second parser in between the opening parser and the closing parser.
Exercises
+-
+
- What is the signature of the
packparser combinator?
+ - Implement the
packparser combinator.
+ - Define a parser combinator
parenthesizedthat packs a parser with a matching pair of parenthesis.
+ - Simiarly define a
bracketedparser.
+
Separating parser
+Lists, or other repetitive structures, often have some sort of separator that distinguishes between where one item stops and the next begins. In the case of a list of integers, a ',' would be used as separator. In some programming languages the ';' is used for similar purpose.
The separatedBy parser combinator will be used in this situation. It accepts two parsers. One parser will parse the separator, the other the structure that is separated.
Exercises
+-
+
- What is the signature of the
separatedByparser combinator?
+ - Implement the
separatedByparser combinator.
+
How to use it
+We have created a parser combinator framework that allows us to construct parsers by combining basic parsers into more elaborate parsers. But how do we use them?
+This section of the workshop presents to you various projects to solidify your understanding of parser combinators and how to use them. All projects follow more or less the following structure.
+-
+
- Identify what structure your want to end up with. +
- Create does structures in code. +
- Devise a grammar for how you want to describe those structures. +
- Create a parser for the grammar. +
All these steps and variants have real world counterparts. The most important one is step 1, what the structure do you want to work with. All steps follow from that.
+Because this is a workshop focusses on parser combinators, the realm that makes step 4 possible, the projects in this sections are providing steps 1 and 3 for you. You are still asked to implement the structures that you are going to work with, but that is mainly because you are free to choose your favorite programming language.
+List of things
+The first project we are going to take on is to parse a list of elements. For demonstration purposes the element will be either a character 'A' or a character 'B'. This way we can focus on the the list part of parsing a list. Do make sure to accept a the element parser as a parameter. This makes it easy to change the element parser later on.
For the record, a list is denoted by:
+-
+
- An opening bracket
'['.
+ - A comma seperated list of elements. +
- A closing bracket
']'.
+
The list parser combinator accepts an element parser and returns a parser that can parse a list of elements.
Exercises
+-
+
- What is the signature of the
listparser combinator.
+ - Implement the
listparser combinator, making use of the combinators in your framework.
+ - Create a parser that parses either a character
'A'or a character'B'.
+ - Create a parser that parses a list of
'A's and'B's.
+
Balanced parentheses
+The next project to grasp is parsing balanced parentheses. We will dispense with the content inside the parentheses and just focus on the structure of the parentheses.
+Grammar
+Below we will give a grammar for balanced parentheses:
+S := "(" S ")" S | ""
+Which in plain english is describing balanced parentheses as either
+-
+
- a opening parenthesis, followed by balanced parentheses, followed by a closing parenthesis, followed by balanced parentheses. +
- an empty string +
The empty string alternative serves as a base case. Without it, we would have no way to stop accepting parentheses.
+Structure
+We would like to define a data structure that reflects the structure of the balanced parentheses. A binary tree fits nicely.
+A binary tree has two alternatives. It is either a leaf that holds not no data. Or it is a node that contains two children, who both are trees. The children are called the left child and the right child. The left child represents the resultant tree from the first S in the production, the right child represents the resultant tree from the second S in the production.
Exercises
+-
+
- Represent a binary tree in code. +
- Which trees do the following inputs represent:
"()","(())()"and"()(()())()"?
+ - What is the signature of the parser that can parse trees? +
- Create a parser that can parse trees. +
Extra credit
+Formally balanced parentheses are a Dyck language. In this project we restricted our language to only use matching pairs of parentheses. But we could mix and match delimiters. For example, we could be interested in the language of properly matched pairs of parentheses () and brackets [].
How would the grammar change to allow different pairs of delimiters? How would the parser change? Can you generalize the parser of an arbitrary set of matching delimiters?
+Template Language
+Sometimes you want a template that can be specialized with a certain context. For example, the template "Hello, {subject}!" evaluated in the context subject => "World" should produce `"Hello, World!".
Grammar
+The grammar for this template language is a little subtle. In broad strokes there are two different parts. Literal text, like "Hello, " and "!" from our example. And substitutions, like "{subject}". Substitutions are formed by wrapping an identifier with a matching pair of braces.
Literal text seems straightforward. But what if your text contains a literal {? This could certainly trip up a naive parser. You can escape the problem, by escaping the {. This allows the parser to differentiate between a start of a substitution and a literal opening brace.
Often one uses the backslash \ to escape the following character. That would become \{ in our case. If you think this through you will notice a problem with this "solution". How to include a literal \? Luckily one can use the same method: escape it!
S := (Literal|Substitution)*
+Substitution := "{" Variable "}"
+Variable := Alpha+
+Alpha := 'a'|'b'|'c'|...|'z'|'A'|'B'|...|'Z'
+Literal := (Escaped|Allowed)+
+Escaped := "\\"|"\{"
+Allowed := <any character not an '\' or '{'>
+Data Structure
+The data structures that are involved in presenting the user with a template is have a common interface. They can be evaluated in a context to produce a string.
+Depending on your temperament you could differentiate between the following distinct templates:
+-
+
- Literal template +
- Substitution +
- Concatenation of sub-templates +
Literal Template
+When a literal template is evaluated, it ignores the context and produces the literal string it represents.
+Substitution
+When a substitution is evaluated, it looks up the string associated with the variable in the current context, and produces that result.
+Concatenation
+When a concatenation of templates is evaluated, each sub-templates is evaluated, and the produced results are strung together in order.
+Exercises
+-
+
- What is the signature of the context? What is a data structure that matches that signature? +
- Create different data structures to match the proposed templates. +
- What is the signature of the template parser? +
- Create the template parser. +
Aritmetic Expression
+In this chapter we will parse aritmetical expression. For us that will mean expressions involving integers, variables, addition, subtraction, multiplication and division. An example of such an expresion would be 5*2+1.
Grammar
+The grammar for our expression is as follows
+Expression ::= Term ('+'|'-') Expression | Term
+Term ::= Factor ('*'|'/') Term | Factor
+Factor ::= Constant | Variable | '(' Expression ')'
+Constant ::= Digit+
+Variable ::= Alpha+
+Digit ::= '0' | '1' | '2' | ... | '9'
+Alpha ::= 'a' | 'b' | ... | 'z | 'A' | 'B' | ... | 'Z'
+Data Structure
+A data structure that can represent an expression should cater for the following variants
+-
+
- Constant, containing the integer it represents +
- Variable, containing the name of a value in the context. +
- and the four operators, Addition, Subtraction, Multiplication, Division +
Exercises
+-
+
- Create a parser that can parse an expression. +
- Create an evaluate function that takes an expression and a context and returns the corresponding value. +
Solutions
+In this section you will find solutions some of the exercises of this workshop.
+The reason we included these answers is to be self-contained. We would much prefer if you would discuss your solutions with others and discuss the reasons why you decided to answer the questions in the manner you did.
+Prelimenaries
+Languages
+-
+
- The language of all the wrong ways of spelling bananan:
{"banan", "bananana", "ban", ...}
+ - I think the English languages is finite for it is not possible to concatenate words in the English languages and form valid words. For this reason I think that Dutch is an infinite language. +
EBNF
+-
+
- Using the natural number from the chapter we could have +
addition ::= number ("+" number)?
+Types
+-
+
- The types describes a function that accepts a string and returns a list of pairs of string and integer. An example of such functions would be a function that determines the frequency of all the words that occur in a text. +
S -> U -> T.
+
Style
+-
+
- Currently, I am very interested in the Kind programming language. It is a dependently typed, functional programming language. +
- I like a lot of styles. I am particular fond of logic programming. +
- I worked through the workshop various times. I have picked object oriented styles and functional styles. +
Parser
+-
+
tis the twentiest letter in the alphabet. Including the digits '0' through '9' we have 30 options. So base 30 is an option. Note that there are other options as well.
+- If using an object oriented programming language, I could implement the following interface. Each parser object should have a method called
parsethat accepts a string and returns a list of paris ofTandstring.
+ - I would introduce a result type that differentiates between the return values of a parser: failed, succesfull. +
- I would keep track of the the position in the original string the remaining input is from. This way I could provide some extra information when a parse failed. +
Workshop
+Some of the questions in this chapter ask for an implementation. See the example code accompanying this material for possible ways of implementing the succeed and fail parsers.
Succeed and Friends
+-
+
- The
succeed("Hello, World!")is a parser that does not consume the any input and always returns"Hello, World".
+ () -> string -> [()].
+
Character A
+-
+
string -> [(string, string)].
+- If my language of choices does not have a
startsWithfunction but does allow indexing into the string I would implement it by examining the 0th character of the string.
+
Any character
+-
+
string -> string -> [(string, string)]. At least this is what the examples show. It would be better if the examples would return the actual character. Then the signature would bechar -> string -> [(char, string)].
+characterA = character('A').
+
Parse a Token
+-
+
string -> string -> [(string, string)].
+
Parse a predicate
+-
+
(char -> boolean) -> string -> [(char, string)]
+character(target) = satisfy(actual => actual == target)
+- Why, of course. Thank you for asking. +
Parsing this or that
+-
+
- If I would want to accept more than one parser as an alternative, I would accept a list of parsers. The implementation would concatenate all the results from calling the given parsers on the input. +
Parsing this and that
+-
+
(string -> [(A, string)]) -> (string -> [(B, string)]) -> string -> [((A, B), string)]. Or with theparser Talias:parser A -> parser B -> parser (A, B).
+- If I would want to accept more than one parse as an string those parsers together, I would accept a list of parsers. I would implement a recursive call differentiating between an empty list and a non-empty list. +
Just All
+-
+
parser T -> parser T.
+
Transform a Result
+-
+
(A -> B) -> parser A -> parser B.
+- I would implement a recursive function, differentiating between an empty list and a non-empty list. +
Being Lazy
+-
+
(() -> parser T) -> parser T.
+- Yes, but this highly depends on your language. +
Parse Many Things
+-
+
parser T -> parser [T].
+(T, [T] -> [T].
+many1(parser) = map(combine, and(parser, many(parser))).
+
Utilities
+Ignore the Result
+-
+
parser T -> parser ().
+
Commit to the First Result
+-
+
parser T -> parser T.
+- The order in which influence the semantics of first. It changes from the longest match to the shortest match. +
Greedy Parsing
+-
+
parser T -> parser T.
+greedy1(parser) = map(combine, and(parser, greedy(parser))).
+
Consecutive Parsers
+-
+
[parser T] -> parser [T]. This forces all the parsers to return similar things.
+
One of the Following Parsers
+-
+
[parser T] -> parser T.
+
Whitespace
+-
+
parser ().
+parser T -> parser T.
+
Packing Parser
+-
+
parser L -> parser T -> parser R -> parser T.
+
Separating Parser
+-
+
parser string -> parser T -> parser [T].
+
Projects
+List of Things
+-
+
parser T -> parser [T].
+
Balanced Parenthesis
+-
+
parser Tree.
+
Template Language
+-
+
string -> T. A dictionary.
+parser ((string -> T) -> string). This signature assumes that a key is not present in the dictionary, the key is used as a default.
+
Arithmetic Expression
+++This paragraph intentionally is left blank
+
Sources
+The sources for this workshop and related files can be found at
+https://github.com/fifth-postulate/parser-combinators.
+Mediography
+There are a lot of resources on the internet about parser combinators. We have a curated list of resources on the wiki page accompanying this workshop.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/project/instructions.html b/guide/project/instructions.html
new file mode 100644
index 0000000..57e051c
--- /dev/null
+++ b/guide/project/instructions.html
@@ -0,0 +1,238 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Aritmetic Expression
+In this chapter we will parse aritmetical expression. For us that will mean expressions involving integers, variables, addition, subtraction, multiplication and division. An example of such an expresion would be 5*2+1.
Grammar
+The grammar for our expression is as follows
+Expression ::= Term ('+'|'-') Expression | Term
+Term ::= Factor ('*'|'/') Term | Factor
+Factor ::= Constant | Variable | '(' Expression ')'
+Constant ::= Digit+
+Variable ::= Alpha+
+Digit ::= '0' | '1' | '2' | ... | '9'
+Alpha ::= 'a' | 'b' | ... | 'z | 'A' | 'B' | ... | 'Z'
+Data Structure
+A data structure that can represent an expression should cater for the following variants
+-
+
- Constant, containing the integer it represents +
- Variable, containing the name of a value in the context. +
- and the four operators, Addition, Subtraction, Multiplication, Division +
Exercises
+-
+
- Create a parser that can parse an expression. +
- Create an evaluate function that takes an expression and a context and returns the corresponding value. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/project/list.html b/guide/project/list.html
new file mode 100644
index 0000000..b1a7538
--- /dev/null
+++ b/guide/project/list.html
@@ -0,0 +1,243 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ How to use it
+We have created a parser combinator framework that allows us to construct parsers by combining basic parsers into more elaborate parsers. But how do we use them?
+This section of the workshop presents to you various projects to solidify your understanding of parser combinators and how to use them. All projects follow more or less the following structure.
+-
+
- Identify what structure your want to end up with. +
- Create does structures in code. +
- Devise a grammar for how you want to describe those structures. +
- Create a parser for the grammar. +
All these steps and variants have real world counterparts. The most important one is step 1, what the structure do you want to work with. All steps follow from that.
+Because this is a workshop focusses on parser combinators, the realm that makes step 4 possible, the projects in this sections are providing steps 1 and 3 for you. You are still asked to implement the structures that you are going to work with, but that is mainly because you are free to choose your favorite programming language.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/project/parens.html b/guide/project/parens.html
new file mode 100644
index 0000000..26ea676
--- /dev/null
+++ b/guide/project/parens.html
@@ -0,0 +1,252 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ List of things
+The first project we are going to take on is to parse a list of elements. For demonstration purposes the element will be either a character 'A' or a character 'B'. This way we can focus on the the list part of parsing a list. Do make sure to accept a the element parser as a parameter. This makes it easy to change the element parser later on.
For the record, a list is denoted by:
+-
+
- An opening bracket
'['.
+ - A comma seperated list of elements. +
- A closing bracket
']'.
+
The list parser combinator accepts an element parser and returns a parser that can parse a list of elements.
Exercises
+-
+
- What is the signature of the
listparser combinator.
+ - Implement the
listparser combinator, making use of the combinators in your framework.
+ - Create a parser that parses either a character
'A'or a character'B'.
+ - Create a parser that parses a list of
'A's and'B's.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/project/template.html b/guide/project/template.html
new file mode 100644
index 0000000..a0b8f1c
--- /dev/null
+++ b/guide/project/template.html
@@ -0,0 +1,262 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Balanced parentheses
+The next project to grasp is parsing balanced parentheses. We will dispense with the content inside the parentheses and just focus on the structure of the parentheses.
+Grammar
+Below we will give a grammar for balanced parentheses:
+S := "(" S ")" S | ""
+Which in plain english is describing balanced parentheses as either
+-
+
- a opening parenthesis, followed by balanced parentheses, followed by a closing parenthesis, followed by balanced parentheses. +
- an empty string +
The empty string alternative serves as a base case. Without it, we would have no way to stop accepting parentheses.
+Structure
+We would like to define a data structure that reflects the structure of the balanced parentheses. A binary tree fits nicely.
+A binary tree has two alternatives. It is either a leaf that holds not no data. Or it is a node that contains two children, who both are trees. The children are called the left child and the right child. The left child represents the resultant tree from the first S in the production, the right child represents the resultant tree from the second S in the production.
Exercises
+-
+
- Represent a binary tree in code. +
- Which trees do the following inputs represent:
"()","(())()"and"()(()())()"?
+ - What is the signature of the parser that can parse trees? +
- Create a parser that can parse trees. +
Extra credit
+Formally balanced parentheses are a Dyck language. In this project we restricted our language to only use matching pairs of parentheses. But we could mix and match delimiters. For example, we could be interested in the language of properly matched pairs of parentheses () and brackets [].
How would the grammar change to allow different pairs of delimiters? How would the parser change? Can you generalize the parser of an arbitrary set of matching delimiters?
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/searcher.js b/guide/searcher.js
new file mode 100644
index 0000000..dc03e0a
--- /dev/null
+++ b/guide/searcher.js
@@ -0,0 +1,483 @@
+"use strict";
+window.search = window.search || {};
+(function search(search) {
+ // Search functionality
+ //
+ // You can use !hasFocus() to prevent keyhandling in your key
+ // event handlers while the user is typing their search.
+
+ if (!Mark || !elasticlunr) {
+ return;
+ }
+
+ //IE 11 Compatibility from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+ if (!String.prototype.startsWith) {
+ String.prototype.startsWith = function(search, pos) {
+ return this.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+ };
+ }
+
+ var search_wrap = document.getElementById('search-wrapper'),
+ searchbar = document.getElementById('searchbar'),
+ searchbar_outer = document.getElementById('searchbar-outer'),
+ searchresults = document.getElementById('searchresults'),
+ searchresults_outer = document.getElementById('searchresults-outer'),
+ searchresults_header = document.getElementById('searchresults-header'),
+ searchicon = document.getElementById('search-toggle'),
+ content = document.getElementById('content'),
+
+ searchindex = null,
+ doc_urls = [],
+ results_options = {
+ teaser_word_count: 30,
+ limit_results: 30,
+ },
+ search_options = {
+ bool: "AND",
+ expand: true,
+ fields: {
+ title: {boost: 1},
+ body: {boost: 1},
+ breadcrumbs: {boost: 0}
+ }
+ },
+ mark_exclude = [],
+ marker = new Mark(content),
+ current_searchterm = "",
+ URL_SEARCH_PARAM = 'search',
+ URL_MARK_PARAM = 'highlight',
+ teaser_count = 0,
+
+ SEARCH_HOTKEY_KEYCODE = 83,
+ ESCAPE_KEYCODE = 27,
+ DOWN_KEYCODE = 40,
+ UP_KEYCODE = 38,
+ SELECT_KEYCODE = 13;
+
+ function hasFocus() {
+ return searchbar === document.activeElement;
+ }
+
+ function removeChildren(elem) {
+ while (elem.firstChild) {
+ elem.removeChild(elem.firstChild);
+ }
+ }
+
+ // Helper to parse a url into its building blocks.
+ function parseURL(url) {
+ var a = document.createElement('a');
+ a.href = url;
+ return {
+ source: url,
+ protocol: a.protocol.replace(':',''),
+ host: a.hostname,
+ port: a.port,
+ params: (function(){
+ var ret = {};
+ var seg = a.search.replace(/^\?/,'').split('&');
+ var len = seg.length, i = 0, s;
+ for (;i
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Template Language
+Sometimes you want a template that can be specialized with a certain context. For example, the template "Hello, {subject}!" evaluated in the context subject => "World" should produce `"Hello, World!".
Grammar
+The grammar for this template language is a little subtle. In broad strokes there are two different parts. Literal text, like "Hello, " and "!" from our example. And substitutions, like "{subject}". Substitutions are formed by wrapping an identifier with a matching pair of braces.
Literal text seems straightforward. But what if your text contains a literal {? This could certainly trip up a naive parser. You can escape the problem, by escaping the {. This allows the parser to differentiate between a start of a substitution and a literal opening brace.
Often one uses the backslash \ to escape the following character. That would become \{ in our case. If you think this through you will notice a problem with this "solution". How to include a literal \? Luckily one can use the same method: escape it!
S := (Literal|Substitution)*
+Substitution := "{" Variable "}"
+Variable := Alpha+
+Alpha := 'a'|'b'|'c'|...|'z'|'A'|'B'|...|'Z'
+Literal := (Escaped|Allowed)+
+Escaped := "\\"|"\{"
+Allowed := <any character not an '\' or '{'>
+Data Structure
+The data structures that are involved in presenting the user with a template is have a common interface. They can be evaluated in a context to produce a string.
+Depending on your temperament you could differentiate between the following distinct templates:
+-
+
- Literal template +
- Substitution +
- Concatenation of sub-templates +
Literal Template
+When a literal template is evaluated, it ignores the context and produces the literal string it represents.
+Substitution
+When a substitution is evaluated, it looks up the string associated with the variable in the current context, and produces that result.
+Concatenation
+When a concatenation of templates is evaluated, each sub-templates is evaluated, and the produced results are strung together in order.
+Exercises
+-
+
- What is the signature of the context? What is a data structure that matches that signature? +
- Create different data structures to match the proposed templates. +
- What is the signature of the template parser? +
- Create the template parser. +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/tomorrow-night.css b/guide/tomorrow-night.css
new file mode 100644
index 0000000..81fe276
--- /dev/null
+++ b/guide/tomorrow-night.css
@@ -0,0 +1,102 @@
+/* Tomorrow Night Theme */
+/* https://github.com/jmblog/color-themes-for-highlightjs */
+/* Original theme - https://github.com/chriskempson/tomorrow-theme */
+/* https://github.com/jmblog/color-themes-for-highlightjs */
+
+/* Tomorrow Comment */
+.hljs-comment {
+ color: #969896;
+}
+
+/* Tomorrow Red */
+.hljs-variable,
+.hljs-attribute,
+.hljs-tag,
+.hljs-regexp,
+.ruby .hljs-constant,
+.xml .hljs-tag .hljs-title,
+.xml .hljs-pi,
+.xml .hljs-doctype,
+.html .hljs-doctype,
+.css .hljs-id,
+.css .hljs-class,
+.css .hljs-pseudo {
+ color: #cc6666;
+}
+
+/* Tomorrow Orange */
+.hljs-number,
+.hljs-preprocessor,
+.hljs-pragma,
+.hljs-built_in,
+.hljs-literal,
+.hljs-params,
+.hljs-constant {
+ color: #de935f;
+}
+
+/* Tomorrow Yellow */
+.ruby .hljs-class .hljs-title,
+.css .hljs-rule .hljs-attribute {
+ color: #f0c674;
+}
+
+/* Tomorrow Green */
+.hljs-string,
+.hljs-value,
+.hljs-inheritance,
+.hljs-header,
+.hljs-name,
+.ruby .hljs-symbol,
+.xml .hljs-cdata {
+ color: #b5bd68;
+}
+
+/* Tomorrow Aqua */
+.hljs-title,
+.css .hljs-hexcolor {
+ color: #8abeb7;
+}
+
+/* Tomorrow Blue */
+.hljs-function,
+.python .hljs-decorator,
+.python .hljs-title,
+.ruby .hljs-function .hljs-title,
+.ruby .hljs-title .hljs-keyword,
+.perl .hljs-sub,
+.javascript .hljs-title,
+.coffeescript .hljs-title {
+ color: #81a2be;
+}
+
+/* Tomorrow Purple */
+.hljs-keyword,
+.javascript .hljs-function {
+ color: #b294bb;
+}
+
+.hljs {
+ display: block;
+ overflow-x: auto;
+ background: #1d1f21;
+ color: #c5c8c6;
+}
+
+.coffeescript .javascript,
+.javascript .xml,
+.tex .hljs-formula,
+.xml .javascript,
+.xml .vbscript,
+.xml .css,
+.xml .hljs-cdata {
+ opacity: 0.5;
+}
+
+.hljs-addition {
+ color: #718c00;
+}
+
+.hljs-deletion {
+ color: #c82829;
+}
diff --git a/guide/utilities/consecutive.html b/guide/utilities/consecutive.html
new file mode 100644
index 0000000..0c24809
--- /dev/null
+++ b/guide/utilities/consecutive.html
@@ -0,0 +1,245 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parser Combinators
+Practical Parsing for Pragmatic Programmers
+You are looking at the guide accompanying a workshop about parser combinators.
+Parser combinators is an interesting topic that allows a developer to parse complex input into rich data-structures in a modular fashion. This form of parsing is possible in any language that supports higher order functions. Luckily that includes a lot of languages, like Java, Python, JavaScript and many more.
+We believe in learning by doing, so you can expect to be asked to open your favourite editor or integrated development environment and gain first-hand practical experience with parser combinators, by following along this guide. Exercises along the way help cement your new found knowledge making parser combinators a valuable tool in your toolkit.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/utilities/first.html b/guide/utilities/first.html
new file mode 100644
index 0000000..b4866cc
--- /dev/null
+++ b/guide/utilities/first.html
@@ -0,0 +1,236 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Consecutive parsers
+The and parser is a happy little parser combinator. It takes two parsers and runs them consecutively, feeding the remaining input of the first parse into the second parser, returning the pair of results.
The only problem with the and parser is that it only accepts two parsers. Often you find yourself wanting to parser any number of parsers consecutively. For example, in order to parse a pair of a name and an integer, you would have to parse the following structures
-
+
- Parse a character
'('.
+ - Parse any name. +
- Parse a character
','.
+ - Parse any integer. +
- Parse a character
')'.
+
And combine the result of the name parser and the integer parser into a pair of the two.
+The consecutive parser will be build for this task. It accepts a sequence of parsers and a way to combine the intermediate results into a final result.
Exercises
+-
+
- What is the signature of the
consecutiveparser? Depending on the language you are working with, this can be a tricky question. Don't be afraid to sacrifice generality for practicality.
+ - Implement the
consecutiveparser.
+ - Use the
consecutiveparser to parse the tuple from the example.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/utilities/greedy.html b/guide/utilities/greedy.html
new file mode 100644
index 0000000..2e1ac34
--- /dev/null
+++ b/guide/utilities/greedy.html
@@ -0,0 +1,236 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Commit to the first result
+Sometimes you are not interested in all possible ways of parsing input into a data structure. You are happy with the first successful parse.
+The first parser does precisely that. Instead of returning all the possible parsing of an input, it only returns the first.
Exercises
+-
+
- What is the signature of the
firstparser?
+ - Implement the
firstparser.
+ - How does the order of alternatives influence the semantics of
first?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/utilities/ignore.html b/guide/utilities/ignore.html
new file mode 100644
index 0000000..f6a5158
--- /dev/null
+++ b/guide/utilities/ignore.html
@@ -0,0 +1,235 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Greedy parsing
+There are times that you just want to be greedy. Take what every you can get and continue.
+The greedy parser is your friend. It will execute the task above for you.
Exercises
+-
+
- What is the signature of the
greedyparser?
+ - Implement the
greedyparser. Try to express it as a combination of other parsers.
+ - The companion to
manyismany1. Implement agreed1parser.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/utilities/oneof.html b/guide/utilities/oneof.html
new file mode 100644
index 0000000..f723f95
--- /dev/null
+++ b/guide/utilities/oneof.html
@@ -0,0 +1,241 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Ignore the result
+Sometimes you are not that interested in the result of a parser. For example, if you are parsing a tuple at one point you need to parse the character '('. But you don't really need the actual character. You just want to make sure that the parse succeeds.
This is where the ignore parser combinator comes in. It accepts a parser p and parses the same input as p would do. The only difference is that it ignores the resulting value. Instead it returns a dummy value.
Exercises
+-
+
- What is the signature of the
ignoreparser combinator?
+ - Implement the
ignoreparser.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/utilities/pack.html b/guide/utilities/pack.html
new file mode 100644
index 0000000..79cc127
--- /dev/null
+++ b/guide/utilities/pack.html
@@ -0,0 +1,237 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Oneof the following parsers
+What consecutive is to and, oneOf is to or.
Just like the case for the and parser combinator, the or parser combinator only accepts two parsers. Often there a multiple alternatives that you want to combine. For example, when you are creating a full-blown programming language, an expression could be a number of things. Among the options there would be
-
+
- an assignment +
- an arithmetical expression +
- a logical expression +
- a ternary expression +
Exercises
+-
+
- What is the signature of the
oneOfparser combinator?
+ - Implement the
oneOfparser combinator.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/utilities/separating.html b/guide/utilities/separating.html
new file mode 100644
index 0000000..8aa3fbb
--- /dev/null
+++ b/guide/utilities/separating.html
@@ -0,0 +1,235 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Packing parser
+Often we want to parse some data that is surrounded with some structure. For example, some programming languages delineate blocks of code by a matched pair of curly braces. A literal list of items starts with an opening bracket and is finished with a closing bracket.
+The pack parser combinator accepts three parser. It "packs" the second parser in between the opening parser and the closing parser.
Exercises
+-
+
- What is the signature of the
packparser combinator?
+ - Implement the
packparser combinator.
+ - Define a parser combinator
parenthesizedthat packs a parser with a matching pair of parenthesis.
+ - Simiarly define a
bracketedparser.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/utilities/whitespace.html b/guide/utilities/whitespace.html
new file mode 100644
index 0000000..2f979f4
--- /dev/null
+++ b/guide/utilities/whitespace.html
@@ -0,0 +1,254 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Separating parser
+Lists, or other repetitive structures, often have some sort of separator that distinguishes between where one item stops and the next begins. In the case of a list of integers, a ',' would be used as separator. In some programming languages the ';' is used for similar purpose.
The separatedBy parser combinator will be used in this situation. It accepts two parsers. One parser will parse the separator, the other the structure that is separated.
Exercises
+-
+
- What is the signature of the
separatedByparser combinator?
+ - Implement the
separatedByparser combinator.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/utilities/why.html b/guide/utilities/why.html
new file mode 100644
index 0000000..693f9ee
--- /dev/null
+++ b/guide/utilities/why.html
@@ -0,0 +1,235 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Whitespace
+When parsing certain input, we are often not interested in the whitespace that is present. For example, the following expression should all result in the same data structure.
+-
+
5*2+1
+5*2 + 1
+5 * 2 + 1
+5 * 2 + 1
+
What is whitespace?
+Depending on your use case whitespace could mean different things. It could be just a space, just a tab, just a newline or any combination of the mentioned, and possibly other, characters.
+But once a choice is made, one could create a parser for it. We will call this parser whitespace.
Ignore whitespace prefix
+If whitespace is not important for the input that you are parsing, it can be ignored. A usefull parser combinator in this case is the sp parser combinator. It accepts a parser p and parses everything that p parses, even if it is preceded by any amount of whitespace.
| input | character('A') | sp(character('A')) |
|---|---|---|
| "ABC" | [('A', "BC")] | [('A', "BC")] |
| " ABC" | [] | [('A', "BC")] |
| " ABC" | [] | [('A', "BC")] |
The above table provides an example of the sp parser combinator. Where character('A') would fail if the string starts with any number of whitespace, the sp(character('A')) ignores the whitespace prefix and returns the wanted result.
Exercises
+-
+
- What is the signature of the
whitespaceparser?
+ - Implement the
whitespaceparser.
+ - What is the signature of the
spparser combinator?
+ - Implement the
spparser combinator.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/A.html b/guide/work/A.html
new file mode 100644
index 0000000..d01371a
--- /dev/null
+++ b/guide/work/A.html
@@ -0,0 +1,252 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ It does not end here
+We have created a number of basic parsers and combinators for them. But it does not end here.
+Not all combinators that could come in handy are already defined. Some of them are presented in the utilities section, others are only discovered after using the parser combinator framework.
+If you want to try your hand on creating other parser combinators that serve a certain purpose, stick around.
+If instead you would like to use them to parse an interesting structure, take a look at the projects section.
+Time to spread your wings
+In the preceding chapters there was pseudo code that provided hints on how to implement certain parser.
+Now is the time to spread your wings and take to the skies without our hints. You will not find pseudo code anymore. Partly because it allows you to cement the knowledge obtained from the workshop. Partly because the pseudo code is for all intents and purposes indistinct from an actual implementation.
+ +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/andThen.html b/guide/work/andThen.html
new file mode 100644
index 0000000..dccd128
--- /dev/null
+++ b/guide/work/andThen.html
@@ -0,0 +1,243 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ character
+
+
+
+
+
+
+ character A
+One of the simplest parsers that depends on any input to parse is a parser that succeeds if the input starts with the character 'A'.
For example, parserA is a parser that succeeds if the input starts with the character 'A'. Below we summarize our expectation for parserA.
| input | parserA() |
|---|---|
| "ABC" | [("A", "BC")] |
| "BC" | [] |
| "aBC" | [] |
Implementation
+Below you can find some pseudo code for the parserA function.
The implementation of the parserA function relies on the capabilities of your language to work with string. Here we assume that your language can tell you when a certain string start with an other character. See the exercises for some pointers on how to solve the problem if your language does not provide such functionality.
parserA() =
+ input => if input.startsWith('A') then
+ [("A", input[1:])]
+ else
+ []
+Here input[1:] means the rest of the input starting with the second character, since our lists indices are zero-based. People familiar with Python will feel comfortable with this notation.
Exercises
+-
+
- What is the type of
parserA?
+ - Implement
parserAin your favorite language. From now on, implement will also mean verify your implementation.
+ - If your language does not have a
startsWithfunction forstringhow would you implement it? What tools are provided for working withstring?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/character.html b/guide/work/character.html
new file mode 100644
index 0000000..ce763c8
--- /dev/null
+++ b/guide/work/character.html
@@ -0,0 +1,253 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parse this and then that
+What we are going to combine in this chapter is two parsers with the intent of parsing with the first parser and then parse the remaining input with the second parser.
+Let's assume again that we have parser A = character('A') and B = character('B'). The expectations of the and combinator are
| input | and(A, B) |
|---|---|
| "ABC" | [(('A', 'B'), "C")] |
| "ABCD" | [(('A', 'B'), "CD")] |
| "aBC" | [] |
Note that when the parser accepts its input, it returns a pair as a result. In our example it is a pair of characters, but it depends on the parser that we are combining.
+Exercises
+-
+
- What is the type of the
andcombinator?
+ - Create the
andcombinator. Depending on your language it would be better to return a list of results instead of a pair.
+ - If you wanted to combine more than two consecutive parsers, how would you implement that? +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/just.html b/guide/work/just.html
new file mode 100644
index 0000000..29f0c61
--- /dev/null
+++ b/guide/work/just.html
@@ -0,0 +1,247 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Any character
+The work we have done for the parsing of a character 'A', could also be done for other characters.
One could copy the implementation of parserA and change it into a parserB, a parserC or a parser^ for that matter.
+Instead we will define a character function that accepts the character to parse as an argument.
+That is, character is a parser that accepts a character as argument and returns a parser that succeeds if the input starts with that character. Below we summarize our expectation for character.
+| input | char | character(char) |
|---|---|---|
| "ABC" | 'A' | [("A", "BC")] |
| "BC" | 'A' | [] |
| "aBC" | 'A' | [] |
| "aBC" | 'a' | [("a", "BC")] |
Implementation
+The implementation of the character function has a lot in common with parserA.
character(char) =
+ input => if input.startsWith(char) then
+ [(char.toString(), input[1:])]
+ else
+ []
+Exercises
+-
+
- What is the type of the
characterfunction?
+ - Implement the
characterfunction.
+ - Implement
parserAin terms ofcharacter. This is a common practice in this workshop. When you notice a common pattern in parsers, generalize it.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/lazy.html b/guide/work/lazy.html
new file mode 100644
index 0000000..73dd45b
--- /dev/null
+++ b/guide/work/lazy.html
@@ -0,0 +1,271 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Just all
+Some parsers accept only a part of their input. This is generally fine for intermediate parsers, but you generally want to accept the entire input for top-level parsers.
+The just parser does just that. It accepts a parsers and will only succeed when the remaining input is empty.
| input | just(character('A')) |
|---|---|
| "ABC" | [] |
| "A" | [('A', "")] |
| "aBC" | [] |
Implementation
+Once we parsed our input, we need to remove the results that did not consume the entire input.
+just(p) =
+ input => filter ((r, rest) => rest == "") (p input)
+Here filter is a function that accepts a list and keeps all the elements in the list that satisfy the predicate.
Exercises
+-
+
- What is the type of the
justcombinator?
+ - Implement the
justcombinator.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/many.html b/guide/work/many.html
new file mode 100644
index 0000000..c55d580
--- /dev/null
+++ b/guide/work/many.html
@@ -0,0 +1,266 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Being lazy
+Up until now, our parser combinators are not recursive. Every combinator accepts one or more parsers and use combine them into a more complex parser.
+What we are about to do is define parser combinators that are defined in terms of themselves.
+This can be problematic. The problem is that our combinators have to return a parser. They can't predict how deeply nested a parser needs to be called. Take a look at the following grammar.
+A ::= A | "a";
+This grammar accepts any number of the character 'a'. If we naively write a parser we would might write the following.
+A =
+ or(A(), character('a'))
+The thoughts are: Our parser A is either
-
+
- our parser
A
+ - a character
'a'.
+
The first part is problematic, because when it calls the A parser it will go down an infinite path. If we would try to call A we would need to repeatedly call A without bounds.
-
+
A()
+or(A(), character('a'))
+or(or(A(), character('a')), character('a'))
+or(or(or(A(), character('a')), character('a')), character('a'))
+or(or(or(or(A(), character('a')), character('a')), character('a')), character('a'))
+- ... +
Solution
+One way to solve this problem is to delay the call to yourself. What we instead would like to say is, when it is time to parse some input I will produce a the parser that is going to do the parsing. So there are two ingredients: a parser producer, and a combinator that works in the above manner.
+Parser producer
+We could use a function that accepts a dummy value as a producer. It's signature would be () -> string -> [(T, string)] or, using the parser alias, () -> parser T.
One could implement a producer with an anonymous function. Say we have a parser A, a producer of A could be implemented as
_ => A
+Here we use an underscore _ to signify that we are not interested in the actual argument.
combinator
+The last ingredient is a combinator that accepts a producer for a parser and returns a parser that uses it.
+lazy(p) =
+ input => (p ())(input)
+This might be hard to read. The first parenthesized part (p ()) calls the producer. It will return a parser. That parser is then called with the input to return the parse result.
Exercises
+-
+
- What is the type of the
lazycombinator?
+ - Implement the
lazycombinator.
+ - Is it possible not to use recursion? +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/map.html b/guide/work/map.html
new file mode 100644
index 0000000..88c4628
--- /dev/null
+++ b/guide/work/map.html
@@ -0,0 +1,247 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parse many things
+Parsing a single character, or a single character and then an other, will only get you so far. Sometimes you want to accept many things. This chapter introduces a parser combinator that does exactly this.
+The many combinator accepts a parser p and returns a parser that accepts input precisely when p succeeds any number of times.
| Input | many(character('A')) |
|---|---|
| "" | [([], "")] |
| "A" | [(['A'], ""), ([], "A")] |
| "AA" | [(['A', 'A'], ""), (['A'], "A"), ([], "AA")] |
| "aAA" | [([], "aAA")] |
This is the first time that a parser returns multiple possible results. The different results correspond with the different options. Any number of times include
+-
+
- zero times +
- one time +
- two times +
- three times +
- etcetera +
This can be seen in our results. In the example with the input "AA" the parser many(character('A')) can parse
-
+
- Two 'A's, with no remaining input. +
- One 'A', with remaining input "A". +
- Zero 'A's, with remaining input "AA". +
All these results are returned, in the order from most input consumed to least input consumed.
+Implementation
+The implementation of the many combinator is defined in terms of itself. The lazy combinator allows a call to the parser you are defining without blowing the call stack. Our pseudo-code had this build in 😁.
many(p) =
+ or(map(combine, and(p, many(p))), succeed([]))
+We are relying on combinators from earlier chapters. Because of this the implementation is not as exact, leaving some ideas to be explored.
+Exercises
+-
+
- What is the type the
manycombinator?
+ - What is the type of the
combinefunction used to map the result of parserpand thenmany(p)?
+ - Implement the
combinefunction.
+ - Implement the
manycombinator. Don't forget to be lazy.
+ - The
manycombinator parses zero or more items. Create a combinatormany1that parser one or more items.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/orThat.html b/guide/work/orThat.html
new file mode 100644
index 0000000..c2d2c06
--- /dev/null
+++ b/guide/work/orThat.html
@@ -0,0 +1,264 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Transform a result
+Sometimes you end up with a parser for a certain structure A, but you want to have a parser for an other structure B, which you now how to make from a structure A. For example, you have a parser that accepts a character '7', but you want to have a parser that accepts the corresponding number 7.
The map parser combinator will help you out in this situation. It will accept a parser string -> [(A, string)] and turn is into a parser string -> [(B, string)]. For this you need to provide a transform function A -> B.
| Input | parser | transform | map(transform, parser) |
|---|---|---|---|
| "123" | satisfy(isDigit) | toInt | [(1, "23")] |
| "ABC" | satisfy(isDigit) | toInt | [] |
Implementation
+For the map combinator we rely on the a function that can transform a list in the same way. We only need to change the first arguments of the tuples in our result list.
map(f, parser) =
+ input =>
+ listMap ((r, rest) => (f(r), rest)) (parser input)
+Exercises
+-
+
- What is the type of
map?
+ - Implement the
mapcombinator.
+ - If your languages does not have a
listMap, how would you implement that?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/predicate.html b/guide/work/predicate.html
new file mode 100644
index 0000000..194587b
--- /dev/null
+++ b/guide/work/predicate.html
@@ -0,0 +1,263 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parse this or that
+With some basic parsers under our belt, we can start looking at a combinator. A combinator is a function that combines simpler things into a more complex thing. In our case, it combines simpler parsers into a more complex parser.
+Sometimes you find yourself at a cross road. Either we want to parse a number, or we want to parse a variable name. If we have simpler parser that can parse a number and another parser that can parse a variable name, we can combine them into a more complex parser that could parse either of the two.
+Assuming we have parsers A = character('A') and B = character('B'), below you find a table of our expectations for the or combinator.
| input | or(A, B) |
|---|---|
| "ABC" | [("A", "BC")] |
| "BAC" | [("B", "AC")] |
| "aBC" | [] |
Signature
+Remember, the type of a parser is string -> [(T, string)] where T is a type variable representing the structure that is returned for this parser.
A combinator is a higher order function. I.e.
+++a function that does at least one of the following:
++
+- takes one or more functions as arguments,
+- returns a function as its result.
+
In our case it does both. We accept two parsers, which themselves are functions and in turn returns a parser, again a function. The type of or is
or : (string -> [(T, string)]) -> (string -> [(T, string)]) -> (string -> [(T, string)])
+or, if we abbreviate string -> [(T, string)] to parser T, it could read
or : parser T -> parser T -> parser T
+I.e. or is a function that accepts two parsers and returns a third.
Implementation
+When we think about an implementation of or we need to consider the two parsers that are used to construct the result parser. If we have a parser A that produces output resultA on input I, and a parser B that produces output resultB on input I, parser or(A, B) should produce the concatenation of resultA and resultB on input I.
or(A, B) =
+ input => A(input).concat(B(input))
+Exercises
+-
+
- Implement the
orcombinator.
+ - If you want choose between multiple options to parse, how would you implement
orin that case?
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/succeed.html b/guide/work/succeed.html
new file mode 100644
index 0000000..4cd6f17
--- /dev/null
+++ b/guide/work/succeed.html
@@ -0,0 +1,269 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parse a Predicate
+Just like we generalized characterA into character, we are going to generalize character into something we will call satisfy.
The satisfy function will accept a predicate, and returns a parser that will succeed when the input starts with a character that fulfills the predicate. A predicate is a function that accepts a character and returns a boolean.
char -> boolean
+As an example how we would want to use the satisfy function, we could write the following equation.
characterA == satisfy(c => c == 'A')
+Here we have introduced the notation for a function without a name: c => c == 'A'. This notation can be read as follows
-
+
- The part before
=>names the parameter of the function.
+ - The part after
=>is the body of the function.
+
In our example we have denoted a function that accepts a character c and returns true when that character equals 'A'.
Our expectations for the satisfy function are
| input | predicate | satisfy(predicate) |
|---|---|---|
| "ABC" | c => c == 'A' | [('A', "BC")] |
| "aBC" | c => c == 'a' | [('a', "BC")] |
| "ABC" | c => c == '!' | [] |
Implementation
+The satisfy function is not that different from either the character or token functions. The difference are the clause in the if-expression, and how we return our input.
satisfy(predicate) =
+ input => if predicate(input[0]) then
+ [(input[0], input[1:])]
+ else
+ []
+Exercises
+-
+
- What is the type of the
satisfyfunction?
+ - Implement
satisfy.
+ - Implement the
characterfunction in terms of thesatisfyfunction.
+ - Does your implementation work correctly when the input is the empty string? +
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/guide/work/token.html b/guide/work/token.html
new file mode 100644
index 0000000..f8415ec
--- /dev/null
+++ b/guide/work/token.html
@@ -0,0 +1,252 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Succeed and Friends
+So we have established a signature for our parser
+string -> [(T, string)]
+In other words: a parser is a function that accepts a string and returns a list of pairs. Each pair in the list is a combination of a value of type T and a string, which is the remaining input.
What would the simplest parser be?
+succeed
+One of the simplest parser would not bother with the input and instead return a value we provide.
+Thinking hard about the signature we could come up with
+T -> string -> [(T, string)]
+Let's break this signature down. There are some arrows involved so this is a function. The part after the first arrow is the same as the signature for our parser.
+So this is a function that accepts an argument of type T and returns the parser.
Below you can find some examples of how we would use succeed
+| input | succeed(37) |
|---|---|
| "whatever" | [(37, "whatever")] |
| "input" | [(37, "input")] |
| "ABC" | [(37, "ABC")] |
With succeed under our belt, we can go on to an other simple parser. One could argue that it is even simpler then succeed.
fail
+Some parsers fail to turn the input into a meaningfull structure. fail is the quintessential example. It fails on any input, whatever that is.
Here are some examples.
+| input | fail() |
|---|---|
| "whatever" | [] |
| "input | [] |
| "ABC" | [] |
Why these parsers?
+The succeed and fail parser seem very simple. Certainly they can not have practical use, other then introducing you to the idea of parsers.
Although succeed and fail are simple parsers, the are powerful none the less. It can seem that these parsers would not amount to anything, but within a few chapters they allow you to wield tremendous power.
So don't dismiss them just yet, they will come in handy rather sooner then later.
+Exercises
+-
+
- Provide your own example to cement your understanding of
succeed. Discuss your example with somebody.
+ - Implement the
succeedfunction in your language of choice. You will have to choose how to represent functions.
+ - Make sure you are confident your implementation works as expected. You could write tests, use a read-eval-print-loop (REPL) or any other means to check. +
- What is the type of the
failfunction?
+ - Implement
failand test your implementation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/index.html b/index.html
new file mode 100644
index 0000000..3c01b39
--- /dev/null
+++ b/index.html
@@ -0,0 +1,19 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Parse a token
+Instead of parsing a single character, we could try to parse a word or token.
+Assume we want to know if an input starts with a name, for example "Geert". But you yourself could be interested in a different name. So we would like to create a function that accepts a token and returns a parser that accepts input whenever it starts with that token.
Below you find some expectations we have for the token parser.
| input | t | token(t) |
|---|---|---|
| "Geert is a father" | "Geert" | [("Geert", " is a father")] |
| "if a == 1 then 1 else 2" | "if" | [("if", " a == 1 then 1 else 2")] |
| "Daan is a father" | "Geert" | [] |
| "while a == 1 do nothing" | "if" | [] |
Implementation
+The implementation of token is very similar to the character implementation. This is in part because we reuse our startsWith function. It magically accepts both characters and strings! Real languages might not be so flexible.
token(t) =
+ input => if input.startsWith(t) then
+ [(t, input[t.size:])]
+ else
+ []
+We use our Python inspired notation input[n:] to snip of the the length of the token t from our input.
Exercises
+-
+
- What is the type of the
tokenfunction?
+ - Implement
token.
+
Parser Combinators
+Practical Parsing for the Pragmatic Programmer
++ This webpage accompanies the workshop Parser Combinators. +
-
+
- Material +
- Guide +
- Presentations +
":M.tabReplace?t.replace(/\t/g,M.tabReplace):""}):e}function d(e){var t,r,a,n,i,s,c,o,l,d,u=function(e){var t,r,a,n,i=e.className+" ";if(i+=e.parentNode?e.parentNode.className:"",r=p.exec(i)){var s=A(r[1]);return s||(console.warn(E.replace("{}",r[1])),console.warn("Falling back to no-highlight mode for this block.",e)),s?r[1]:"no-highlight"}for(t=0,a=(i=i.split(/\s+/)).length;t
"+i(e.message+"",!0)+"";throw e}}var u={newline:/^\n+/,code:/^( {4}[^\n]+\n*)+/,fences:c,hr:/^( *[-*_]){3,} *(?:\n+|$)/,heading:/^ *(#{1,6}) *([^\n]+?) *#* *(?:\n+|$)/,nptable:c,lheading:/^([^\n]+)\n *(=|-){2,} *(?:\n+|$)/,blockquote:/^( *>[^\n]+(\n[^\n]+)*\n*)+/,list:/^( *)(bull) [\s\S]+?(?:hr|\n{2,}(?! )(?!\1bull )\n*|\s*$)/,html:/^ *(?:comment|closed|closing) *(?:\n{2,}|\s*$)/,def:/^ *\[([^\]]+)\]: *]+)>?(?: +["(]([^\n]+)[")])? *(?:\n+|$)/,table:c,paragraph:/^((?:[^\n]+\n?(?!hr|heading|lheading|blockquote|tag|def))+)\n*/,text:/^[^\n]+/};u.bullet=/(?:[*+-]|\d+\.)/,u.item=/^( *)(bull) [^\n]*(?:\n(?!\1bull )[^\n]*)*/,u.item=o(u.item,"gm")(/bull/g,u.bullet)(),u.list=o(u.list)(/bull/g,u.bullet)("hr",/\n+(?=(?: *[-*_]){3,} *(?:\n+|$))/)(),u._tag="(?!(?:a|em|strong|small|s|cite|q|dfn|abbr|data|time|code|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo|span|br|wbr|ins|del|img)\\b)\\w+(?!:/|[^\\w\\s@]*@)\\b",u.html=o(u.html)("comment",//)("closed",/<(tag)[\s\S]+?<\/\1>/)("closing",/
'+(a?e:i(e,!0))+"\n"+(a?e:i(e,!0))+"\n\n"+e+"\n"},s.prototype.html=function(e){return e},s.prototype.heading=function(e,t,a){return"
\n"},s.prototype.list=function(e,t){var a=t?"ol":"ul";return"<"+a+">\n"+e+"\n"},s.prototype.listitem=function(e){return"
"+e+"
\n"},s.prototype.table=function(e,t){return""+e+""},s.prototype.br=function(){return""},s.prototype.del=function(e){return"
\s*<\/p>/g,""),i.innerHTML.replace(/\n\r?$/,"")}},{marked:2}],13:[function(e,t,a){function r(){}t.exports=r,r.prototype.XMLHttpRequest=XMLHttpRequest,r.prototype.getHTMLElement=function(){return document.getElementsByTagName("html")[0]},r.prototype.getBodyElement=function(){return document.body},r.prototype.getElementById=function(e){return document.getElementById(e)},r.prototype.getLocationHash=function(){return window.location.hash},r.prototype.setLocationHash=function(e){"function"==typeof window.history.replaceState&&"null"!==document.origin?window.history.replaceState(void 0,void 0,e):window.location.hash=e}},{}],14:[function(e,t,a){for(var r=function(){var e={};return function(t){var a="object"==typeof window&&window||"object"==typeof self&&self;"undefined"!=typeof e?t(e):a&&(a.hljs=t({}),"function"==typeof define&&define.amd&&define([],function(){return a.hljs}))}(function(e){function t(e){return e.replace(/[&<>]/gm,function(e){return M[e]})}function a(e){return e.nodeName.toLowerCase()}function r(e,t){var a=e&&e.exec(t);return a&&0===a.index}function s(e){return k.test(e)}function n(e){var t,a,r,n,i=e.className+" ";if(i+=e.parentNode?e.parentNode.className:"",a=w.exec(i))return j(a[1])?a[1]:"no-highlight";for(i=i.split(/\s+/),t=0,r=i.length;t Keyboard shortcuts
+
":N.tabReplace?t.replace(/\t/g,N.tabReplace):void 0}):e}function h(e,t,a){var r=t?C[t]:a,s=[e.trim()];return e.match(/\bhljs\b/)||s.push("hljs"),e.indexOf(r)===-1&&s.push(r),s.join(" ").trim()}function p(e){var t,a,r,i,c,p=n(e);s(p)||(N.useBR?(t=document.createElementNS("http://www.w3.org/1999/xhtml","div"),t.innerHTML=e.innerHTML.replace(/\n/g,"").replace(/\n \n\n\n\n\n \n \n \n \n\n \n Notes for current slide\n \n \n \n Notes for next slide\n \n \n \n\n Paused\n \n\n \n'}},{}],23:[function(e,t,a){function r(e,t){var a=this;a.events=e,a.slideshow=t,a.ratio=s(t),a.dimensions=n(a.ratio),a.events.on("propertiesChanged",function(e){e.hasOwnProperty("ratio")&&(a.ratio=s(t),a.dimensions=n(a.ratio))})}function s(e){var t,a=e.getRatio().split(":");return t={width:parseInt(a[0],10),height:parseInt(a[1],10)},t.ratio=t.width/t.height,t}function n(e){return{width:Math.floor(i/o*e.ratio),height:l}}var i=908,l=681,o=i/l;t.exports=r,r.prototype.scaleToFit=function(e,t){var a,r,s,n,i,l=this,o=t.clientHeight,c=t.clientWidth,d=l.ratio,m=l.dimensions;a=c/d.width>o/d.height?o/m.height:c/m.width,r=m.width*a,s=m.height*a,n=(c-r)/2,i=(o-s)/2,e.style["-webkit-transform"]="scale("+a+")",e.style.MozTransform="scale("+a+")",e.style.left=Math.max(n,0)+"px",e.style.top=Math.max(i,0)+"px"}},{}],24:[function(e,t,a){a.addClass=function(e,t){e.className=a.getClasses(e).concat([t]).join(" ")},a.removeClass=function(e,t){e.className=a.getClasses(e).filter(function(e){return e!==t}).join(" ")},a.toggleClass=function(e,t){var r=a.getClasses(e),s=r.indexOf(t);s!==-1?r.splice(s,1):r.push(t),e.className=r.join(" ")},a.getClasses=function(e){return e.className.split(" ").filter(function(e){return""!==e})},a.hasClass=function(e,t){return a.getClasses(e).indexOf(t)!==-1},a.getPrefixedProperty=function(e,t){var a=t[0].toUpperCase()+t.slice(1);return e[t]||e["moz"+a]||e["webkit"+a]}},{}],25:[function(e,t,a){function r(e,t,a){var r=this;r.events=e,r.element=t,r.slideViewsAccessor=a,r.configureElements(),e.on("showSlide",function(e){r.showSlide(e)})}e("../converter");t.exports=r,r.prototype.showSlide=function(e){var t=this,a=t.slideViewsAccessor(),r=a[e],s=a[e+1];t.notesElement.innerHTML=r.notesElement.innerHTML,s?t.notesPreviewElement.innerHTML=s.notesElement.innerHTML:t.notesPreviewElement.innerHTML=""},r.prototype.configureElements=function(){var e=this;e.notesElement=e.element.getElementsByClassName("remark-notes")[0],e.notesPreviewElement=e.element.getElementsByClassName("remark-notes-preview")[0],e.notesElement.addEventListener("mousewheel",function(e){e.stopPropagation()}),e.notesPreviewElement.addEventListener("mousewheel",function(e){e.stopPropagation()}),e.toolbarElement=e.element.getElementsByClassName("remark-toolbar")[0];var t={increase:function(){e.notesElement.style.fontSize=(parseFloat(e.notesElement.style.fontSize)||1)+.1+"em",e.notesPreviewElement.style.fontsize=e.notesElement.style.fontSize},decrease:function(){e.notesElement.style.fontSize=(parseFloat(e.notesElement.style.fontSize)||1)-.1+"em",e.notesPreviewElement.style.fontsize=e.notesElement.style.fontSize}};e.toolbarElement.getElementsByTagName("a").forEach(function(e){e.addEventListener("click",function(e){var a=e.target.hash.substr(1);t[a](),e.preventDefault()})})}},{"../converter":12}],26:[function(e,t,a){function r(e,t,a,r){var s=this;s.events=e,s.slideshow=t,s.scaler=a,s.slide=r,s.slideNumber=new g(r,t),s.configureElements(),s.updateDimensions(),s.events.on("propertiesChanged",function(e){e.hasOwnProperty("ratio")&&s.updateDimensions()})}function s(e,t,a){var r=document.createElement("div");return a.properties.name&&(r.id="slide-"+a.properties.name),n(t,r,a.properties),r.innerHTML=b.convertMarkdown(a.content,t.getLinks()),d(r,t),r}function n(e,t,a){t.className="",c(t,a),o(t,a,e),l(t,a)}function i(e,t){var a=document.createElement("div");return a.className="remark-slide-notes",a.innerHTML=b.convertMarkdown(t,e.getLinks()),d(a,e),a}function l(e,t){var a=t["background-image"],r=t["background-color"],s=t["background-size"],n=t["background-position"];a&&(e.style.backgroundImage=a),r&&(e.style.backgroundColor=r),s&&(e.style.backgroundSize=s),n&&(e.style.backgroundPosition=n)}function o(e,t,a){var r=t["highlight-style"]||a.getHighlightStyle();r&&f.addClass(e,"hljs-"+r)}function c(e,t){f.addClass(e,"remark-slide-content"),(t.class||"").split(/,| /).filter(function(e){return""!==e}).forEach(function(t){f.addClass(e,t)})}function d(e,t){var a,r=e.getElementsByTagName("code"),s=t.getHighlightLines(),n=t.getHighlightSpans(),i=t.getHighlightInlineCode();r.forEach(function(e){return""===e.className&&(e.className=t.getHighlightLanguage()),"PRE"!==e.parentElement.tagName?(f.addClass(e,"remark-inline-code"),void(i&&_.engine.highlightBlock(e,""))):(s&&(a=m(e)),""!==e.className&&_.engine.highlightBlock(e," "),u(e),s&&h(e,a.highlightedLines),n&&p(e),void f.addClass(e,"remark-code"))})}function m(e){var t=[];return e.innerHTML=e.innerHTML.split(/\r?\n/).map(function(e,a){return 0===e.indexOf("*")?(t.push(a),e.replace(/^\*( )?/,"$1$1")):e}).join("\n"),{highlightedLines:t}}function u(e){var t=e.innerHTML.split(/\r?\n/).map(function(e){return'\n \n Help
\n \n
\n \n \n \n ↑,\n ←,\n Pg Up,\n k\n \n Go to previous slide \n \n \n \n ↓,\n →,\n Pg Dn,\n Space,\n j\n \n Go to next slide \n \n \n \n Home\n \n Go to first slide \n \n \n \n End\n \n Go to last slide \n \n \n \n Number + Return\n \n Go to specific slide \n \n \n \n b /\n m /\n f\n \n Toggle blackout / mirrored / fullscreen mode \n \n \n \n c\n \n Clone slideshow \n \n \n \n p\n \n Toggle presenter mode \n \n \n \n t\n \n Restart the presentation timer \n \n \n \n ?,\n h\n \n Toggle this help \n \n \n\n
\n \n \n \n Esc\n \n Back to slideshow \n '+e+""});t.length&&t[t.length-1].indexOf("><")!==-1&&t.pop(),e.innerHTML=t.join("")}function h(e,t){t.forEach(function(t){f.addClass(e.childNodes[t],"remark-code-line-highlighted")})}function p(e){var t=/([^`])`([^`]+?)`/g;e.childNodes.forEach(function(e){e.innerHTML=e.innerHTML.replace(t,function(e,t,a){return"\\"===t?e.substr(1):t+''+a+""})})}var g=e("../components/slide-number/slide-number"),b=e("../converter"),_=e("../highlighter"),f=e("../utils");t.exports=r,r.prototype.updateDimensions=function(){var e=this,t=e.scaler.dimensions;e.scalingElement.style.width=t.width+"px",e.scalingElement.style.height=t.height+"px"},r.prototype.scale=function(e){var t=this;t.scaler.scaleToFit(t.scalingElement,e)},r.prototype.show=function(){f.addClass(this.containerElement,"remark-visible"),f.removeClass(this.containerElement,"remark-fading")},r.prototype.hide=function(){var e=this;f.removeClass(this.containerElement,"remark-visible"),f.addClass(this.containerElement,"remark-fading"),setTimeout(function(){f.removeClass(e.containerElement,"remark-fading")},1e3)},r.prototype.configureElements=function(){var e=this;e.containerElement=document.createElement("div"),e.containerElement.className="remark-slide-container",e.scalingElement=document.createElement("div"),e.scalingElement.className="remark-slide-scaler",e.element=document.createElement("div"),e.element.className="remark-slide",e.contentElement=s(e.events,e.slideshow,e.slide),e.notesElement=i(e.slideshow,e.slide.notes),e.contentElement.appendChild(e.slideNumber.element),e.element.appendChild(e.contentElement),e.scalingElement.appendChild(e.element),e.containerElement.appendChild(e.scalingElement),e.containerElement.appendChild(e.notesElement)},r.prototype.scaleBackgroundImage=function(e){var t,a,r,s=this,n=window.getComputedStyle(this.contentElement),i=n.backgroundImage,l=n.backgroundSize,o=n.backgroundPosition;(!l&&!o||s.backgroundSizeSet)&&null!==(t=/^url\(("?)([^\)]+?)\1\)/.exec(i))&&(a=new Image,a.onload=function(){a.width>e.width||a.height>e.height?s.originalBackgroundSize||(s.originalBackgroundSize=s.contentElement.style.backgroundSize,s.originalBackgroundPosition=s.contentElement.style.backgroundPosition,s.backgroundSizeSet=!0,r=e.width/a.width parser, Function
+>
+> ()
+> (())
+> ()()
+> (()())
+> (())()
+> ...
+>
+
+---
+
+* ### Model
+* ### Grammar
+* ### Parser
+
+---
+
+
+
+---
+
+## [funcj.parser](https://github.com/typemeta/funcj/tree/master/parser)
+
+---
+
+* [https://fifth-postulate.nl/parser-combinators/guide/](https://fifth-postulate.nl/parser-combinators/guide/)
+* twitter: [@daan_van_berkel](https://twitter.com/daan_van_berkel)
+* GitHub: [dvberkel](https://github.com/dvberkel)
+* Instagram: [daan.vanberkel](https://www.instagram.com/daan.vanberkel/)
\ No newline at end of file
diff --git a/presentations.html b/presentations.html
new file mode 100644
index 0000000..c5d91b5
--- /dev/null
+++ b/presentations.html
@@ -0,0 +1,18 @@
+
+
+
+
+ Parser Combinators
+ Practical Parsing for the Pragmatic Programmer
+ Presentations
+
+
+