코틀린 (Kotlin) 함수형 프로그래밍


함수형 프로그래밍

  • 불변성(immutable)
  • 참조 투명성(referential transparency)
  • 일급 함수(first-class-function)
  • 게으른 평가(lazy evaluation)

순수한 함수

  • 동일한 입력->동일한 결과
  • 부수효과 없음
  • 부수효과...
    • 전역 변수, 객체 상태변경
    • 파일, 네트워크 출력
    • 예외발생

일급 함수

  • 함수를 함수 매개변수로 사용
  • 함수를 반환값으로 사용
  • 함수를 변수에 저장 가능

게으른 평가

val lazy: String by lazy {
   //long work...
}

print(lazy)
print(lazy)

값을 사용할 때 lazy{...} 작업이 실행되어 할당된다.
코드가 실행될때 할당되지 않기때문에 오래걸리는 작업을 필요할때 실행하여 작업을 효율적으로 동작가능.
val 로만 가능하며 최초 한번만 할당되고 두번째부터는 값이 재사용된다.

시퀀스(sequence)

val infinite = generatieSequence(0) { it + 10 }
infinite.take(10).forEach {println("$it")}

실제 사용할때 사용되기때문에 무한대 자료구조로서 사용할 수 있다.

Unit

public object Unit {
override fun toString() = "kotlin.Unit"
}
Unit 은 자바의 void 처럼 아무것도 반환하지 않을때 사용.
Unit 은 참조형 타입이다.


확장함수

private fun String.addHelloPrefix(): String = "Hello, ${this}"

if 조건 표현식

조건문을 구문과 표현식으로 사용할 수 있다.
표현식으로 사용된 경우 else 가 필요하며 변수에 할당할 수 있다.

val x: Int = 1
val y: Int = 2
val max: Int = if (x > y) x else y

when 조건

switch 와 동일하게 사용가능.
패턴 매칭 사용 가능.

fun checkValue(value: Any) = when (value) {
    "kotlin" -> "kotlin"
    in 1..10 -> "1..10"
    11, 15 -> "11 or 15"
    is User -> "User"
    else -> "SomeValue"
}

if else 처럼 동일하게 사용 가능.
when 에 value 없이 사용.

fun checkCondition(value: Any) = when {
    value == "kotlin" -> "kotlin"
    value in 1..10 -> "1..10"
    value === User("Joe", 76) -> "=== User" //주소값 비교
    value == User("Joe", 76) -> "== User(Joe, 76)"//데이터equls비교
    value is User -> "is User"
    else -> "SomeValue"
}

List<Int> 처럼 <Int> 를 패턴매칭 할 수 없다.

fun sum(numbers: List<Int>): Int = when {
    numbers.isEmpty() -> 0
    else -> numbers.first() + sum(numbers.drop(1))
}

for문

for((index, item) in collection.withIndex()) {
    println($index, $item)
}

for(i in 1..3)) {...}
for(i until 1..3) {...}
for(i in 6 downTo 0 step 2) {...}

인터페이스(interface)


  • 다중 상속
  • 추상 함수
  • 함수 본문 구현
  • 여러 인터페이스에서 같은 이름 함수 가능
  • 추상 프로퍼티
interface Foo {
    fun printFoo()
    fun printFoo2() {
        println("Foo2")
    }
    fun printKotlin() { println("Foo Kotlin") }
}

interface Bar {
    fun printBar()

    fun printKotlin() { println("Bar Kotlin") }

}

class Kotlin: Foo, Bar {
    override fun printFoo() {...}
    override fun printBar() {...}
    override fun printFoo2() { println("Kotlin-Foo2") } //kotlin.printFoo2()->"Kotlin-Foo2" 출력
    //다중 상속에서 동일한 함수 호출시
    overrde fun printKotlin() {
        super<Foo>.printKotlin()
        super<Bar>.printKotlin()
    }


}

추상 프로퍼티

인터페이스에서는 프로퍼티 초기화할 수 없으나 get() 으로 사용 가능하며 get() 있으면 override 하지 않아도 됨.

interface Foo {
    val bar: Int
        get() = 3
}
class Kotlin : Foo {
    override val bar: Int = 3
}

클래스(class)

class User(var name:String, val: age: Int = 20)
getter(), setter() 를 자동으로 생성.
기본값 설정 가능.

데이터 클래스(data class)

getter, setter, hashCode, equals, toString, copy, componentN 자동 생성 됨.

enum 클래스

enum class Error(val num: Int) {
    WARN(2) {
         override fun getErrorName():String {
             retrun "WARN"
         }
    }
    abstract fun getErrorName(): String
}

sealed 클래스

