Convert CFG/CNF Grammar Code from Scala to Python

Scala's case classes provide concise data container definitions with automatic generation of toString, equals, hashCode, and copy methods. A single line like 'case class Student(rollNumber: Int, name: String, marks: Int)' creates a complete data structure with constructor, getters, and comparison methods—all automatically generated. Methods are defined using 'def' followed by the method name and parameters, with the equals sign separating the signature from the body. Single-line methods can omit curly braces entirely. Operator overloading allows custom methods to use symbolic operators as function names, making code more readable when working with domain-specific operations.

Algebraic Data Types (ADTs) in Scala are a powerful data modeling paradigm consisting of two fundamental types: sum types (implemented as sealed traits with case objects, representing exclusive choices like weather conditions) and product types (implemented as case classes, representing combinations of values like coordinates). ADTs provide three key advantages: illegal states are not representable (ensuring only valid data can be constructed), high composability (allowing ADTs to be nested within other ADTs), and immutability (storing only data without functionality, enabling easier testing and parallel processing). By explicitly defining all possible cases rather than using loose types like strings, developers can reduce complexity and improve code maintainability.

Algebraic Data Types (ADTs) in Scala are built from two fundamental types: products (tuples and case classes that combine multiple values) and sums (sealed traits and case classes that represent one of several alternatives). Product types like tuples (Int, Boolean) encode all possible combinations of their components, while sum types like sealed traits (PaymentMethod) encode mutually exclusive alternatives. Pattern matching enables structural deconstruction of these types, allowing developers to safely extract and manipulate data through match expressions with cases, guards, and alternatives.

This extensive section introduces Scala as a modern multiparadigm programming language designed for expressing general programming patterns elegantly and type-safely. Scala integrates object-oriented and functional programming paradigms seamlessly: every value is an object (defined through traits and classes), and every function is a value (supporting higher-order functions, closures, and currying). The language supports case classes and pattern matching for algebraic type manipulation. Scala's statically typed system includes annotations, polymorphic methods, compound types, and type bounds, providing both flexibility and safety. Basic data types mirror Java's types with identical precision and memory footprint. Literals include integers (decimal/hex), floating-point numbers (with optional exponents), characters (Unicode with escape sequences), strings (with escape handling), booleans, and symbols. Operators provide syntactic sugar for method invocations. Type inference eliminates redundant annotations for variables and method returns, though recursive methods and dangerous inferences (null type) require explicit typing. Collections include mutable and immutable variants optimized for different use cases, with lists implementing linked lists optimal for stack patterns. Functions are first-class citizens supporting higher-order programming patterns.

Scala class definitions are more concise than Java, eliminating unnecessary curly braces. Methods without return types default to Unit (equivalent to Java's void). Scala lacks static methods, using companion objects instead - objects defined in the same file with the same name as a class. Companion objects and classes can share private members, enabling factory methods. Objects in Scala are true singletons. Case classes automatically generate companion objects with apply methods, equals/hashCode, copy methods, and toString. They provide immutable value objects with concise syntax. The companion object pattern is essential for creating natural-looking APIs like Array(1,2,3) that create instances through factory methods.

Object-oriented programming (OOP) is a development approach for designing large software systems, not a specific programming paradigm. It is supported by languages through encapsulation, inheritance, and polymorphism. The three pillars of OOP are: 1) Encapsulation - bundling data and methods within a single unit; 2) Inheritance - deriving properties from existing classes; 3) Polymorphism - different objects responding to the same method calls differently. Abstraction involves creating general models from specific instances by identifying common properties. Python uses dynamic typing where type checking occurs at runtime rather than compile time, enabling duck typing where behavior is determined by implemented methods rather than declared types.

Stage 2 covers Python-specific data structures including lists, tuples, sets, and dictionaries. Additionally, learners must master file handling (CSV and JSON files), exception handling, and object-oriented programming (OOP) concepts. OOP is emphasized as crucial because its principles apply across all major programming languages and are expected in technical interviews. The four pillars of OOP—polymorphism, abstraction, encapsulation, and inheritance—are covered in detail.

