Iterable

• If you are familiar with Dart/Flutter you are knowingly or unknowingly using Iterable in your application or program.
• You might have come across objects like List, Map, and Set when building an application.
• These are nothing but Iterable. You can verify this by taking a look into the implementation of these collections.
• List :
• 
• Set :
• 
• An Iterable as the name suggests, it has something to do with iteration.
• The definition of Iterable given by Dart is :

  An Iterable is a collection of elements that can be accessed sequentially

• If we look at the implementation of the Iterable, we can see that Iterable is an abstract class.
• 
• That means we cannot instantiate the Iterable class.
• But we can create a new Iterable by creating List, Set, Map. For example :
• 
• We cannot access the value by index, like numbers[index]. It's because Iterable doesn't have [ ] operator like List.
• Let's try to access the element of the Iterable by [ ], And see what error it throws:
• 
• 
• As expected it threw an error that says operator [ ] is not defined in Iterable class.
• Iterable has many useful properties and methods available.
• As List, Set is Implementing Iterable , All the methods that are available in Interable are also accessible in List and Set.
• A Map is different than List and Set, because it contains key : value pairs. We cannot directly loop through the Map variable as we're doing in Set and List. Because Map is not implementing Iterable
• 
• 
• Map has keys and values Iterables inside it.
• Keys Iterable
• Values Iterable
• 
• So to iterate over the Map we can do something like :
• 

---

Iterator

• In simple terms Iterator is a single element of a collection that we can get one at a time.
• Iterator is an Interface. The for-in loop we've used in the above examples is using this Iterator interface under the hood.
• The thing is Iterable doesn't know how to iterate over the collection. That is why Iterable has an Iterator getter inside it.
• 
• Its job is to move sequentially through all the elements of the iterable.
• All iterables have an iterator
• 
• 
• The Iterator has a method called moveNext(), which returns a boolean value.
• If it returns true then it means that iterable contains the next element.
• if it returns false then it means that there are no further elements.
• Iterator has one very important getter called current. Which gives the current element of the iterable.
• Example :
• 

---

Properties of Iterable :

• first & last:

• first returns the first value/element from the Iterable.
• last returns the last value/element from the Iterable.
• first Example :

  void main() {
   final List<String> listOfCar = ["Audi","BMW","Ferrari","Mercedes"];
   print(listOfCar.first);
  }
  

• 
• For accessing the first element from Map :

• void main() {
   final Map<String,dynamic> mapOfNumbers = 
  {"0":"Zero","1":"One","2":"Two","3":"Three"};
   print(mapOfNumbers.values.first);
  }
  

• 
• last Example :

•  final List<String> listOfCar = ["Audi","BMW","Ferrari","Mercedes"];
   print(listOfCar.last);
  

• 

---

• isEmpty & isNotEmpty:

• isEmpty returns true if Iterable is empty, otherwise false.
• isNotEmpty returns true if Iterable is not empty, otherwise false

• void main() {
  final List<String> listOfCar = ["Audi","BMW","Ferrari","Mercedes"];
  print(listOfCar.isEmpty);
  }
  

• 
• Same for the Map

• void main() {
   final Map<String,dynamic> mapOfNumbers = 
  {"0":"Zero","1":"One","2":"Two","3":"Three"};
   print(mapOfNumbers.isEmpty); // false
  }
  

---

• length :

• Returns the total number of elements/values present in the Iterable.

• void main() {
   final Map<String,dynamic> mapOfNumbers = 
  {"0":"Zero","1":"One","2":"Two","3":"Three"};
  
   final List<String> listOfCar = ["Audi","BMW","Ferrari","Mercedes"];
  
   print("List: "+listOfCar.length.toString());
   print("Map: "+mapOfNumbers.length.toString());
  }
  

• 

---

• runtimeType :

• Returns the type of the object.

• void main() {
   final Map<String,dynamic> mapOfNumbers = 
  {"0":"Zero","1":"One","2":"Two","3":"Three"};
  
   final List<String> listOfCar = ["Audi","BMW","Ferrari","Mercedes"];
  
   print(listOfCar.runtimeType);
   print(mapOfNumbers.runtimeType);
  }
  

• 

---

• single :

• If the Iterable has only one element inside it, then single returns that value/element.

• void main() {
   final List<String> listOfCar = ["Audi"];
   print(listOfCar.single);
  }
  

• 
• If there are more than one element then it will throw an error.

---

Methods of Iterable :

• elementAt(index) :

• As we've seen in the explanation of Iterable that we cannot access the element of Iterable by [ ]. Because Iterable doesn't have [ ] defined.
• So we can use elementAt() method to access any element from the Iterable.

• void main() {
   final Map<String,dynamic> mapOfNumbers = 
  {"0":"Zero","1":"One","2":"Two","3":"Three"};
  
   final Iterable<String> listOfCar = ["Audi","BMW","Ferrari","Mercedes"];
  
   print(listOfCar.elementAt(0));
   print(mapOfNumbers.values.elementAt(0));
  }
  

