[Scala] 함수 컴비네이터

컴비네이터란?

컬렉션을 변형한 후 동일한 자료형의 컬렉션을 반환하는 메소드

map(), foreach()

map()은 function을 이용해서 해당 컬렉션의 원소들을 변형시킨 후 새롭게 컬렉션을 만들어서 반환한다.

val list = List(2,4,6)
val minus_list = list.map(elem => elem - 1)
println(list) // Output : List(2,4,6)
println(minus_list) // Output : List(1,3,5)

foreach()는 map()과 마찬가지로 함수를 이용하지만 반환값이 없다.

var list = List(2,4,6)
list.foreach(elem => println(elem))
// Output 
// 2
// 4
// 6

filter(), filterNot()

filter()는 function을 활용해서 해당 function의 결과값이 true인 요소만 모아서 새로운 컬렉션을 만들어 반환한다.

val oo = List(1,2,3)
val nn = oo.filter(i => i >= 3) 
println(nn)
// Output List(3)

filterNot()은 filter와 반대 역할을 한다.

foldLeft(), foldRight(), partition()

fold의 의미인 '접다'처럼 왼쪽이나 오른쪽으로 요소를 접는 함수다.
두 개의 요소를 가져다가 하나로 만든다. 이를 최종적으로 하나의 값만 남을 때까지 반복한다.

val o = List(1,2,3,4)
val n = o.foldLeft(-1)((i,j)=>i+j)
println(n)
// Output 9
-1 + 1 + 2 + 3 + 4의 결과

foldRight()는 반대의 방향이다.

partition() 은 Boolean을 돌려주는 함수를 받아서 True인 요소와 False인 요소를 분리한다.

val o = List(1,2,3,4)
val n = o.partition(i => i > 3)
println(n)
// Output List(4), List(1,2,3)

:::() zip() unzip()

zip()은 ::: 과는 달리 튜플형태의 쌍으로 연결된 리스트를 돌려주고 unzip()은 zip()으로 묶어둔 리스트를 다시 풉니다.

val l1 = List(1,2,3)
val l2 = List(4,5,6)

val s1 = l1 zip l2
val s2 = l1 ::: l2

println(s1)
// Output List((1,4), (2,5), (3,6))

println(s2)
// Output List(1,2,3,4,5,6)

println(s1.unzip)
// Output (List(1, 2, 3),List(4, 5, 6))

특이한 점은 zip()은 짝이 안맞는 요소는 버린다는 것이다.

val l1 = List(1,2,3,4,5,6,7,8,9)
val l2 = List(10)

println(l1 zip l2)
// Output List((1,10))

find()

원하는 조건에 맞는 첫번째 요소를 Optional 형태로 반환한다.

val o = List(1,2,3,4)

println(o.find(i => i > 3))
// Output Some(4)

println(o.find(i => i > 10))
// Output None

drop(), dropWhile()

drop()은 인덱스를 받아서, 해당 인덱스까지의 모든 요소를 버린다.
dropWhile()은 조건식을 받아서 조건에 부합하는 요소를 모두 버린다. 단, 조건에 부합하지않는 요소가 하나라도 나타나면 그 즉시 중단한다.

val o = List(1,2,3,4,5,6,7,8)

val n = o.drop(4)
val nn = o.dropWhile(i => i > 3)
val nnn = o.dropWhile(i => i < 3)

println(n)
// Output List(5, 6, 7, 8, 9)

println(nn)
// Output List(1, 2, 3, 4, 5, 6, 7, 8, 9)

println(nnn)
// Output List(3, 4, 5, 6, 7, 8, 9)

flatten()

중첩된 리스트 등을 1차원으로 만들어주는 역할을 합니다.

val oo = List(1,2,3,4) :: List(5,6) :: Nil
val n = oo.flatten
println(n)
// Output List(1, 2, 3, 4, 5, 6)

================

이 글은 "누구나 쉽게 스칼라 + 플레이" 를 읽고 적었습니다.
한국인이 쓴 책이고 2016년 초판이라 읽기는 좋은데 중간중간 내용 오류가 있습니다. 그럼에도불구하고 '아예 초심자'가 감을 잡기에는 좋습니다. (가격이 비싼 건 흠입니다.)