void main() {
  print('Hello, World!');
}

// This is a single-line comment.
 
/*
   This is a multi-line
   comment block.
*/
 
/// This is a documentation comment (Doxygen/Dartdoc style).
/// Used for generating code documentation and IDE tooltips.
void documentedFunction() {}

// Dynamically typed / type-inferred variables
var name = 'VR Rathod'; // Type inferred as String
dynamic flexible = 42; // Variable can hold any type at runtime
flexible = 'Now a string'; 
 
// Explicitly typed variables
int age = 25;
double weight = 72.5;
bool isDeveloper = true;
String language = 'Dart';
 
// final - Value must be set once and is read-only. Evaluated at runtime.
final DateTime now = DateTime.now();
 
// const - Value is a compile-time constant. Implicitly final.
const double pi = 3.14159265;
const List<int> numbers = [1, 2, 3]; // Immutable list

// Object is the base class for all non-nullable types
Object something = 'Hello';
// something.substring(1); // Compile Error: Object doesn't have substring()
 
// dynamic bypasses compile-time checks (unsafe)
dynamic loose = 'Hello';
print(loose.substring(1)); // Works at compile time, might fail at runtime
 
// var infers type once
var x = 10;
// x = 'string'; // Compile Error: int cannot be assigned to String

import 'dart:io';
 
void main() {
  stdout.write('Enter your name: ');
  String? input = stdin.readLineSync(); // Reads line from terminal (can be null)
  
  if (input != null && input.isNotEmpty) {
    print('Hello, $input!');
  } else {
    print('Hello, Stranger!');
  }
}

// Arithmetic
// + (add), - (sub), * (mul), / (div), ~/ (integer division), % (modulo)
int divResult = 5 ~/ 2; // 2 (returns int)
double exactDiv = 5 / 2; // 2.5 (returns double)
 
// Relational & Equality
// ==, !=, >, <, >=, <=
 
// Type Test Operators
// as (typecast), is (true if object has the type), is! (true if object does not have the type)
if (name is String) {
  print('name is a String');
}
 
// Assignment
// =, +=, -=, *=, /=, ~/=, %=, ??=
int? nullableScore;
nullableScore ??= 10; // Assigns 10 only if nullableScore is currently null
 
// Logical
// && (AND), || (OR), ! (NOT)
 
// Conditional / Ternary
// condition ? expr1 : expr2
String access = age >= 18 ? 'Allowed' : 'Denied';
 
// Cascade Notation
// .. (allows sequential operations on same object)
var paint = Paint()
  ..color = Colors.black
  ..strokeCap = StrokeCap.round
  ..strokeWidth = 5.0;

// Upcasting (implicit)
num value = 10; // int is subtype of num
 
// Downcasting (explicit using 'as')
int concreteInt = value as int; // Will throw TypeError at runtime if not int
 
// Safe check before casting
if (value is int) {
  int safeInt = value; // Type promotion handles casting automatically!
}

// Non-nullable type (default)
int nonNullScore = 100;
// nonNullScore = null; // Compile Error
 
// Nullable type (appended with ?)
int? nullableScore;
nullableScore = null; // Allowed
 
// Null-aware Operators:
// ?. (Null-aware member access)
print(nullableScore?.toString()); // Prints null instead of throwing exception
 
// ?? (Null-coalescing fallback operator)
int finalScore = nullableScore ?? 0; // Uses 0 if nullableScore is null
 
// ! (Null assertion operator / Bang operator)
int forcedScore = nullableScore!; // Forces value, throws NullThrownError if null
 
// late keyword - lazily initialized non-nullable variable
late String description;
description = 'Lazy text'; // Initialized later, fails at runtime if read before write

int score = 85;
if (score >= 90) {
  print('Grade A');
} else if (score >= 80) {
  print('Grade B');
} else {
  print('Grade F');
}

// Traditional Switch
var command = 'OPEN';
switch (command) {
  case 'CLOSED':
    print('Closed');
    break;
  case 'OPEN':
    print('Open');
    break;
  default:
    print('Unknown');
}
 
// Switch Expression (Dart 3) - Concise, returns value, exhaustive
var color = 'red';
var hexColor = switch (color) {
  'red' => '#FF0000',
  'blue' => '#0000FF',
  'green' => '#00FF00',
  _ => '#000000' // Default fallback
};

