Dart (4) - 함수형 프로그래밍

void main(){
 List<String> blackPink = ['로제','지수','리사','제니','제니'];
 
 print(blackPink); //[로제, 지수, 리사, 제니, 제니]
 print(blackPink.asMap()); // {0: 로제, 1: 지수, 2: 리사, 3: 제니, 4: 제니}
 print(blackPink.toSet()); // list를 set로 & 중복 처리 {로제, 지수, 리사, 제니}

 
 Map blackPinkMap = blackPink.asMap();
 
 print(blackPinkMap.keys); // (0, 1, 2, 3, 4)
 print(blackPinkMap.values); // (로제, 지수, 리사, 제니, 제니)

 print(blackPinkMap.keys.toList()); // [0, 1, 2, 3, 4]
 print(blackPinkMap.values.toList()); // [로제, 지수, 리사, 제니, 제니]
 
 
 Set blackPinkSet = Set.from(blackPink); // list로부터 set 만드는 방법 중 하나 

 print(blackPinkSet); // {로제, 지수, 리사, 제니}
 print(blackPinkSet.toList()); // set를 list로 만들기 [로제, 지수, 리사, 제니]
}

map

• 맵핑을 통해 새로운 맵을 만들고 싶을 때

• 키값 혹은 밸류값만 리스트로 만들고 싶을 때
  맵을 쓰면 새로운 리스트가 계속 만들어짐
  완전히 같은 멤버를 가지고 있더라도 newAespa 와 newAespa2는 다른 리스트로 인식

  void main(){
   List<String> aespa = ['카리나','윈터','닝닝','지젤'];
   
   final newAespa = aespa.map((x){
     return '에스파 $x';
   });
   
   print(aespa);
   print(newAespa.toList());
   
   final newAespa2 = aespa.map((x)=> '에스파 $x');
   
   print(newAespa2.toList());
   
   print(aespa == aespa); // true
   print(newAespa == aespa); // false
   print(newAespa == newAespa2); // false
  }

  void main(){
   Map<String, String> harryPotter = {
     'Harry' : '해리',
     'Ron' : '론',
     'Hermione' : '헤르미온느',
   };
   
   final result = harryPotter.map(
     (key, value) => MapEntry(
       'Harry Potter Character $key',
       '해리포터 캐릭터 $value',
     )
   );
   
   print(result); // {Harry Potter Character Harry: 해리포터 캐릭터 해리, Harry Potter Character Ron: 해리포터 캐릭터 론, Harry Potter Character Hermione: 해리포터 캐릭터 헤르미온느}
  
   final keys = harryPotter.keys.map((x) => 'HPC $x').toList();
   final values = harryPotter.values.map((x) => '해리포터 $x').toList();
   
   print(keys); // [HPC Harry, HPC Ron, HPC Hermione]
   print(values); // [해리포터 해리, 해리포터 론, 해리포터 헤르미온느]
  }

  set 역시 mapping 가능

  void main(){
   Set aespaSet = {
     '카리나',
     '윈터',
     '닝닝',
     '지젤',
   };
   
   final newSet = aespaSet.map((x)=> '에스파 $x').toSet();
   
   print(newSet); // {에스파 카리나, 에스파 윈터, 에스파 닝닝, 에스파 지젤}
  }

  where

  작동하는 방식은 map과 같음, true 값만 keep 하고 false 값은 없앰.

  void main(){
   List<Map<String, String>> people = [
     {
       'name':'카리나',
       'group':'에스파',
     },
     {
       'name':'윈터',
       'group':'에스파',
     },
     {
       'name':'RM',
       'group':'BTS',
     },
     {
       'name':'V',
       'group':'BTS',
     },
   ];
  
   
   final aespa = people.where((x)=> x['group']=='에스파');
   final bts = people.where((x)=> x['group']=='BTS');
   
   print(aespa); // ({name: 카리나, group: 에스파}, {name: 윈터, group: 에스파})
   print(bts); // ({name: RM, group: BTS}, {name: V, group: BTS})
  }

  reduce

  reduce를 실행하는 리스트의 타입과 같은 타입을 리턴해줘야 실행할 수 있음

  void main(){
   List<int> numbers = [1,3,5,7,9];
   final result = numbers.reduce((prev, next)=>prev+next);
   print(result); // 25
   
   List<String> words = ['안녕하세요 ','저는 ','솜입니다.'];
   final sentence = words.reduce((prev,next)=> prev+next);
   print(sentence); // 안녕하세요 저는 솜입니다.
  }

  fold

  reduce의 단점 보완 (리턴타입 일치해야한다는)
  fold는 어떤 값이 리턴될 건지 정해주어야함.

  void main(){
   List<int> numbers = [1,3,5,7,9];
  
   final sum = numbers.fold<int>(0, (prev, next)=> prev+next);
  //   prev 첫번째 값이 1이 아닌 첫번째 파라미터의 값인 0으로 들어감
   print(sum); // 25 
   
   List<String> words = ['안녕하세요 ','저는 ','솜입니다.'];
   final sentence = words.fold<String>('', (prev,next)=> prev+next);
   print(sentence); // 안녕하세요 저는 솜입니다.
   
   final count = words.fold<int>(0, (prev,next)=> prev+next.length);
   print(count); // 14
  }

  cascading operator

  void main(){
   List<int> even = [2,4,6,8];
   List<int> odd = [1,3,5,7];
   
   print([even, odd]); // [[2, 4, 6, 8], [1, 3, 5, 7]]
   print([...even, ...odd]); // [2, 4, 6, 8, 1, 3, 5, 7]
  }

  함수형 프로그래밍 연습

  void main(){
   List<Map<String, String>> people = [
     {
       'name':'카리나',
       'group':'에스파',
     },
     {
       'name':'윈터',
       'group':'에스파',
     },
     {
       'name':'RM',
       'group':'BTS',
     },
     {
       'name':'V',
       'group':'BTS',
     },
   ];
  
   final result = people.map(
     (x)=> Person(
       name: x['name']!,
       group: x['group']!,
     ),
   ).where((x)=>x.group == 'BTS');
   
   print(result); // (Person(name:RM, group:BTS), Person(name:V, group:BTS))
  }

class Person{
final String name;
final String group;

Person({
required this.name,
required this.group,
});

@override
String toString(){
return 'Person(name:$name, group:$group)';
}
}