Hint: var is about inference, not flexibility.

Solution: No. var infers the type once (int here) and locks it permanently. x = 'hi' is a compile error. The keyword that allows the type to change is dynamic.

Hint: Recall the division gotcha from Part 3.

Solution: double. The / operator always returns a double, even for two ints — so y is 0.75, not 0.

Hint: An empty literal can't infer its element type — annotate it.

Solution:

var names = <String>[]; // or: List<String> names = [];
names.add('Asha');

var names = [] would infer List<dynamic> — a trap.

Hint: One keeps the type checker on; the other switches it off.

Solution: Object is a real type — it accepts any non-null value but the compiler still checks every member access. dynamic disables type checking, so member access compiles even when it's wrong and crashes at runtime.

Hint: What's the one value Object excludes?

Solution: Every value in Dart is an Object except null. Adding ? includes null too, so Object? is the single type that every possible value fits into — the top of the type hierarchy.

Hint: is plus type promotion.

Solution:

if (value is String) {
  print(value.length); // promoted to String here
}

Hint: One promotes safely; the other asserts and can throw.

Solution: is tests a type and promotes the variable inside the guarded block (safe). as forcibly casts and throws a TypeError if wrong. Use as only when you're certain, or when you can't structure the code as an if to get promotion.

Hint: Find the nearest common supertype of int and double.

Solution: List<num>. int and double both extend num, so the least common type of the elements is num. (Check with print(d.runtimeType) or your IDE.)

Hint: Inference needs something on the right-hand side at declaration.

Solution: With no initializer there's nothing to infer from, so x defaults to dynamic. Avoid it by initializing on the same line (var x = 5;) or annotating the type (int x;).

Hint: Two is checks, both promote.

Solution:

int safeLength(Object o) {
  if (o is String) return o.length;
  if (o is List) return o.length;
  return -1;
}

Hint: What the compiler tracks vs. what's actually in memory.

Solution: The static type of x is Object (what the compiler enforces). The runtime type is int — x.runtimeType returns int, the actual class of the stored value. They can differ; that's why x is int is true even though it's declared Object.

Hint: Subtypes.

Solution: is respects subtyping (a subclass instance is its supertype), and it promotes the variable. runtimeType == is an exact-class equality check that fails for subclasses and gives no promotion — fragile and unidiomatic.

Hint: Don't trust dynamic — test before use.

Solution:

int asInt(dynamic data) => data is int ? data : 0;

The is int both checks and promotes, so data is usable as an int in the true branch.

Hint: Where do the bugs surface?

Solution: dynamic defers all type errors to runtime, so mistakes reach users instead of being caught while you type. It also kills autocomplete and refactoring safety. Prefer concrete types or Object? + is so the compiler does the checking.

Hint: What can a plain int hold?

Solution: A plain type (int, String) can never be null. To allow null you must opt in with ? (int?). This makes "might be missing" visible in the type itself.

Hint: n might be null, so prove it isn't — or supply a default.

Solution:

int doubled = (n ?? 0) * 2;
// or:
if (n != null) { int doubled = n * 2; }

Hint: Two possibilities.

Solution: "A String, or null." The ? makes the type nullable — a distinct type from String, which the compiler forces you to null-check before use.

Hint: The "if null, use this" operator.

Solution:

print(name ?? 'Guest');

Hint: Safe-call operator.

Solution:

int? len = s?.length; // null in → null out

Hint: One is safe; one is a promise that can break.

Solution: ?. is safe — it returns null instead of calling on a null receiver. ! asserts non-null and throws at runtime if the value is actually null. Prefer ?./??; use ! only when certain.

Hint: Chain ?. then finish with ??.

Solution:

String city = user?.address?.city ?? 'Unknown';

Hint: Assign, but only when currently null.

Solution: It assigns the right side only if the variable is currently null. name ??= 'Anonymous'; sets name only when it was null; otherwise it's a no-op.

Hint: n! on the null element.

Solution: n! throws on the middle element. Replace the bang with a default:

var total = xs.fold(0, (sum, n) => sum + (n ?? 0)); // 4

Hint: The key might not exist.

Solution: A missing key yields null rather than crashing, so map[key] is typed V?. Null safety forces you to handle the miss, usually with ?? default.

Hint: Is it conceptually always present, just assigned later?

Solution: Use late when the value is genuinely non-null but can't be assigned at declaration (e.g. set in a constructor body or initState). Use ? only when the value can truly be absent. late keeps a clean non-null type without scattering !/?..

Hint: late, not nullable.

Solution:

class Service {
  late Database db;
  void connect() => db = Database();
}

