함수형 프로그래밍

함수형 프로그래밍 (Functional Programming)

int number = -12345;
var result = number.abs().toString().contains('3');
print(result); // true

String word = 'abcd';
var index = word.toUpperCase().indexOf('B');
print(index); // 1

int add(int a, int b) {
	return a + b;
}

void main() {
	int result = add(3, 4);
	print(result);  // 7
}

순수 함수(Pure Function)

// 예시

int add(int a, int b) {
	return a + b;
}

int multiply(int a, int b) {
	return a * b;
}

int getTotal(List<int> numbers) {
	int result = 0;
	for (var number in numbers) {
		result += number;
	}
	return result;
}

// 비고: 부작용이 발생할 수 있는 경우

int number = 0;

void increaseNumber() {
	number += 1;
}

void main() {
	print(number);
	increaseNumber();
	print(number);
}

함수형 프로그래밍의 종류

형변환 함수 (Type Casting Function)

void main() {
int number = 42;
var result = number.toString();
print("$result, ${result.runtimeType}"); // 42, String
}

void main() {
  double number = 1.5;
  var result = number.toString();
  print("$result, ${result.runtimeType}"); // 1.5, String
}

void main() {
  String number = "123";
  var result = int.parse(number);
  print("$result, ${result.runtimeType}");  // 123, int
}

void main() {
  String actor = "박정민";
  var result = int.parse(actor);
  print(result);
} // Uncaught Error, error: Error: FormatException: 박정민

void main() {
  String actor = "박정민";
  var result = int.tryParse(actor);
  print(result); // null
}

void main() {
  Set<String> directorSet = {"박찬욱", "봉준호", "홍상수", "나홍진"};
  var directorList = directorSet.toList();
  print("$directorList, ${directorList.runtimeType}");
} // [박찬욱, 봉준호, 홍상수, 나홍진], List<String>

void main() {
  List<String> directorList = ["박찬욱", "봉준호", "홍상수", "나홍진"];
  var directorSet = directorList.toSet();
  print("$directorSet, ${directorSet.runtimeType}");
} // {박찬욱, 봉준호, 홍상수, 나홍진}, LinkedSet<String>

void main() {
  List<String> directorList = ["박찬욱", "봉준호", "홍상수", "나홍진"];
  var directorMap = directorList.asMap();
  print(directorMap);
} // {0: 박찬욱, 1: 봉준호, 2: 홍상수, 3: 나홍진}

Insight or Questions.

함수는 원본의 값을 바꾸는 것이 아니라 변환된 값을 반환하는 것.

void main() {
  String n = "123";
  int.parse(n);
  print(n.runtimeType); // String
  
  int m = 123;
  m.toString();
  print(m.runtimeType); // int
  
  bool k = false;
  k.toString();
  print(k.runtimeType); // bool
}

void main() {
  String n = "123";
  int a = int.parse(n);
  print(a.runtimeType); // int
  
  int m = 123;
  String b = m.toString();
  print(b.runtimeType); // String
  
  bool k = false;
  String c = k.toString();
	print("$c, ${c.runtimeType}"); // false, String

}

함수의 적용 방식 헷갈림.

void main() {
  String n = "123";
  int.parse(n);
  print(n.runtimeType); // String
  
  int m = 123;
  m.toString();
  print(m.runtimeType); // int
}

“누가 변환 기능을 갖고 있느냐”의 차이 때문이야.

변환 기능이 타입(int, double, DateTime 같은 타입 자체)에 붙어 있으면 → int.parse(n) -- 정적 메서드
변환 기능이 객체(String, int 같은 인스턴스)에 붙어 있으면 → m.toString() -- 객체 지향

즉, 변환 로직이 타입에 붙어 있느냐 / 객체에 붙어 있느냐에 따라 문법이 갈린다.

int.parse(n)은 “String을 int로 바꾸는 능력”이 int 타입 자체에 붙어 있다는 의미야.
Dart는 문자열이 int로 변환될 수 있는지 여부를 int 타입이 알고 있다고 본다.
그래서 변환 함수가 객체(String)에 붙어 있는 게 아니라, 타입(int)에 붙어 있음.

m.toString 의 경우는 정수값 123이라는 객체가 자신의 문자열 버전을 알고 있다.
이 구조는 “이 객체에게 서버 일을 시키는 문장”이야.
문법형식은 전형적인 OOP 방식: `객체.메서드()`
Dart의 모든 객체는 기본적으로 Object를 상속하니까, toString()은 모든 객체가 갖는 메서드야.

형변환 메서드가 타입에 속하면 TypeName.method(value) 형태가 되고,
형변환 메서드가 객체에 속하면 object.method() 형태가 된다.
이것이 문법 차이를 만든다.