Functional

//Higher order methods
//map(), where(), every(), reduce(), fold() and sort().
void main() {

  var numbers = [1, 2, 3, 4, 5];

  //map()
  var sq1 = [];
  for(var element in numbers){
    sq1.add(element * element);
  }
  print(sq1);

  final sq2 = numbers.map((element) => element * element).toList();
  print(sq2);

  //where() - filter
  var even1 = [];
  for(var element in numbers){
    if (element.isEven) {
      even1.add(element);
    }
  }
  print(even1);

  final even2 = numbers.where((element) => element.isEven).toList();
  print(even2);

  //every()
  bool? isGood1;
  for(var element in numbers){
    if (element == 3) {
      isGood1 = false;
      break;
    }
    isGood1 = true;
  }
  print(isGood1);

  final isGood2 = numbers.every((element) => element != 3);
  print(isGood2);

  //reduce()
  var sum1 = 0;
  for (var element in numbers) {
    sum1 += element;
  }
  print(sum1);

  final total1 = numbers.reduce((value, element) => value + element);
  print(total1);

  //fold()
  var strings = ['a', 'bb', 'ccc', 'dddd', 'eeeee'];
  var sum2 = 0;
  for (var element in strings) {
    sum2 += element.length;
  }
  print(sum2);

  final total2 = strings.fold(0, (value, element) => (value as int) + element.length);
  print(total2);

  //sort()
  var list1 = [3, 5, 1, 4, 2];
  list1.sort();
  print(list1);

  //Comparable
  var list2 = ['c', 'a', 'b'];
  list2.sort();
  print(list2);

  //Comparator
  var list3 = ['ccc', 'a', 'bb'];
  list3.sort((prev, next) => prev.length.compareTo(next.length));
  print(list3);

  //Custom Types
  var points = [Point(3, 1), Point(1, 3), Point(2, 2)];
  //Comparable
  points.sort();
  print(points);
  //Comparator
  points.sort((prev, next) => prev.y.compareTo(next.y));
  print(points);

  //reversed property
  var reversedNumbers = numbers.reversed.toList();
  print(reversedNumbers);

  //Combining methods
  final seven = numbers.where((element) => (element % 2) == 0)
      .where((element) => element == 4)
      .map((e) => e + 3).first;
  print(seven);

}

class Point implements Comparable<Point>{
  Point(this.x, this.y);
  final x;
  final y;

  @override
  bool operator ==(Object other) {
    return (other is Point) && other.x == x && other.y == y;
  }

  //Comparable
  //The function must return an integer.
  // If the result is negative, the first value will be placed before the second value.
  // Otherwise, the second value will appear before the first value in the sorted List.
  // If the result is 0, it means both values are equal in the ordering.
  @override
  int compareTo(Point other) {
    return x - other.x;
  }

  @override
  int get hashCode => x.hashCode ^ y.hashCode;

  @override
  String toString() {
    return 'Point (x: $x, y: $y)';
  }
}