Reading db before connect() throws a clear LateInitializationError.

Hint: A specific runtime error, not a silent null.

Solution: You get a LateInitializationError at runtime — explicit and traceable, far better than a silent null propagating through your code.

Hint: late + an initializer expression defers execution.

Solution:

late final config = _loadConfig(); // _loadConfig runs on first read, then caches

If config is never read, _loadConfig() never runs.

Hint: Can a non-nullable type ever be null at runtime?

Solution: Soundness means the guarantee is airtight: a non-nullable type cannot be null at runtime (barring ! lies). The compiler can optimize on that fact, and you can rely on it for correctness — no defensive null checks needed on plain types.

Hint: ...?.

Solution:

var all = ['post', ...?tags]; // skips tags entirely if null

Hint: What is ! working against?

Solution: Frequent ! usually means the data is being forced non-null instead of modelled honestly. Each ! is a potential runtime crash and a place the compiler's guarantee was overridden. The fix is usually to make the type properly nullable (and handle it) or non-nullable (and guarantee it), not to assert.

Hint: Return type must allow "none."

Solution:

int? firstEven(List<int> xs) {
  for (final x in xs) {
    if (x.isEven) return x;
  }
  return null;
}

The nullable return type makes "not found" explicit and forces callers to handle it.

Hint: Uniqueness and fast membership.

Solution: When you need unique values and/or fast "does it contain X?" checks, and order isn't the point. Lists keep order and allow duplicates but membership scans the whole thing.

Hint: Indexes start at 0.

Solution:

var colors = ['red', 'green', 'blue'];
print(colors[1]); // green

Hint: Ambiguity resolved in favor of one of them.

Solution: {} is an empty Map. For an empty Set you must annotate: <String>{}.

Hint: Round-trip through a Set.

Solution:

[1, 2, 2, 3, 3, 3].toSet().toList(); // [1, 2, 3]

Hint: Lookup is nullable.

Solution:

var ages = {'Asha': 30};
print(ages['Ben'] ?? 0); // 0

Hint: Spread, and order matters.

Solution:

var merged = {...defaults, ...over}; // {a: 1, b: 9}

The later key wins in a map literal, so spread overrides last.

Hint: [for (...) expr].

Solution:

var squares = [for (final n in [1,2,3,4]) n * n]; // [1,4,9,16]

Hint: Collection-if.

Solution:

var menu = ['Home', if (isAdmin) 'Admin'];

Hint: Null operand.

Solution: ... spreads a collection's elements into a literal; ...? does the same but safely skips the operand when it's null (no crash).

Hint: Set algebra methods.

Solution:

var a = {1,2,3}, b = {2,3,4};
a.intersection(b); // {2, 3}
a.union(b);        // {1, 2, 3, 4}

Hint: Nest if inside for.

Solution:

var nums = [for (var i = 1; i <= 10; i++) i];
var evens = [for (final n in nums) if (n.isEven) n]; // [2,4,6,8,10]

Hint: Laziness.

Solution: No — they return lazy Iterables. Call .toList() (or .toSet()) to materialize a concrete collection.

Hint: fold and reduce.

Solution:

var nums = [1,2,3,4];
nums.fold(0, (s, n) => s + n);   // 10 (works on empty list too)
nums.reduce((a, b) => a + b);    // 10 (throws on empty list)

Hint: .entries or forEach.

Solution:

for (final e in ages.entries) {
  print('${e.key} → ${e.value}');
}
// or: ages.forEach((k, v) => print('$k → $v'));

Hint: putIfAbsent to create the list lazily.

Solution:

var words = ['apple','avocado','banana','cherry'];
var grouped = <String, List<String>>{};
for (final w in words) {
  grouped.putIfAbsent(w[0], () => []).add(w);
}
// {a: [apple, avocado], b: [banana], c: [cherry]}

Hint: Deeply immutable.

Solution: A const collection is frozen at compile time — its contents can't be added to, removed, or changed (add throws). Useful for fixed lookup tables you want to guarantee nobody mutates.

Hint: Swap each entry's key and value.

Solution:

var m = {'a': 1, 'b': 2};
var inverted = {for (final e in m.entries) e.value: e.key}; // {1: a, 2: b}

(Map collection-for! Assumes values are unique.)

Hint: Spread each sublist inside a collection-for.

Solution:

var flat = [for (final sub in nested) ...sub];
// or: nested.expand((e) => e).toList();

Hint: Hashing vs. scanning.

Solution: A Set (hash set) hashes the value to find its bucket directly — roughly constant time. A List.contains must scan element by element until it finds a match — linear time. For frequent "contains" checks, use a Set.