// Standard For Loop
for (var i = 0; i < 5; i++) {
  print(i);
}
 
// For-In Loop (Iterating over iterables)
var list = [10, 20, 30];
for (var element in list) {
  print(element);
}
 
// ForEach lambda
list.forEach(print);
 
// While Loop
int count = 0;
while (count < 3) {
  print(count++);
}
 
// Do-While Loop
int index = 0;
do {
  print(index++);
} while (index < 3);
 
// Collection-if & Collection-for (within list/map literals)
bool includePromo = true;
var cart = [
  'Apple',
  'Banana',
  if (includePromo) 'Free Cookie',
  for (int i = 1; i <= 3; i++) 'Item $i'
];

for (var i = 0; i < 10; i++) {
  if (i == 3) continue; // Skip iteration
  if (i == 7) break;    // Exit loop
  print(i);
}
 
// assert - checks conditions in debug mode, ignored in release
int value = 5;
assert(value < 10); // Throws AssertionError if false

// standard declaration
int add(int a, int b) {
  return a + b;
}
 
// Shorthand arrow syntax (for single expression functions)
int subtract(int a, int b) => a - b;

// 1. Required Positional Parameters
void setIdentity(String name, int age) {}
 
// 2. Optional Positional Parameters (wrapped in [])
void logMsg(String msg, [String? level, int? code]) {
  print('$level ($code): $msg');
}
// logMsg('Starting', 'INFO'); // Valid
 
// 3. Named Parameters (wrapped in {}, implicitly optional unless marked 'required')
void createUser({required String username, String? email, int age = 18}) {
  print('User: $username, Email: $email, Age: $age');
}
// createUser(username: 'vr_ Rathod', age: 26); // Valid

void main() {
  var fruits = ['apple', 'banana', 'mango'];
  
  // Anonymous function block
  fruits.forEach((item) {
    print('Fruit: $item');
  });
  
  // Arrow anonymous function
  var mapped = fruits.map((item) => item.toUpperCase());
}

// Closures capture variables from outer scopes
Function makeAdder(int addBy) {
  return (int i) => addBy + i;
}
 
void main() {
  var add2 = makeAdder(2);
  var add5 = makeAdder(5);
  print(add2(3)); // 5
  print(add5(3)); // 8
}

// Defines a function signature type alias
typedef MathOperation = int Function(int a, int b);
 
int executeOp(int x, int y, MathOperation op) {
  return op(x, y);
}

// Synchronous Generator: Returns Iterable
Iterable<int> countTo(int max) sync* {
  for (int i = 1; i <= max; i++) {
    yield i; // Produces value lazily
  }
}
 
// Asynchronous Generator: Returns Stream
Stream<int> asyncCounter(int max) async* {
  for (int i = 1; i <= max; i++) {
    await Future.delayed(Duration(seconds: 1));
    yield i; // Emits value asynchronously
  }
}

var listA = [1, 2, 3];
var listB = listA; // Copies reference
listB.add(4);
print(listA); // [1, 2, 3, 4] — listA is mutated

// WeakReference prevents GC from keeping referenced object alive
var heavyObject = HeavyResource();
var weakRef = WeakReference(heavyObject);
 
// Retrieve value
var target = weakRef.target; // Returns null if object was GC'd
 
// Finalizer - triggers callback when object is garbage-collected
final Finalizer<String> resourceCleanup = Finalizer((token) {
  print('Cleaning native memory associated with token: $token');
});
 
resourceCleanup.attach(heavyObject, 'native_token_123');

// Single or double quotes
String s1 = 'Hello';
String s2 = "World";
 
// String Interpolation
int count = 5;
String total = 'The total count is $count'; // evaluates variable
String upper = 'Uppercase: ${s1.toUpperCase()}'; // evaluates expression
 
// Multi-line Strings
String multi = '''
  Line 1
  Line 2
''';
 
// Raw String (ignores escape characters)
String raw = r'C:\Users\Name\Documents';
 
// Common methods
print(s1.substring(1, 3)); // 'el'
print(s1.contains('ell')); // true
print(s1.split('e')); // ['H', 'llo']

// Literal List definition
List<int> numbers = [10, 20, 30];
 
numbers.add(40);
numbers.addAll([50, 60]);
numbers.removeAt(0); // Removes 10
 