• 

---

• contains(element) :

• Returns true if the Iterable contains the element passed inside the contains() method.

• void main() {
   final Map<String,dynamic> mapOfNumbers = 
  {"0":"Zero","1":"One","2":"Two","3":"Three"};
  
   final List<String> listOfCar = ["Audi","BMW","Ferrari","Mercedes"];
  
   print(listOfCar.contains("BMW"));
   print(mapOfNumbers.values.contains("Five"));
  }
  

• 

---

• firstWhere()

• This will return the first encountered element which satisfies the condition given to the function.
• The function must return boolean value.
• This method takes two things: 1. The function which returns the value if a certain condition is satisfied & 2. orElse function which will be called when no condition is satisfied.

• void main() {
   final List<String> listOfCar = ["Audi","Audi A5","BMW","Ferrari","Mercedes"];
   print(listOfCar.firstWhere((element)=> element.startsWith("Au")));
  }
  

• 
• orElse

  void main() {
   final List<String> listOfCar = ["Audi","Audi A5","BMW","Ferrari","Mercedes"];
   print(listOfCar.firstWhere((element)=> element.startsWith("Zu"),orElse: ()=> "No Element Found"));
  }
  

• 

---

• where()

• Takes boolean function.
• This function will iterate over all the elements and checks if the condition given to the function is satisfied on that element.

• void main() {
   final List<String> listOfCar = ["Audi","Audi A5","BMW","Ferrari","Mercedes"];
   print(listOfCar.where((element)=> element.length > 4));
  }
  

• 

• Map:

• void main() {
   final Map<String,dynamic> mapOfNumbers = 
  {"0":"Zero","1":"One","2":"Two","3":"Three"};
   print(mapOfNumbers.values.where((element)=> element.length > 3));
  }
  

• 

---

• toSet() :

• Used to convert from type T to Set, where T can be : List,Map etc.
• The Set will remove duplicate element from previous iterable.

• void main() {
   final List listOfCar = ["Audi","Audi","BMW","Ferrari","Mercedes"];
   print(listOfCar.toSet());
  }
  

• 

---

• toList() :

• Used to convert any iterable to List.
• Takes one optional argument growable. If true we can further add elements in list, otherwise add() will not work.

• void main() {
   final Set<String> setOfCar = {"Audi","BMW","Ferrari","Mercedes"};
   print(setOfCar.toList());
  }
  

• 
• growable : true (default) :

• void main() {
   final Set<String> setOfCar = {"Audi","BMW","Ferrari","Mercedes"};
   final List listOfCar = setOfCar.toList();
   listOfCar.add("Jeep");
   print(listOfCar);
  }
  

• 
• growable : false :

• void main() {
   final Set<String> setOfCar = {"Audi","BMW","Ferrari","Mercedes"};
   final List listOfCar = setOfCar.toList(growable: false);
   listOfCar.add("Jeep");
   print(listOfCar);
  }
  

• 
• As you can see add is not working now.

---

• takeWhile() :

• This will return every element in a list from index 0 to the element that first satisfies the condition.

• void main() {
   final List<String> listOfCar = ["Audi","Audi A5","BMW","Ferrari","Mercedes","Audi A3"];
   final fileteredList =  listOfCar.takeWhile((element) => element.startsWith("Au"));
   print(fileteredList);
  }
  

• 

---

• take(int count) :

• This will return every element in a list from index 0 to the index specified in this method.

• void main() {
   final List<String> listOfCar = ["Audi","Audi A5","BMW","Ferrari","Mercedes","Audi A3"];
   final fileteredList =  listOfCar.take(3);
   print(fileteredList);
  }
  

• 

---

• skipWhile():

• Returns an iterable that skips leading elements while the provided predicate is satisfied.

• void main() {
   final List<String> listOfCar = ["Audi","Ferrari","BMW","Mercedes","Audi A3"];
   final fileteredList =  listOfCar.skipWhile((element)=> element.endsWith("i"));
   print(fileteredList);
  }
  

• 

---

• skip(int count) :

• This will skip every element in a list from index 0 to the index specified in this method and returns the remaining element.

• void main() {
   final List<String> listOfCar = ["Audi","Ferrari","BMW","Mercedes","Audi A3"];
  
   final fileteredList =  listOfCar.skip(3);
  
   print(fileteredList);
  }
  

• 

---

• singleWhere() :

• Returns the single element that satisfies a given condition.
• If no element is found this method will give an error. To handle this error using orElse
• This will also throw an error if any duplicate value is found.

• void main() {
   final List<String> listOfCar = ["Audi","Ferrari","BMW","Mercedes"];
  
   final fileteredList =  listOfCar.singleWhere((element)=> 
  element.startsWith("Au"),orElse:()=> "No Element Found");
  
   print(fileteredList);
  }
  