클래스를 묶은 클래스.
하위클래스는 sealed class와 동일한 파일에서만 선언 가능.


sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()

fun getSum(p1: Double, p2: Double): Sum {
    return Sum(Const(p1), Const(p2))
}

when 으로 패턴매칭이 가능하며 else 를 작성할 필요 없다.
fun eval(expr: Expr): Double = when(expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
}

객체 분해

componentN 함수가 객체 분해시 사용.

val user: User = User("kotlin", 20)
val (name, age) = user
val (name, _) = user //_는 사용안 할때
for ((name, age) in users) { ... }
{ p1, p2 -> "$p1, $p2" } // 매개변수 두개를 받음
{ (p1, p2) -> "$p1 $p2" } //튜플 하나로 받아 객체 분해

컬렉션

불변: List, Set, Map...
가변: MutableList, MutableSet, Mutablemap...

val list: List<Int> = listOf(1,2,3,4,5)
list.add(6) //컴파일 오류. List,Set 은 불변이기때문에 add함수가 없다
val newList = list.plus(6) //새로 생성해서 추가
list 출력 -> 1,2,3,4,5
newList 출력 -> 1,2,3,4,5,6

val list: MutableList<Int> = mutableListOf(1,2,3,4,5)
list.add(6) //정상

맵(map)

val map1 = mapOf(1 to "One", 2 to "Two") //{{1=one, 2=two}
val map2 = map1.plus(Pair(3, "Three")) //{1=one, 2=two, 3=three}

val mutablemap = mutableMapOf(1 to "One", 2 to "Two")
mutablemap.put(3, "Three")

제네릭

fun <T> head(list: list<T>) : T { ...}

let 함수

자신을 파라메터로 넘겨 마지막 블럭값을 리턴.
널처리에 사용.

 fun<T,R> T.let(block: (T) -> R): R
val name = user?.let { it.lastName + it.firstname } ?: "error"

with 함수

fun <T,R> with(receiver: T, block: T.() ->R): R

여기서 T.() 는 람다 리시버로 block 함수에서 this를 사용하지않고 함수나 프로퍼티에 접근할 수 있다.