print(numbers[0]); // 20
print(numbers.length); // 5
 
// Spread operator (...) and Null-aware spread (...?)
var moreNumbers = [0, ...numbers]; // [0, 20, 30, 40, 50, 60]
List<int>? dynamicNullList;
var safeCombined = [0, ...?dynamicNullList]; // [0] (no exception thrown)
 
// Iterating lists
var squares = [for (var n in numbers) n * n];

// Set literal
Set<String> uniqueColors = {'red', 'blue', 'green'};
uniqueColors.add('red'); // Ignored, value already exists
 
// Set operations
var primary = {'red', 'blue', 'yellow'};
var secondary = {'green', 'orange', 'purple'};
 
print(primary.intersection(secondary)); // {}
print(primary.union(secondary)); // {red, blue, yellow, green, orange, purple}
print(primary.difference({'red'})); // {blue, yellow}

// Map Literal
Map<String, int> scores = {
  'Alice': 95,
  'Bob': 87,
};
 
scores['Charlie'] = 92; // Adding entry
print(scores['Alice']); // 95
print(scores['Unregistered']); // null (returns null if key not present)
 
// Useful map properties & methods
print(scores.keys); // (Alice, Bob, Charlie)
print(scores.containsKey('Bob')); // true
scores.putIfAbsent('Bob', () => 100); // Does not overwrite 87

class Point {
  double x; // Instance variable
  double y;
  
  // Generative constructor with syntactic sugar for initialization
  Point(this.x, this.y);
  
  // Method
  double distanceToOrigin() {
    return x * x + y * y;
  }
}
 
void main() {
  Point p = Point(3.0, 4.0); // Instantiate object (new keyword is optional)
  print(p.distanceToOrigin()); // 25.0
}

class Car {
  String make;
  String model;
  int year;
  
  // 1. Standard constructor
  Car(this.make, this.model, this.year);
  
  // 2. Named constructor
  Car.classic(this.make, this.model) : year = 1970; // initializer list
  
  // 3. Redirecting Constructor
  Car.ford(String model, int year) : this('Ford', model, year);
  
  // 4. Constant Constructor (constructs immutable compile-time constants)
  // All instance fields must be final
}
 
class ImmutablePoint {
  final double x;
  final double y;
  const ImmutablePoint(this.x, this.y); // Const constructor
}
 
// 5. Factory Constructor
// Used when constructor doesn't always create new instance of the class
class Logger {
  final String name;
  static final Map<String, Logger> _cache = {};
  
  factory Logger(String name) {
    return _cache.putIfAbsent(name, () => Logger._internal(name));
  }
  
  Logger._internal(this.name); // Private named constructor
}

class BankAccount {
  double _balance = 0.0; // Private field
  
  // Public Getter
  double get balance => _balance;
  
  // Public Setter
  set deposit(double amount) {
    if (amount > 0) _balance += amount;
  }
}

class Circle {
  static const double pi = 3.14159; // Class variable
  double radius;
  
  Circle(this.radius);
  
  static double calculateArea(double r) => pi * r * r; // Class method
}

class Vector {
  final int x, y;
  Vector(this.x, this.y);
  
  // Overload the + operator
  Vector operator +(Vector other) {
    return Vector(x + other.x, y + other.y);
  }
  
  // Overload the == operator
  @override
  bool operator ==(Object other) =>
    identical(this, other) ||
    other is Vector && runtimeType == other.runtimeType && x == other.x && y == other.y;
    
  @override
  int get hashCode => x.hashCode ^ y.hashCode;
}

class Vehicle {
  String brand;
  Vehicle(this.brand);
  
  void honk() => print('Beep!');
}
 
class Truck extends Vehicle {
  double loadCapacity;
  
  // Constructor chaining
  Truck(String brand, this.loadCapacity) : super(brand);
  
  @override
  void honk() {
    super.honk(); // Call parent implementation
    print('Bwahhh!'); // Custom override
  }
}

class Instrument {
  void play() {}
}
 
class Guitar implements Instrument {
  @override
  void play() => print('Strumming strings');
}

mixin Swimmer {
  void swim() => print('Swimming in water');
}
 
mixin Walker {
  void walk() => print('Walking on ground');
}
 