• 

---

• reduce():

• This will reduce a given iterable to a single value by combining elements of the iterable using a provided function.
• The iterable must have at least one element. If it has only one element, that element is returned.

• void main() {
  final List<int> listNumber = [1,2,3,4];
  final reduced =  listNumber.reduce((value,element){
    print("value: "+value.toString());
    print("element "+element.toString());
    return value+element;
  });
  print("total: "+reduced.toString());
  }
  

• 

---

• map() :

• Returns a brand new list.
• The function defined in map will run on each element.
• After that new list will be returned.

• void main() {
   final List<int> listNumber = [1,2,3,4];
   final filteredList = listNumber.map((element)=> element += 1);
   print(filteredList);
  }
  

• 

---

• lastWhere() :

• Returns the last element that satisfies the given condition.

• void main() {
   final List<int> listNumber = [1,2,3,4];
   final fileteredElement =  listNumber.lastWhere((element)=> element.isEven);
   print(fileteredElement);
  }
  

• 

---

• join() :

• Joins every element of the iterable with a given separator and returns it as String.

• void main() {
   final List<int> listNumber = [1,2,3,4];
   final fileteredElement =  listNumber.join(",");
   print(fileteredElement);
  }
  

• 

---

• forEach :

• The function defined inside forEach will run on every element of the iterable.
• The difference between map and forEach is forEach doesn't return a new list whereas map does.

• void main() {
   final List<int> listNumber = [1,2,3,4];
   listNumber.forEach((element)=> print(element * 2));
  }
  

• 

---

• followedBy() :

• If you want to add new iterable inside your current iterable then you can use followdBy() by passing your iterable inside it.

• void main() {
   final List listOfFruits = ["Apple","Banana","Carrot"];
   final newFruitList = listOfFruits.followedBy(["Dates","Emu"]);
   print(newFruitList);
  }
  

• 

---

• fold:

• It is the same as the reduce method.
• It reduces an iterable to a single value by iteratively combining each element of the collection with an existing value.

• void main() {
   final List<String> listOfFruits = ["Apple","Banana","Carrot"];
   listOfFruits.fold(0, (value, element) {
     print("value: "+value.toString());
     print("element: "+ element.toString());
     return value + element.length;
  });
  }
  

• 
• Difference between reduce and fold is: reduce can only be used on non-empty collections with functions that return the same type as the types contained in the collection whereas fold can be used in all cases.
• We cannot compute the sum of the length of all strings in a list with reduce but you can use fold to do that.

---

• expand :

• If you have nested iterables inside one main iterable and you want to extract out those iterables into one single iterable then you can use expand to do this.

• void main() {
   final nestedList = [["Apple","Banana","Carrot"],[1,2,3],[true,false]];
   final flattenedList = nestedList.expand((list)=>list);
   print(flattenedList);
  }
  

• 

• void main() {
   final listOfFruit = ["Apple","Banana","Carrot"];
   final duplicateFruits = listOfFruit .expand((element)=>[element,element]);
   print(duplicateFruits );
  }
  

• 

---

• every() :

• This method returns a boolean depending upon whether all elements satisfies the condition or not.

• void main() {
   final listOfFruits = ["Apple","A Banana","A Carrot"];
   final filteredList = listOfFruits.every((element) => element.startsWith("A"));
   print(filteredList);
  }
  

• 

---

• any() :

• Returns true if any element satisfies the given condition, otherwise false.

• void main() {
   List<int> listOfNumbers = [11,23,3,45,5];
   print(listOfNumbers.any((element)=> element.isEven));
  }
  

• 

---

• cast():

• This will return a new list with a given castType so that you can use it in places where the analyzer expects Iterable<Type>.
• This is a very rarely used method.
• Remember this will not cast an element of the iterable.
• It only gives an illusion to the analyzer that it got that type that it wanted.

• void main() {
   List<num> listOfNumbers = [5, 20, 12.5];
   List<double> castedDoubleList = listOfNumbers.cast<double>();
  
   print("casted list: "+castedDoubleList.toString());
   print("casted list type: "+castedDoubleList.runtimeType.toString());
   print("casted list element type: ");
   castedDoubleList.forEach((element)=> print(element.runtimeType)); 
  }
  

• 
• We can use this castedDoubleList if any function requires it. For example:

• void main() {
   List<num> listOfNumbers = [5, 20, 12.5];
   List<double> castedDoubleList = listOfNumbers.cast<double>();
  
   reverseDoubleList(castedDoubleList);
  }
  

  reverseDoubleList(List<double> doubleList){
   print(doubleList.reversed);
  }
  

• 

---

Wrapping Up

• These all are very useful methods and properties which are very handy during the development.
• Hope you liked it. Thanks for reading.
• Comments and Feedbacks are welcomed 🙂
•