Develop An Interpreter Using Rust Programming

Published 9/2023
MP4 | Video: h264, 1280x720 | Audio: AAC, 44.1 KHz
Language: English | Size: 9.60 GB | Duration: 16h 11m

Develop an interpreter from scratch without third-party libraries using Rust Programming

What you'll learn
Developing an Interpreter using Rust Programming
Understand Lexing, Parsing , Evaluation steps of the Parser
Create a REPL for playing with the interpreter
Develop interpreter for a custom programming language

Requirements
Experience with Rust Programming (Basic Level)

Description
Hello everyone welcome to the course Develop an Interpreter using Rust Programming.This course is a comprehensive and practical guide that takes you on a journey of building your own interpreter using the Rust programming language. This course is inspired by the great book Writing An Interpreter In Go by Thorsten Ball. All credit to him as well. We will demystify the complex world of interpreters in this course.The course begins by introducing the fundamental concepts of interpreters and programming languages, making it accessible to both beginners and experienced developers. We will build an interpreter using Rust programming language for a custom programming language called Monkey through a hands-on approach.we will understand key concepts such as lexical analysis, parsing, and evaluating expressions. In the course we will learn how to design and implement a lexer and a recursive descent parser, providing you learners with a solid foundation in language processing techniques.The course will help developers seeking to deepen their understanding of language implementation.During the process of developing an interpreter, we will also learn more advanced topics like closures, first-class functions, and error handling.By the end of the course, you would have hopefully gained a deep understanding of how interpreters work and the skills to build your own programming language, opening up new possibilities for exploration and creativity in the world of software development.

Overview
Section 1: Introduction

Lecture 1 Introduction

Lecture 2 Interpreter 101

Lecture 3 Monkey Programming Language 101

Lecture 4 Tools Installation

Section 2: Lexer Phase

Lecture 5 Introduction to Lexer

Lecture 6 Project Generation using Cargo

Lecture 7 Defining Tokens

Lecture 8 Test for getting Next Token

Lecture 9 Read Char method

Lecture 10 Implementation of Next Token

Lecture 11 Review - Next Token

Lecture 12 Extending Next Token Test Case

Lecture 13 Keywords and Identifiers Implementation

Lecture 14 Integer Implementation

Lecture 15 Extending Test case and Token set

Lecture 16 Extending next token method

Lecture 17 Extending Keywords

Lecture 18 Double Character Tokens

Lecture 19 REPL

Section 3: Parser Phase

Lecture 20 Introduction to Parsing

Lecture 21 Note on Parser Generators

Lecture 22 Parsing Strategies

Lecture 23 Parsing Let Statements Overview

Lecture 24 AST for Let Statement

Lecture 25 Parsing Program Overview

Lecture 26 Test for Let Statement

Lecture 27 Implementation of parsing Let Statement

Lecture 28 Let Statement Code Flow Walkthrough

Lecture 29 Store errors in Parser

Lecture 30 AST for Return Statement

Lecture 31 Test for Return Statement Parsing

Lecture 32 Parser implementation for Return Statement

Lecture 33 Challenges with Parsing an Expression

Lecture 34 AST for Expression Statement

Lecture 35 Test Case for Print String

Lecture 36 Prefix and Infix Functions Setup

Lecture 37 Test for Parsing Identifier Expression

Lecture 38 Parsing Identifier Expression Implementation

Lecture 39 AST and Test Case for Integer Literal Expression

Lecture 40 Parsing Integer Literal Implementation

Lecture 41 AST for Prefix Expression

Lecture 42 Test Case for Prefix Expression

Lecture 43 Implementation of Parsing Prefix Expression

Lecture 44 AST and Test Case for Infix Expression

Lecture 45 Implementation of Parsing Infix Expression

Lecture 46 Pratt Parser Walkthrough

Lecture 47 Simplifying Test with Test Helpers

Lecture 48 AST and Test Case for Boolean Expression

Lecture 49 Implementing Parsing of Boolean Expression

Lecture 50 Implementing Parsing of Grouped Expression

Lecture 51 AST for If Expression

Lecture 52 Test Case for If Expression

Lecture 53 Implementation of Parsing If Expression

Lecture 54 AST for Function Literal

Lecture 55 Test Case for Function Literal

Lecture 56 Implementation of Parsing of Function Literal

Lecture 57 AST for Call Expression

Lecture 58 Test Case for Call Expression

Lecture 59 Implementation of Parsing Call Expression

Lecture 60 Removing TODO's

Lecture 61 Modifying REPL

Section 4: Evaluation

Lecture 62 Introduction to Evaluation

Lecture 63 Evaluation Strategies

Lecture 64 Tree Walking Interpreter and Representing Object System

Lecture 65 Integer Object Representation

Lecture 66 Bool and Null Object Representation

Lecture 67 Test for evaluating Integer Literal

Lecture 68 Implementing evaluation of Integer Literal

Lecture 69 Updating REPL to play with Integer Literal

Lecture 70 Evaluating Boolean

Lecture 71 Evaluating Bang Operator Expression

Lecture 72 Evaluating Minus Prefix Expression

Lecture 73 Evaluating Integer Infix Expression

Lecture 74 Evaluating Boolean Infix Expression

Lecture 75 Test case for evaluating If Else

Lecture 76 Evaluating If Else Implementation

Lecture 77 Evaluating Return Statement

Lecture 78 Handle Errors

Lecture 79 Issue with Evaluation of Let Binding

Lecture 80 Creating an Environment

Lecture 81 Evaluating Identifier

Lecture 82 Testing Let Binding

Lecture 83 Object representation for Function

Lecture 84 Test case to evaluate function literal

Lecture 85 Evaluating Function Literal Implementation

Lecture 86 Test case for evaluating call expression

Lecture 87 Issue with evaluating call expression

Lecture 88 Implementation of evaluating call expression

Lecture 89 Call Expression Logic Walkthrough

Lecture 90 Testing in REPL

Lecture 91 Test case for closures

Section 5: Built in Types & Functions

Lecture 92 Introduction

Lecture 93 String - Lexer

Lecture 94 String - Parser

Lecture 95 String - Evaluator

Lecture 96 String Concatenation

Lecture 97 String Concatenation Walkthrough

Lecture 98 Builtins Introduction

Lecture 99 Builtin - len Method

Lecture 100 Array - Lexer

Lecture 101 Array - Parsing

Lecture 102 Array Index Expression - Parsing

Lecture 103 Array Literal - Evaluator

Lecture 104 Array Index Expression - Evaluator

Lecture 105 Builtins for Arrays

Lecture 106 Hash - Lexer

Lecture 107 Hash - Parser Tests

Lecture 108 Hash - Parser Implementation

Lecture 109 Hash Key Object Implementation

Lecture 110 Hash Object Representation

Lecture 111 Hash Evaluation Tests

Lecture 112 Hash Evaluation Implementation

Lecture 113 Implementation of Hash Index Expression - Evaluation

Lecture 114 Final Builtin - Puts

Section 6: End of Course

Lecture 115 Final dance

Lecture 116 Bonus Lecture

Intermediate Developers,Rust Developers

Buy Premium Account From My Download Links & Get Fastest Speed.