Hint: Split, then accumulate with ??.

Solution:

var counts = <String, int>{};
for (final w in 'a b a c b a'.split(' ')) {
  counts[w] = (counts[w] ?? 0) + 1;
}
// {a: 3, b: 2, c: 1}

Hint: Single expression → =>.

Solution:

int twice(int x) => x * 2;

Hint: No brackets means…

Solution: Yes — a plain positional parameter must be passed, in order. You make parameters optional with { } (named) or [ ] (optional positional).

Hint: { } around the param; pass by name.

Solution:

void greet({required String name}) => print('Hi $name');
greet(name: 'Asha');

Hint: Expressions vs. statements.

Solution: When the body needs more than one expression — loops, if blocks, multiple statements. Those require the full { ... } body with return.

Hint: Named vs. optional-positional.

Solution: { } = named (passed by name, any order, optional unless required). [ ] = optional positional (passed by position, omittable from the end). You can't use both groups in one function.

Hint: Defaults after = inside { }.

Solution:

void connect({String host = 'localhost', int port = 8080}) =>
    print('$host:$port');
connect(port: 3000); // localhost:3000

Hint: Named + required.

Solution:

void sendEmail({
  required String to,
  required String subject,
  bool html = false,
  bool urgent = false,
}) {}
sendEmail(to: 'x@y.com', subject: 'Hi', html: true);

Hint: Functions are first-class values.

Solution:

int square(int x) => x * x;
int Function(int) op = square;
print(op(5)); // 25

Hint: (x) => ... inline.

Solution:

['a','b'].map((s) => s.toUpperCase()).toList(); // [A, B]

Hint: The lambda must be exactly (x) => f(x).

Solution: A tear-off passes a named function directly: list.forEach(print) instead of forEach((x) => print(x)). It can't replace (s) => s.toUpperCase() because that calls an instance method on the element, not a standalone function of the element.

Hint: Optional positional [ ] with a default.

Solution:

int power(int base, [int exponent = 2]) {
  var r = 1;
  for (var i = 0; i < exponent; i++) r *= base;
  return r;
}
power(5);    // 25
power(2, 3); // 8

Hint: Functions that remember.

Solution: A function that captures variables from the scope where it was defined and keeps them alive after that scope returns — a way to hold private, persistent state without a class.

Hint: Capture a local count.

Solution:

int Function() makeCounter() {
  int count = 0;
  return () => ++count;
}
var c = makeCounter();
c(); // 1
c(); // 2

Hint: (int, int) return + var (a, b) = ....

Solution:

(int, int) minMax(List<int> xs) {
  var lo = xs.first, hi = xs.first;
  for (final x in xs) { if (x < lo) lo = x; if (x > hi) hi = x; }
  return (lo, hi);
}
var (low, high) = minMax([4,1,9]); // 1, 9

Hint: Take a function parameter, call it twice.

Solution:

T applyTwice<T>(T Function(T) f, T x) => f(f(x));
applyTwice((n) => n + 3, 10); // 16

Hint: Each call creates a fresh scope.

Solution:

var a = makeCounter();
var b = makeCounter();
a(); a(); // a → 1, 2
b();      // b → 1  (independent)

Each makeCounter() call captures its own count, so the counters don't interfere.

Hint: Named record fields.

Solution:

({String name, int age}) getUser() => (name: 'Ben', age: 25);
var u = getUser();
print(u.name); // Ben
print(u.age);  // 25

Hint: Look at any widget constructor.

Solution: Widgets take many configuration arguments; passing them positionally would be a wall of mystery values. Named parameters (child:, padding:, color:) label each argument at the call site, making deeply nested widget trees self-documenting.

Hint: Methods return something.

Solution: No — strings are immutable. Every method returns a new string; to "change" a variable you reassign it (s = s.toUpperCase()).

Hint: Chain two methods.

Solution:

'  HELLO  '.trim().toLowerCase(); // 'hello'

Hint: split then join.

Solution:

'a,b,c'.split(',').join(' | '); // 'a | b | c'

Hint: toString then padLeft.

Solution:

42.toString().padLeft(5, '0'); // '00042'

Hint: lastIndexOf('.') + substring.

Solution:

var f = 'a.b.final.pdf';
f.substring(f.lastIndexOf('.') + 1); // 'pdf'

Hint: How many matches.

Solution: replaceAll replaces every occurrence; replaceFirst only the first. Both are case-sensitive unless you pass a case-insensitive RegExp.

Hint: split → reversed → join.

Solution:

'dart'.split('').reversed.join(); // 'trad'

