Develop an Interpreter Using TypeScript

Course Curriculum

Chapter 1: Introduction

Lecture 1: Introduction

Lecture 2: Birds Eye view of Interpreter

Lecture 3: Monkey Programming Language Overview

Chapter 2: Lexical Analysis

Lecture 1: Lexical Analysis Introduction

Lecture 2: Installation of Tools

Lecture 3: Initial Project Setup

Lecture 4: Configure Vitest as Test Runner

Lecture 5: Token Type

Lecture 6: Lexer's Next Token Implementation

Lecture 7: Lexer's Next Token Implementation Re-Explanation

Lecture 8: Extending the test to have input as valid Monkey Programming Language

Lecture 9: Implementing reading Identifier Tokens

Lecture 10: Skipping Whitespace and Lookup Ident method

Lecture 11: Reading Numbers

Lecture 12: Extend Single Character Tokens

Lecture 13: Updating Next Token Method

Lecture 14: Extend the Keywords

Lecture 15: Extending Tokens with Double Character Tokens

Lecture 16: Creating a REPL

Lecture 17: Fix for issue in REPL

Chapter 3: Parsing

Lecture 1: Introduction to Parser

Lecture 2: Introduction to Parsing Let Statements

Lecture 3: AST for Statement and Expression Node

Lecture 4: AST for Let and Identifiers

Lecture 5: Starting with Parser Implementation

Lecture 6: Test case for Parsing Let Statements

Lecture 7: Explanation of Test case

Lecture 8: Implementation of parseStatement method

Lecture 9: Completing the parsing of let statement

Lecture 10: Adding errors to Parser

Lecture 11: Parsing Return Statements

Lecture 12: Introduction to Parsing Expressions

Lecture 13: Refactoring AST Module

Lecture 14: Add string method to root AST Node

Lecture 15: Infix and Prefix Methods

Lecture 16: Identifier Expression Test case

Lecture 17: Parsing Identifiers Implementation

Lecture 18: Parse Integer Literals

Lecture 19: Test case for Prefix Expression

Lecture 20: Implementation of Prefix Expression

Lecture 21: Test case for Infix Expression

Lecture 22: Implementation of Infix Expression

Lecture 23: Operator Precedence Test

Lecture 24: How Pratt Parser works

Lecture 25: Refactoring Tests

Lecture 26: AST and Test for Boolean Expressions

Lecture 27: Implementation of Boolean Expression

Lecture 28: Implementation of Grouped Expressions

Lecture 29: AST for If Expression

Lecture 30: Test case for If Else Expression

Lecture 31: Implementation of If Else Expression

Lecture 32: AST and Test case for Function Literal

Lecture 33: Implementation of Function Literal

Lecture 34: AST and Test case for Call Expression

Lecture 35: Implementation of Call Expression

Lecture 36: Working on Todo's

Lecture 37: Completion of Parser with update to REPL

Chapter 4: Evaluator

Lecture 1: Evaluation Introduction

Lecture 2: Object Representation

Lecture 3: Integer Representation

Lecture 4: Boolean and Null Representation

Lecture 5: Evaluation Implementation of Integer

Lecture 6: Evaluation Implementation of Boolean

Lecture 7: Null implementation

Lecture 8: Evaluation of Prefix Expression

Lecture 9: Evaluation of Infix (Integers)

Lecture 10: Evaluation of Infix (Integers) – Boolean Operators

Lecture 11: Evaluation of Infix (Boolean)

Lecture 12: Conditionals

Lecture 13: Return Statement

Lecture 14: Error Handling

Lecture 15: Let Statement

Lecture 16: Functions Pt.1

Lecture 17: Functions Pt.2

Lecture 18: End of Evaluation

Chapter 5: Adding Data Structures

Lecture 1: Introduction

Lecture 2: String Data Structure – Lexer

Lecture 3: String Data Structure – Parser

Lecture 4: String Data Structure – Evaluator

Lecture 5: String Data Structure – Concatenation

Lecture 6: Builtin Functions

Lecture 7: Builtin Function – len (string)

Lecture 8: Array – Lexer

Lecture 9: Array – Parsing

Lecture 10: Parsing Array Index Expressions

Lecture 11: Evaluate Array Literals

Lecture 12: Evaluate Array Index Expressions

Lecture 13: Array builtin Functions

Lecture 14: Hash Data Structure – Lexer

Lecture 15: Hash Data Structure – Parsing

Lecture 16: Hash Data Structure – Hash Key

Lecture 17: Hash Data Structure – Object Representation

Lecture 18: Hash Data Structure – Evaluation

Lecture 19: Hash Data Structure – Index Expression

Lecture 20: Builtin Method – Puts