class Duck extends Vehicle with Swimmer, Walker {
  Duck() : super('Donald');
}
 
// Constraining a mixin to specific superclass types using 'on'
mixin Flight on Vehicle {
  void fly() => print('Flying vehicle!');
}

abstract class Shape {
  double get area; // Abstract getter
}
 
class Circle extends Shape {
  double radius;
  Circle(this.radius);
  
  @override
  double get area => 3.14159 * radius * radius;
}
 
class Square extends Shape {
  double side;
  Square(this.side);
  
  @override
  double get area => side * side;
}
 
void printArea(Shape s) {
  print('Area: ${s.area}'); // Resolves subclass area getter at runtime
}

// sealed class
sealed class Result {}
class Success extends Result { final String data; Success(this.data); }
class Failure extends Result { final Exception err; Failure(this.err); }
 
// Compiles only if all subtypes are handled (compiler ensures exhaustiveness)
String handle(Result res) => switch(res) {
  Success s => 'Got: ${s.data}',
  Failure f => 'Error: ${f.err}',
};

// Add functionality to existing classes without subclassing
extension StringParsing on String {
  int toInt() => int.parse(this);
}
 
void main() {
  int num = '123'.toInt(); // Extends String class
}

// Zero-cost wrapping over an underlying type. No runtime allocation.
extension type Id(int value) {
  bool get isValid => value > 0;
}
 
void main() {
  Id userId = Id(42);
  print(userId.isValid); // true
  // int raw = userId; // Compile Error: Id is type-safe distinct from int
}

// Implementing the call() method makes the object behaves like a function
class Greeter {
  String greeting;
  Greeter(this.greeting);
  
  void call(String name) => print('$greeting, $name!');
}
 
void main() {
  var sayHello = Greeter('Hello');
  sayHello('VR'); // Invokes the call() method
}

// Generic Class
class Box<T> {
  T value;
  Box(this.value);
  
  T getValue() => value;
}
 
// Generic Method
T findFirst<T>(List<T> items) {
  return items[0];
}

// Restrict generic type parameter to a subclass of a specific type
class MathBox<T extends num> {
  T val;
  MathBox(this.val);
  
  double square() => val.toDouble() * val.toDouble();
}

void checkAge(int age) {
  if (age < 0) {
    // You can throw any non-null object in Dart
    throw ArgumentError('Age cannot be negative');
  }
}
 
void main() {
  try {
    checkAge(-5);
  } on ArgumentError catch (e) {
    print('Specific error handled: $e');
  } on Exception catch (e) {
    print('General exception handled: $e');
  } catch (e, stackTrace) {
    // Fallback block captures everything else
    print('Unknown error: $e');
    print('Stacktrace: $stackTrace');
    rethrow; // Propagate exception up call stack
  } finally {
    print('Clean up operations here.');
  }
}

class OutOfGasException implements Exception {
  final String message;
  OutOfGasException(this.message);
  
  @override
  String toString() => 'OutOfGasException: $message';
}

// returns a future that resolves to String
Future<String> fetchUserData() {
  return Future.delayed(Duration(seconds: 2), () => 'Alice');
}
 
// Handling Future using async/await
Future<void> main() async {
  print('Fetching user...');
  String name = await fetchUserData(); // Suspends execution until future completes
  print('User name: $name');
}
 
// Alternative chaining approach using .then()
void loadUser() {
  fetchUserData().then((name) {
    print('Loaded: $name');
  }).catchError((err) {
    print('Error: $err');
  });
}

// A Stream is a sequence of asynchronous events.
// 1. Single-Subscription stream - can only be listened to once
// 2. Broadcast stream - can be listened to multiple times simultaneously
 
import 'dart:async';
 
void main() async {
  // Stream Controller usage
  final controller = StreamController<String>.broadcast();
  
  // Listen to stream
  final subscription = controller.stream.listen(
    (data) => print('Received: $data'),
    onError: (err) => print('Error: $err'),
    onDone: () => print('Stream Closed'),
  );
  
  // Add items to stream
  controller.sink.add('Event 1');
  controller.sink.add('Event 2');
  
  await controller.close();
}

import 'dart:isolate';
 
// Entry point for spawned isolate (must be global or static function)
void isolateTask(SendPort sendPort) {
  int total = 0;
  for (int i = 0; i < 1000000000; i++) total += i; // Heavy compute
  sendPort.send(total); // Send result back
}
 