(For emoji-safe reversing, use .characters instead of split('').)

Hint: split on space, take first letter of each.

Solution:

var n = 'ada lovelace';
'${n.split(' ').map((w) => w[0].toUpperCase()).join('.')}.'; // 'A.L.'

Hint: \d + allMatches. Raw string!

Solution:

RegExp(r'\d').allMatches('a1b22c333').length; // 6

Hint: Who interprets the backslash first?

Solution: Without r, Dart processes escape sequences (\d, \n) before the regex engine sees them, mangling the pattern. A raw string passes the backslashes through untouched.

Hint: Split at @, keep first char, repeat *.

Solution:

var e = 'asha@x.com';
var at = e.indexOf('@');
var local = e.substring(0, at);
'${local[0]}${'*' * (local.length - 1)}${e.substring(at)}'; // 'a***@x.com'

Hint: Parenthesized groups + group(n).

Solution:

var m = RegExp(r'(\d{4})-(\d{2})-(\d{2})').firstMatch('2026-07-08');
m?.group(1); // 2026
m?.group(2); // 07
m?.group(3); // 08

firstMatch is nullable, hence ?..

Hint: Immutability cost in a loop.

Solution: When building a string across many iterations. Repeated += allocates a new string each time (O(n²)-ish); StringBuffer accumulates in a mutable buffer and produces the result once with toString().

Hint: write in a loop, separator between.

Solution:

var b = StringBuffer();
for (var i = 0; i < 100; i++) {
  if (i > 0) b.write(',');
  b.write(i);
}
b.toString();

Hint: No truthy/falsy.

Solution: Dart conditions require a real bool. There's no truthy/falsy coercion, so you must check explicitly (if (s.isNotEmpty)), which prevents a class of "why did that branch run?" bugs.

Hint: cond ? a : b.

Solution:

var s = n.isEven ? 'even' : 'odd';

Hint: Two loop forms.

Solution:

for (var i = 0; i < 5; i++) print(i);
for (final i in [0,1,2,3,4]) print(i);

Hint: Famous C/Java footgun — absent here.

Solution: No. Each non-empty case automatically stops at its end; no break is needed and there's no accidental fallthrough.

Hint: Arrows, commas, _.

Solution:

String msg(int c) => switch (c) {
  200 => 'OK',
  404 => 'Not Found',
  500 => 'Server Error',
  _ => 'Unknown',
};

Hint: || and >= && <.

Solution:

String f(int n) => switch (n) {
  1 || 2 || 3 => 'small',
  >= 4 && <= 9 => 'medium',
  _ => 'large',
};

Hint: Record pattern in a declaration.

Solution:

var (name, age) = ('Asha', 30);

Hint: Assign a record pattern.

Solution:

var (a, b) = (1, 2);
(a, b) = (b, a); // a == 2, b == 1

Hint: List pattern + binding.

Solution:

if (data case [int x, int y]) {
  print('($x, $y)');
}

Hint: Extra boolean test.

Solution: It adds a runtime condition; the arm matches only if the pattern matches and the when expression is true (e.g. case var a when a > 0).

Hint: var a when ....

Solution:

String ticket(int age) => switch (age) {
  var a when a < 13 => 'child',
  var a when a < 65 => 'adult',
  _ => 'senior',
};

Hint: Object pattern with field matching.

Solution:

switch (p) {
  case Point(x: 0, y: var y): print('Y axis at $y');
  case Point(x: var x, y: 0): print('X axis at $x');
  default: print('elsewhere');
}

Hint: Finite, known set of values.

Solution: A switch over a finite type (enum or sealed class) must cover every case or it won't compile. Adding a new variant turns every unhandled switch into a compile error — a guaranteed refactor checklist.

Hint: Cover all three → no default needed.

Solution:

String act(Light l) => switch (l) {
  Light.red => 'Stop',
  Light.yellow => 'Slow',
  Light.green => 'Go',
};

Adding Light.flashing later makes this a compile error until handled.

Hint: List patterns with a literal first element + binding.

Solution:

String run(List cmd) => switch (cmd) {
  ['move', int n] => 'move $n',
  ['rotate', int deg] => 'rotate $deg',
  _ => 'ignored',
};
run(['move', 5]); // 'move 5'

Hint: Patterns, null safety, types.

Solution: (1) if-case / switch patterns to test shape and destructure in one step; (2) typed patterns (int x, String s) that check the type and bind safely — no as; (3) sound null safety so any missing field is a ? type you must handle. Together they replace nested null/type checks with a single declarative match — e.g. if (json case {'name': String name, 'age': int age}) { ... }.