val stringToInt : String.() -> Int = { toInt()  //String 함수 바로 접근 가능 }
val result = with(person) {
    name = "kotlin"
    age = 20
    this //객체 자체 접근시 this 사용
}

run 함수

1. fun <T,R> T.run(block: T.() ->R) : R
val result = person.run {
    name="kotlin"
    age = 20
    this
}

2. fun <R> run(block: () -> R): R
객체를 생성하기 위한 명령문을 하나의 블록으로 묶는 용도
코드 가독성 향상
val person = run {
    val name = "kotlin"
    val age = 20
    Person(name, age)
}

apply 함수

fun <T> T.apply(block: T.() -> Unit): T
block 함수 내에 반환값이 없고 자신을 반환.
객체만 변경할때 유용.

val result = person.apply {
   name = "kotlin"
   age = 20
}
run 함수와 다르게 this 없이 person객체를 바로 할당 가능


also 함수

fun <T> T.also(block: (T) -> Unit): T
객체 자체를 변경할 때 사용.
val result = person.also {
    it.name = "kotlin"
    it.age = 20
}

*apply, also 는 빌더패턴과 동일한 용도로 사용


close 함수

closeable object 를 제공하는 객체에 대해 클로즈 작업을 자동으로 해줌
FileInputStream("...").use { property.load(it) } // 자동 close

공변 <out T>

타입 S가 T의 하위 타입일 때 Box[S]가 Box[T] 의 하위 타입인 것
kotlin < jvm < language 상속 관계가 존재할 때,

covariant(languageBox) //컴파일 오류
covariant(jvmBox)
covariant(kotlinBox)

fun covariant(value: Box<out JVM>)  {...}

반공변 <int T>

타입 S가 T의 하위 타입일 때 Box[S]가 Box[T] 의 상위 타입인 것

covariant(languageBox)
covariant(jvmBox)
covariant(kotlinBox) //컴파일 오류

fun covariant(value: Box<in JVM>)  {...}

in, out 키워드에서 in은 입력값(set) 에서만 사용할수 있고 out은 반환값(get)에서만 사용할 수 있음


댓글

댓글 쓰기

이 블로그의 인기 게시물

코틀린 (Kotlin) filter, map, all, any, count, find, groupBy, flatMap 함수 정리

filter 함수 filter 함수는 리스트를 이터레이션하면서 리턴이 true 인 값만 필터링합니다. var listInts = listOf(1,2,3,4) //filter listInts. filter { it % 2 == 0 } //출력 [2,4] map 함수 map 함수는 값을 변형해서 새로운 리스트를 생성합니다. var listInts = listOf(1,2,3,4) listInts. map { it * it } //출력 [1,4,9,16] val people = listOf(Person("A", 27), Person("B", 35), Person("C", 35)) listInts. map { it.name } //출력 [A, B, C] //심플한 방법 people. map (Person::name) //30살이상의 이름 출력 people. filter { it.age >= 30 }. map (Person::name) //가장 나이가 많은 사람들 모두 출력하기 //1. 최대값을 구하는 반복작업이 쓸데없이 많은 코드 people. filter { it.age == (people.maxBy(Person::age)!!.age) } //매번 maxBy 호출 //2. 계산이 중복되는것을 피하자. 람다안에 람다를 넣는것은 내부 로직을 매우 복잡하게 할 수 있음 val maxAge = people. maxBy (Person::age)!!.age //외부로 빼서 불필요한 반복 제거 people. filter { it.age == maxAge } //맵 사용 //map 에는 filterKeys, mapKeys 와 filterValues, mapValues 함수가 있음 val numbers = mapOf (0 to "zero", 1 to "one") val upperNumbers = numbers.ma
자세한 내용 보기

코틀린 (Kotlin) 인터페이스 정리

인터페이스 코틀린의 인터페이스는 자바와 같이 interface 로 시작합니다. interface Clickable {     fun click() } interface 를 구현할 때는 [클래스: 인터페이스] 형식으로 구현됩니다. extends(확장)과 implements(구현) 둘 다 :(콜론) 으로 구현합니다. 코틀린은 1개의 상속과 여러개의 인터페이스를 구현할 수 있습니다. 그리고 override 변경자를 사용해서 자바의 @Override 를 대신합니다. 만약에 override 된 함수 이름과 다른 함수 이름이 중복될경우 둘중 하나는 다른 이름을 사용해야 됩니다. //클래스 상속이나 구현은 : 으로 구분 class Button : Clickable, View { //Clickable은 interface, View 는 상속      override fun click() {           //구현시 override 필수     } } 디폴트 메소드 자바8 에서는 디폴트 메소드인경우 default 를 붙이지만 코틀린에서는 따로 추가되는 변경자가 없이 함수를 구현하면 됩니다. interface Clickable {     fun click()     fun showOff() = Log.d("Clickable showoff") //디폴트 메소드 } 디폴트 메소드는 override 를 하지않은 경우 디폴트로 사용되는 함수 입니다. 같은 함수 이름을 갖는 interface 디폴트 함수 이름이 같은 두개의 인터페이스를 구현해야되는 경우를 생각해봅니다. 디폴트 함수 이름이 같은 이름인 인터페이스를 정의하면 컴파일 에러 가 발생합니다. interface Clickable {     fun click()     fun showOff() = Log.d("Clickable showoff") } interface Focusable {     fu
자세한 내용 보기

RecyclerView 에서 notifyItemChanged()의 payload 이해하기

이미지
noti fyItemChanged()의  payload RecyclerView를 사용하다 보면 특정 position 항목만 갱신해야 될 때가 있습니다. 예를들어 버튼을 클릭했을 때, RecyclerView의 마지막 항목만 애니메이션하거나 마지막 항목의 텍스트나 이미지를 업데이트할 수 있습니다. 안드로이드 RecyclerView는 Adapter의  onCreateViewHolder() ,   onBindViewHolder() 를 override해서 구현합니다. 보통 특정 position 항목만 갱신할 때는 notifyItemChanged(position) 을 사용하고 여러개가 변경된 경우 notifyItemRangeChanged(positionStart, itemCount) 을 사용합니다. 하지만  onBindViewHolder() 는 대부분 뷰를 초기화 작업들이 있기 때문에 모든 View를 업데이트하지 않고 특정 View만 Animation 한다던가 TextView의 text만 변경하는 작업들을 하고 싶을 때는 뭔가 조건문으로 처리해야 할 필요성이 생깁니다. 그래서 Recycerview에 payload라는 기능이 추가되었습니다. payload란 무엇일까? notifyItemChanged(position, payload) 에서 payload는 아답터의  onBindViewHolder()가  호출될 때 넘겨받는 객체입니다. 특정 position의 holder를 업데이트할 때 payload 값으로 구분하여 애니메이션 하거나 뷰를 업데이트할 수도 있습니다. 사용하는 방법? notifyItemChanged(int position, Object payload) 업데이트하고 싶은 position 항목에게 payload를 전달합니다. notifyItemRangeChanged(int positionStart, int itemCount, Object payload) 업데이트하고 싶은 범위를 지정하여 모든 항목에 payload를 전
자세한 내용 보기