void main() async {
  final receivePort = ReceivePort();
  
  // Spawn new isolate
  await Isolate.spawn(isolateTask, receivePort.sendPort);
  
  // Wait for message response
  final result = await receivePort.first;
  print('Computed value from Isolate: $result');
}

import 'dart:io';
 
void main() async {
  final file = File('data.txt');
  
  // Asynchronous writing
  await file.writeAsString('Hello, Dart File I/O!\n');
  
  // Appending
  await file.writeAsString('Appended line\n', mode: FileMode.append);
  
  // Asynchronous reading
  if (await file.exists()) {
    String contents = await file.readAsString();
    print('File content:\n$contents');
  }
  
  // Binary raw I/O
  List<int> bytes = await file.readAsBytes();
}

// Importing library
import 'dart:math'; // Standard library
import 'package:http/http.dart' as http; // Package prefix namespace
import 'my_helper.dart' show checkStatus; // Only import checkStatus
import 'my_helper.dart' hide performCalculation; // Import everything except
 
// Deferred loading (lazy loading of code units)
import 'lazy_module.dart' deferred as lazy;
 
Future<void> load() async {
  await lazy.loadLibrary(); // Loads on-demand
  lazy.runWork();
}
 
// Exporting libraries
// my_package.dart exports multiple library fragments
export 'src/models.dart';
export 'src/controllers.dart';

# Run a Dart script
dart run bin/main.dart
 
# Compile to native self-contained executable file
dart compile exe bin/main.dart -o build/main.exe
 
# Compile to JavaScript web target
dart compile js bin/main.dart -o build/main.js

@override // Marks a subclass method overriding a superclass method
@deprecated // Marks method/variable as deprecated
@pragma('vm:prefer-inline') // Gives custom instructions to the compiler

import 'dart:ffi' as ffi;
import 'package:ffi/ffi.dart';
 
// Load native dynamic library (DLL / .so / .dylib)
final ffi.DynamicLibrary nativeLib = ffi.DynamicLibrary.open('math_lib.dll');
 
// Look up function signature
typedef NativeAdd = ffi.Int32 Function(ffi.Int32, ffi.Int32);
typedef DartAdd = int Function(int, int);
 
final DartAdd nativeAdd = nativeLib
  .lookupFunction<NativeAdd, DartAdd>('add_numbers');

import 'dart:js_interop';
 
@JS('window.alert')
external void browserAlert(JSString message);

void main() {
  int a = 12; // Binary: 00001100
  int b = 25; // Binary: 00011001
  
  print(a & b);   // AND: 8 (00001000)
  print(a | b);   // OR: 29 (00011101)
  print(a ^ b);   // XOR: 21 (00010101)
  print(~a);      // NOT: -13 (two's complement)
  print(a << 2);  // Left Shift: 48
  print(a >> 2);  // Right Shift (Sign-extending): 3
  print(a >>> 2); // Unsigned Right Shift: 3
}

name: code_note_dart
description: A Dart project containing reference code notes.
version: 1.0.0
publish_to: 'none'
 
environment:
  sdk: '>=3.0.0 <4.0.0' # Targets Dart 3.x SDK
  
dependencies:
  http: ^1.1.0
  path: ^1.8.3
  
dev_dependencies:
  lints: ^2.1.0
  test: ^1.24.0

// Enhanced Enum (Dart 2.17+) allows fields, constructor, and methods
enum LogLevel {
  info('INFO', 200),
  warning('WARN', 400),
  error('ERROR', 500);
  
  final String label;
  final int code;
  const LogLevel(this.label, this.code);
  
  void printLog() => print('$label (Code $code)');
}

// Records are anonymous, immutable aggregate types
void main() {
  // 1. Positional fields
  var point = (1.5, 2.5);
  print(point.$1); // 1.5
  
  // 2. Named fields
  var user = (name: 'VR', age: 26);
  print(user.name); // 'VR'
}

// Destructuring using patterns
void main() {
  var pair = (1, 'two');
  var (a, b) = pair; // Binds 1 to a, 'two' to b
  
  var list = [1, 2, 3];
  if (list case [1, var y, 3]) {
    print(y); // 2 (Pattern matched lists with y extracted)
  }
}