Functions

Why functions?

A function is a named, reusable block of code that does one job. Write the GST calculation once, call it from ten screens, and fix it in one place when rules change.

double withGst(double price, double ratePercent) {
  return price + price * ratePercent / 100;
}

int square(int n) => n * n;       // arrow syntax for one expression

void greet(String name) {
  print('Namaste, $name!');
}

void main() {
  print(withGst(1000, 18));   // 1180.0
  print(square(9));           // 81
  greet('Kiran');
}

Named parameters

Named parameters are wrapped in curly braces and passed by name. They make calls readable, and Flutter uses them everywhere: Text('Hi', style: ..., maxLines: 2). A named parameter is optional unless marked required; optional ones need a default value or a nullable type.

String ticket({required String from, required String to, int passengers = 1, String? coach}) {
  final coachText = coach == null ? '' : ' in $coach';
  return '$passengers ticket(s) $from to $to$coachText';
}

void main() {
  print(ticket(from: 'Pune', to: 'Nagpur'));
  print(ticket(to: 'Goa', from: 'Mumbai', passengers: 3, coach: '3A'));
}

Named parameters are the main reason Flutter code is readable. Compare Container(16, null, Colors.white) with Container(padding: EdgeInsets.all(16), color: Colors.white): the second tells you exactly what each value means.

Optional positional parameters

String greeting(String name, [String title = '']) =>
    title.isEmpty ? 'Hello $name' : 'Hello $title $name';

void main() {
  print(greeting('Rao'));          // Hello Rao
  print(greeting('Rao', 'Dr.'));   // Hello Dr. Rao
}

Functions as values

In Dart, functions are objects. You can store them in variables, pass them to other functions and return them. An anonymous function has no name: (x) => x * 2 or () { print('tapped'); }. This is how Flutter callbacks work: ElevatedButton(onPressed: () { ... }) passes an anonymous function that runs when the button is tapped.

void repeatTimes(int n, void Function(int) action) {
  for (var i = 1; i <= n; i++) {
    action(i);
  }
}

void main() {
  repeatTimes(3, (i) => print('Reminder $i: pay electricity bill'));
  final discounts = [0.1, 0.2];
  final apply = discounts.map((d) => 1000 - 1000 * d).toList();
  print(apply);    // [900.0, 800.0]
}

You can also name a function type with typedef, for example typedef PriceRule = int Function(int price);, and then write PriceRule rule instead of the long type.

Closures

A closure is a function that remembers variables from where it was created. Flutter widgets use closures all the time, for example a button's onPressed changing a counter defined outside it.

Function makeCounter() {
  var count = 0;
  return () => ++count;
}

void main() {
  final next = makeCounter();
  next();
  print(next());   // 2
}

Common mistakes

• Forgetting required on a named parameter that must be given, then dealing with nulls everywhere.
• Writing onPressed: doSomething() instead of onPressed: doSomething (or () => doSomething()): the first calls the function immediately while building.
• Using arrow syntax for a body with several statements. => takes exactly one expression.
• Missing return types on public functions. Write them; they document the code.