Develop An Interpreter Using Rust Programming

Free Download Develop An Interpreter Using Rust Programming
Published 9/2023
MP4 | Video: h264, 1280×720 | 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

Homepage

www.udemy.com/course/develop-an-interpreter-using-rust-programming/