Functions in Dart

Analogy categoryAnalogies

What Functions Are in Dart

A function in Dart is a named, reusable block of code that takes zero or more parameters and optionally returns a value; even Dart's entry point, main(), is itself a function. Dart functions are typed — you declare the return type and each parameter's type — which lets the analyzer catch mismatched calls at compile time rather than at runtime. Because everything in Dart is an object, including functions themselves, they can be assigned to variables, passed as arguments, and returned from other functions, forming the basis for callbacks, event handlers, and the functional-style Iterable methods like map, where, and reduce.

🏏

Cricket analogy: A specific fielding drill — 'catching practice' — is called by name and run identically every time a coach requests it, just as a Dart function is a named, reusable block you invoke by name instead of rewriting the same logic before every net session.

Function Syntax, Parameters, and Return Types

A basic function declaration follows returnType functionName(parameterType parameterName) { body }, and Dart supports three parameter categories: required positional, optional positional (wrapped in square brackets), and named (wrapped in curly braces) — the last two can be combined with a required positional parameter but not with each other in the same signature. The => arrow syntax is shorthand for a function body that's a single expression, implicitly returning that expression's value, and is common for short getters and one-line functions. If a function's body can fall through without hitting an explicit return, its effective return value is null, so the return type must be nullable or void.

🏏

Cricket analogy: A required positional parameter is like the non-negotiable toss call at the start of a match — you cannot skip it — while an optional named parameter is like choosing to request a pitch report, which you may or may not ask for depending on the situation.

dart

// Required, optional positional, and arrow syntax
int add(int a, int b) => a + b;

String describeBook(String title, [String? author]) {
  return author == null ? title : '$title by $author';
}

void main() {
  print(add(2, 3));                // 5
  print(describeBook('Dart 101')); // Dart 101
}

First-Class Functions and Function Types

Because Dart functions are first-class values, you can store a reference to one in a variable typed as a function type, such as int Function(int, int) operation = add;, and pass that variable anywhere a callback is expected, as List.sort does with its optional comparator. Anonymous functions (function literals) let you define a function inline without naming it, which is the pattern behind most Flutter event handlers like onPressed: () { ... } and Iterable transformations like list.map((item) => item.toUpperCase()). Dart's type system infers and checks function-type parameters just like any other type, so passing a callback with the wrong signature is a compile-time error, not a runtime crash.

🏏

Cricket analogy: A team can substitute its designated 'death-over specialist' bowler into any match situation just by handing the ball to whoever fits that role, just as Dart lets you pass a function itself, like a comparator, as a value wherever a matching function type is expected.

Dart's typedef keyword lets you give a function type a readable name, e.g. typedef IntTransformer = int Function(int);, which is especially useful for documenting complex callback signatures used repeatedly across a codebase, such as validators or event handlers in a Flutter form.

Recursion and Variable Scope

A recursive function calls itself to solve a smaller instance of the same problem, such as computing a factorial or traversing a nested tree of widgets, and every recursive function needs a base case that stops the recursion to avoid a stack overflow. Dart uses lexical (static) scoping: a variable is visible only within the block where it's declared and any nested blocks, and an inner function can 'close over' variables from its enclosing function, reading and even capturing their value after the outer function has returned, which is what makes closures possible.

🏏

Cricket analogy: A commentator explaining a rain-delay rule recursively references the previous over's asterisk situation, and eventually bottoms out at the last ball bowled before the stoppage — that stopping point is exactly like recursion's base case preventing infinite backtracking.

dart

int factorial(int n) {
  if (n <= 1) return 1; // base case
  return n * factorial(n - 1);
}

Function makeAdder(int base) {
  // 'base' is captured from the enclosing scope
  return (int value) => base + value;
}

void main() {
  print(factorial(5)); // 120
  final addFive = makeAdder(5);
  print(addFive(10));  // 15
}

Deep unbounded recursion in Dart can throw a StackOverflowError just like in most languages — Dart does not guarantee tail-call optimization, so a recursive algorithm expected to run on very large inputs (like processing a huge JSON tree) is often safer rewritten iteratively with an explicit stack or converted to use Iterable methods.

Functions are named, reusable, typed blocks of code — even main() is a function.
Dart supports required positional, optional positional ([]), and named ({}) parameters.
The => arrow syntax is shorthand for a single-expression function body with an implicit return.
Functions are first-class values in Dart: they can be stored in variables, passed as arguments, and returned from other functions.
typedef gives a function type a readable name for documenting complex callback signatures.
Recursive functions need a base case to avoid a StackOverflowError, since Dart doesn't guarantee tail-call optimization.
Dart uses lexical scoping, so inner functions can read variables from their enclosing scope.