Python has become one of the most popular programming languages due to its simple syntax, interpreted nature, and dynamic typing. Variables can change types during execution without explicit declarations. Built-in data types include integers, floats, complex numbers, lists, tuples, strings, and dictionaries. Object-Oriented Programming (OOP) is a paradigm where software is designed around objects and classes. Classes serve as blueprints defining structure and behavior, while objects are instances containing data (state) and methods (behavior). Core OOP principles include encapsulation (bundling data and methods), polymorphism (treating different objects uniformly), and inheritance (reusing code through class hierarchies).

This section explains Python's dynamic typing and object-oriented nature. Python is dynamically typed, meaning variables can change types during execution without Python complaining. Everything in Python is an object, including functions, which means everything has methods and can be introspected. The 'dir()' function reveals available methods on objects, which is useful for undocumented code. Introspection allows examining objects at runtime: single interrogation (?) provides information, while double interrogation (??) shows source code (only for Python-written code, not C-based built-ins). Reference copying means assigning one variable to another creates a reference to the same object, not a copy.

Python is a dynamically typed language, meaning developers do not need to explicitly specify the type of variables. The interpreter automatically determines the type of variables at runtime based on the value assigned to them. This dynamic type determination simplifies the development process and reduces boilerplate code. Python is also an object-oriented programming language, meaning everything in Python is an object. Objects are memory locations that store data and can be manipulated by the program. This object-oriented approach simplifies data management and enables developers to create complex applications using the principles of encapsulation, inheritance, and polymorphism.

This section establishes the theoretical foundation of compiler grammars. Terminals are input symbols (numbers, operators, semicolons) corresponding to parse tree leaves. Non-terminals are abstract constructs (expressions, statements) that organize language structure. Production rules define how non-terminals decompose into other symbols, enabling finite descriptions of infinitely many valid programs. Bison's grammar specification syntax (non-terminal : symbol1 symbol2 ... ;) is equivalent to Chomsky Normal Form notation. The meta-language challenge involves distinguishing between Bison's grammar description language and the target programming language, where symbols like semicolons serve different purposes at different abstraction levels.

Formal grammars describe which programs are syntactically correct in a programming language. A grammar consists of four parts: (1) Terminals - basic building blocks like digits and operators; (2) Non-terminals - helper symbols that describe how terminals can be combined; (3) Production rules - rules showing how non-terminals derive terminals; (4) Initial symbol - the starting point for deriving valid programs. For example, an arithmetic expression grammar might have terminals {0-9, +, -}, non-terminals {expr, num, op, digit}, production rules defining how expressions can be numbers or operator combinations, and initial symbol expr.

Parsing is the process of converting source code into an Abstract Syntax Tree (AST) through two stages: lexical analysis (tokenizer) that converts characters into tokens, and syntactic analysis (parser) that validates syntax against a formal grammar; formal grammars are defined as tuples (N, T, P, S) consisting of non-terminals, terminals, productions, and a start symbol, with context-free grammars being particularly important for programming languages as they allow one non-terminal on the left-hand side and can handle recursive structures like balanced parentheses that regular expressions cannot.

This segment explains the fundamental components of a context-free grammar used in compiler design. The instructor describes terminals as the actual tokens in the source program (like keywords, identifiers, operators) that cannot be further expanded. Non-terminals are symbols that can be replaced by other symbols according to production rules. The instructor explains that production rules specify how non-terminals can be replaced by sequences of terminals and non-terminals. The instructor emphasizes that terminals are represented by lowercase letters and non-terminals by uppercase letters in grammar notation, and that this convention should not be confused with the actual case of tokens in the source code.

The instructor introduces formal grammars (pioneered by Chomsky) as a way to define language syntax. A formal grammar has four components: (1) Terminals - the actual symbols in the language (like numbers and operators), (2) Non-terminals - names of syntactic structures (like 'expression' or 'sentence'), (3) Productions - rules that define how non-terminals break down into components, (4) Starting symbol - the root non-terminal of the parse tree.