// Top-level function.
int square(int a) { return a * a; }

class SquareUtil {
  dynamic squareAnything(dynamic val) {
    bool isNumber = val is num  // this is how we can do runtime type checking
    return isNumber ? val * val : val + val;  // ternary operator supported
  }  
}

// This is the app entry point.
main() {
  dynamic result;
  
  var intVal = 9;           // Declare and initialize a variable. Type inferred
  result = square(intVal);  // Call a function
  print("Squaring int value ${intVal} yields ${result}");
  
  var sqr = SquareUtil();   // instantiate an object of type SquareUtil
  double doubleVal = 2.0;
  result = sqr.squareAnything(doubleVal);
  print("Squaring double value ${doubleVal} yields ${result}");
  
  String sVal = 'frou';
  result = sqr.squareAnything(sVal);
  print("Squaring string value '${sVal}' yields ${result}");
}

void main() {
  var list = [ 3, 4, 5 ];             // type inferred as List<int>
  var constList = const [ 6, 7, 8];   // const means fixed at compile-time
 
  print("'Classic' C-style for loop");
  for (int i = 0; i < list.length; i++) {
    print("list[i] = ${list[i]}");
  }
  
  print("\nNewer-style for loop");
  for (var value in list) {
    print("value = ${value}");
  }
  
  list.add(6);
  print("\nAdd 6 to the list: ${list}");
  
  var newList = [ 2, ...list ];
  print("\nNew list using spread operator: ${newList}");
  
  var newListWithConditional = [
    if (newList[0] == 2) 1,
    ...newList
  ];
  print("\nNew list with conditional entry: ${newListWithConditional}");
  
  var cubes = newListWithConditional.map((it) {
    return it * it * it;
  }).toList();
  print("Cubes of newListWithConditional: ${cubes}");
  
//   constList.add(9);  // yields error
}

// Working with Sets
void main() {
  var items = { 'A', 'B', 'C' }; // type inferred as Set<String>
  
  print("Items in set: ${items}");
  
  print('\nAdd another String:');
  items.add('D');
  print("Items in set after add: ${items}");
  
  print('\nAdd one or many:');
  var newSet = <Object>{};  // element type explicitly Object
  newSet.addAll(items);
  newSet.add(5);
  print("Items in newSet: ${newSet}");

  print('\Remove an item:');
  newSet.remove(5);
  print("Items in newSet after remove: ${newSet}");
  
  print('\nTry to add a duplicate:');
  bool wasItAdded = newSet.add('B');
  print("Item was added? ${wasItAdded}\nItems in newSet after trying to add duplicate: ${newSet}");
  
  print('\nMake an immutable set:');
  var immutableSet = const { 'X', 'Y', 'Z' };
  print("Items in immutableSet: ${immutableSet}");
  
//   immutableSet.add('Q');

// Working with Maps
void main() {
  var map = { 1: 'Chocolate', 2: 'Vanilla', 3: 'Strawberry' }; // type inferred as Map<int, String>
  print("Created map = ${map}");
  
  print('\nAccess individual entry:');
  print("Value for key 2: ${map[2]}");
  
  print('\nAccess missing key:');
  print("Value for key 99: ${map[99]}");
  
  print('\nAdd a new entry:');
  map[4] = 'Moose Tracks';
  print("Map after adding entry: ${map}");
  
  print('\nOutput map using keys and values:');
  map.forEach((key, value) {
    print("key = ${key}, value = ${value}");
  });
  
  print('\nOutput map using map entries:');
  map.entries.forEach((entry) {
    print("key = ${entry.key}, value = ${entry.value}");
  });
  
  print('\nMake a new map out of the old:');
  var newMap = Map<int, String>();
  newMap.addAll(map);
  newMap[5] = 'Mint Chocolate';
  print("newMap = ${newMap}, length = ${newMap.length}");
  
  var immutableMap = const { 'A123': 46, 'B456': 78, 'C789': 42 }; // type inferred as Map<String, int>
  print("immutableMap = ${immutableMap}");
  
//   immutableMap.remove('B456');
  
//   final immutableReference = immutableMap;
//   immutableReference = { 'A': 65, 'B': 66 };
  
}