https://github.com/krshrimali/interpreter-go

Just the code while I was reading the book: Writing an Interpreter in Go
https://github.com/krshrimali/interpreter-go

Last synced: 4 months ago
JSON representation

Just the code while I was reading the book: Writing an Interpreter in Go

• Host: GitHub
• URL: https://github.com/krshrimali/interpreter-go
• Owner: krshrimali
• Created: 2022-11-13T05:56:47.000Z (almost 3 years ago)
• Default Branch: main
• Last Pushed: 2022-12-09T05:03:44.000Z (almost 3 years ago)
• Last Synced: 2025-03-31T00:42:17.626Z (6 months ago)
• Language: Go
• Size: 27.3 KB
• Stars: 1
• Watchers: 2
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

          
# Code from book: Writing an Interpreter in Go

Just the code while I was reading the book: Writing an Interpreter in Go.

**Progress**:

* [x] 1 Lexing

    * [x] 1.1 - Lexical Analysis

    * [x] 1.2 - Defining Our Tokens

    * [x] 1.3 - The Lexer

    * [x] 1.4 - Extending our Token Set and Lexer

    * [x] 1.5 - Start of a REPL

* [ ] 2 Parsing

    * [x] 2.1 - Parsers

    * [x] 2.2 - Why not a parser generator?

    * [x] 2.3 - Writing a Parser for the Monkey Programming Language

    * [x] 2.4 - Parser’s first steps: parsing let statements

    * [x] 2.5 - Parsing Return Statements

    * [x] 2.6 - Parsing Expressions

    * [x] Expressions in Monkey

    * [x] Top Down Operator Precedence (or: Pratt Parsing)

    * [x] Terminology

    * [x] Preparing the AST

    * [x] Implementing the Pratt Parser

    * [x] Identifiers

    * [x] Integer Literals

    * [x] Prefix Operators

    * [x] Infix Operators

    * [x] 2.7 - How Pratt Parsing Works

    * [x] 2.8 - Extending the Parser

    * [x] Boolean Literals

    * [x] Grouped Expressions

    * [ ] If Expressions

    * [ ] Function Literals

    * [ ] Call Expressions

    * [ ] Removing TODOs

    * [ ] 2.9 - Read-Parse-Print-Loop

* [ ] 3 Evaluation

    * [ ] 13.1 - Giving Meaning to Symbols

    * [ ] 3.2 - Strategies of Evaluation

    * [ ] 3.3 - A Tree-Walking Interpreter

    * [ ] 3.4 - Representing Objects

    * [ ] Foundation of our Object System

    * [ ] Integers

    * [ ] Booleans

    * [ ] Null

    * [ ] 3.5 - Evaluating Expressions

    * [ ] Integer Literals

    * [ ] Completing the REPL

    * [ ] Boolean Literals

    * [ ] Null

    * [ ] Prefix Expressions

    * [ ] Infix Expressions

    * [ ] 3.6 - Conditionals

    * [ ] 3.7 - Return Statements

    * [ ] 3.8 - Abort! Abort! There’s been a mistake!, or: Error Handling

    * [ ] 3.9 - Bindings & The Environment

    * [ ] 3.10 - Functions & Function Calls

    * [ ] 3.11 - Who’s taking the trash out?

* [ ] 4 Extending the Interpreter

    * [ ] 4.1 - Data Types & Functions

    * [ ] 4.2 - Strings

    * [ ] Supporting Strings in our Lexer

    * [ ] Parsing Strings

    * [ ] Evaluating Strings

    * [ ] String Concatenation

    * [ ] 4.3 - Built-in Functions

    * [ ] len

    * [ ] 4.4 - Array

    * [ ] Supporting Arrays in our Lexer

    * [ ] Parsing Array Literals

    * [ ] Parsing Index Operator Expressions

    * [ ] Evaluating Array Literals

    * [ ] Evaluating Index Operator Expressions

    * [ ] Adding Built-in Functions for Arrays

    * [ ] Test-Driving Arrays

    * [ ] 4.5 - Hashes

    * [ ] Lexing Hash Literals

    * [ ] Parsing Hash Literals

    * [ ] Hashing Objects

    * [ ] Evaluating Hash Literals

    * [ ] Evaluating Index Expressions With Hashes

    * [ ] 4.6 - The Grand Finale