> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # Dart Multiplication The `*` (asterisk) in Dart functions primarily as a binary infix operator for multiplicative operations, and lexically as a suffix modifier for generator functions and yield delegation. ## The Binary Operator (`*`) As an operator, `*` is a syntactic sugar for a method call on the left operand. It possesses **multiplicative precedence** (level 14 in Dart's precedence table), meaning it evaluates after unary operators but before additive operators, with **left-to-right associativity**. ### Built-in Implementations **1. Numeric Multiplication** When applied to `num` types (`int` or `double`), it performs standard arithmetic multiplication. The return type is determined by the operands: if both are `int`, it returns an `int`; if either is a `double`, it returns a `double`. ```dart theme={"dark"} int a = 5 * 2; // Evaluates to 10 double b = 5.0 * 2; // Evaluates to 10.0 ``` **2. String Repetition** Dart's `String` class implements the `*` operator, accepting an `int` as the right operand. It returns a new string containing the original string repeated the specified number of times. ```dart theme={"dark"} String repeated = 'Dart' * 3; // Evaluates to 'DartDartDart' ``` ### Operator Overloading Because `*` is implemented as an instance method, it can be overridden in user-defined classes using the `operator` keyword. The right operand can be of any type specified by the method signature. ```dart theme={"dark"} class Matrix { final List values; Matrix(this.values); // Overloading the * operator Matrix operator *(int scalar) { return Matrix(values.map((v) => v * scalar).toList()); } } Matrix m1 = Matrix([1, 2, 3]); Matrix m2 = m1 * 2; ``` ## Lexical Modifiers (Generators) Beyond binary operations, the `*` symbol is a structural component of Dart's generator syntax. It modifies the behavior of functions and the `yield` keyword. **1. `sync*` and `async*`** Appending `*` to the `sync` or `async` keywords transforms a standard function into a generator function. * `sync*` forces the function to return an `Iterable` and evaluates synchronously. * `async*` forces the function to return a `Stream` and evaluates asynchronously. ```dart theme={"dark"} Iterable synchronousGenerator() sync* { yield 1; } Stream asynchronousGenerator() async* { yield 1; } ``` **2. `yield*` (Yield Delegation)** When appended to the `yield` keyword, `*` delegates the emission of values to another `Iterable` or `Stream`. Instead of emitting the collection as a single object, `yield*` flattens the sequence, emitting each element of the delegated collection individually into the current generator's output. ```dart theme={"dark"} Iterable delegatedGenerator() sync* { yield* synchronousGenerator(); } ```

Tired of Poor Dart Skills? Fix That With Deep Grasping! Learn More