Kotlin_제네릭 / 확장 / 함수형 프로그래밍

제네릭 타입 표준화된 명칭

 

↓ TakeIf, TakeUnless

https://medium.com/@limgyumin/%EC%BD%94%ED%8B%80%EB%A6%B0-%EC%9D%98-takeif-takeunless-%EB%8A%94-%EC%96%B8%EC%A0%9C-%EC%82%AC%EC%9A%A9%ED%95%98%EB%8A%94%EA%B0%80-f6637987780

 

/**
 * generic :
 * 클래스와 인터페이스 매개 변수 또는 함수의 매개 변수 반환 타입을 미리 확정하지 않고
 * 정의한 후에 사용되는 시점에서 특정 타입을 지정할 수 있도록 해주는 기법이 제네릭.
 *
 * 캐스팅을 방지 하여 성능 향상 가능.
 *
 * ( List는 Generic 인터페이스로 정의 됨 → 한 종류의 List 안에 다른 타입의 요소들을 저장할 수 있다.)
 *
 * 복합 제네릭 타입 매개변수
 *
 *
 * 제네릭 타입 제약 (type constraint)
 * - 원하지 않는 타입의 아이템은 저장하지 못하돌록 하고 싶을 때
 *
 *
 * vararg 와 get
 * : 가변인자 vararg  키워드 - 인자의 개수를 가변적으로 전달 가능.
 *
 * out 키워드 : Loot의 어떤 서브 클래스 인스턴스도 가변 인자로 받을 수 있다.
 * >> 코틀린에서는 in과 out 키워드를 사용하여 제네릭 타입 매개변수를 더 다양한 방법으로 조정할 수 있다.
 *
 *
 * reified 키워드
 *
 * */

// 제네릭 타입 정의하기
// 제네릭 타입 매개변수 T 를 갖는다. → 어떤 타입의 item도 받을 수 있으며, 그 private 속성인 loot에 지정한다.
// 어떤 단어나 문자여도 상관 없으나 표준화된 명칭을 따르는 것이 좋다.

// <T> → <T :  Loot> 로 타입 제약 : 즉 LootBox에는 어떤 종류이든 Loot 만 지정할 수 있음.
// LootBox에 vararg 키워드를 추가하면 매개변수가 배열로 처리되므로 여러 개의 아이템을 인자로 전달.
class LootBox<T : Loot>(vararg item: T)
{
    var open = false
    // private var loot: T = item
    private var loot: Array<out T> = item

    operator fun get(index : Int):T? = loot[index].takeIf { open }

    // 만약 open 이 false 이면 takeIf 에서 null을 반환하므로 T? 로 타입 지정.
    fun fetch(item: Int): T?{
        // return loot.takeIf{ open }
        return loot[item].takeIf{ open }

    }

    // 복합 제네릭 타입 매개변수
    fun <R> fetch(item: Int, lootModFunction: (T)->R):R? {
        return lootModFunction(loot[item]).takeIf { open }
    }
}

open class Loot (val value:Int)

// Fedora 와 Coin 에서 value 속성의 val을 삭제한 이유 : Loot 클래스에서 상속 되는 value 속성을 사용할 것이기 때문
class Fedora(val name:String,  value: Int) : Loot(value)
class Coin( value: Int) : Loot(value)




fun main() {
//    val lootBoxOne : LootBox<Fedora> = LootBox(Fedora("평범한 중절모",15))
//    val lootBoxTwo : LootBox<Coin> = LootBox(Coin(15))

//    lootBoxOne.open = true
//    lootBoxOne.fetch()?.run {
//        println("${name} 을 LootBox에서 꺼냈습니다.")
//    }
//
//    val fedora = lootBoxOne[1]
//    fedora?.let{println(it.name)}

    // 패러미터로 넘긴건 인스턴스 A
    UsingGeneric(A()).doShouting()
    UsingGeneric(B()).doShouting()
    UsingGeneric(C()).doShouting()

    doShouting(B())
}

fun <T:A> doShouting(t:T){
    t.shout()
}
open class A{
    open fun shout(){
        println("A 가 소리칩니다.")
    }
}

class B : A()
{
    override fun shout() {
        println("B가 소리칩니다.")
    }
}

class C : A()
{
    override fun shout() {
        println("C가 소리칩니다.")
    }
}

// 수퍼 클래스를 A로 제한한 제너릭 T 선언
class UsingGeneric<T: A> (val t:T){
    fun doShouting(){
        t.shout()
    }
}

 

 

확장.

/**
 * 함수의 확장은 클래스 상속 없이도 가능하다.
 *
 * 연쇄 호출 - 이후의 함수를 호출할 수 있는 객체를 이전 함수 호출에서 반환한다면 연속해서 여러 함수 호출 가능
 * 확장 함수에 추가하여 확장 속성도 정의할 수 있다.
 *
 * 산출 속성을 제외한 모든 클래스 속성은 데이터가 저장되는 후원 필드를 가지며, 게터와 세터가 자동 생성 됨.
 * 그러나 확장 속성은 산출 속성 처럼 후원 필드를 갖지 않는다.따라서 속성에서 반환될 값을 산출 하는 get 을 반드시 정의해야 함.
 *
 * 예를 들어 아래 코드는 컴파일 에러. Why? 확장 속성은 후원 필드를 갖지 않으므로 초기화할 수 없기 때문.
 * var String.preferredCharacters = 10
 * 따라서 var 대신 val 을 지정하고 원하는 값을 반환하는 get 을 정의해야 한다.
 *
 *
 * 코틀린의 모든 컬렉션 클래스와 인터페이스의 슈퍼 타입은 Iterable 이다.
 *
 *
 * 1. 새로운 "extension"폴더를 만든다.
 * 2. 해당 폴더 안의 .kt 파일에 private 확장 함수를 입력한다.
 * 3. private 을 없앤다.
 * 4. 해당 함수를 사용하고 싶은 다른 외부의 .kt 파일에서 import 를 해준다.
 * 5. import 주의 사항! import 문을 사용하고자 하는 .kt 의 제일 위에 지정(package가 있으면 그 담 줄에)
 * 6. import 해서 사용할 때 함수들을 함꼐 사용할 경우, as 키워드로 별칭을 지정하여 이름 충돌이 생기지 않게 할 수 있다.
 *
 */

// 확정 속성 : 아래 확장 속성은 문자열의 모음 개수를 산출한다.
val String.numVowels
    get()= count{"aeiouy".contains(it)}



// String 클래스에 확장 함수 추가하기
// 확장 함수를 정의 시에, 확장 함수 추가할 타입(수신자 타입 receiver type)
fun String.addEnthusiasm(amount:Int = 1) = this + "!".repeat(amount)



// Any 에서 확장 : 모든 타입에 대해 사용할 수 있다. → easyPrint는 Any의 모든 서브타입에서 사용할 수 있다.
// fun Any.easyPrint()  = println(this)
// ↓ 연쇄 호출 가능 하도록 변경 (generic 확장함수로 변경)
// : 매개변수인 T가 확장 함수의 수신자 타입으로 사용되고, Any 대신 T 타입으로 반환됨.
fun <T> T.easyPrint(): T{
    println(this)
    return this
}


// null 가능 타입에 확장 함수 추가하기
// infix : 하나의 인자를 갖는 확장 함수와 클래스 함수 모두에 사용할 수 있으며, 함수 호출 문법을 간결하게 해줌.
//         infix 키워드를 지정한 것을 중위 함수라고 하며,
//         중위 함수를 호출할 때는 수신자 객체와 함께 함수 호출 사이의 점(.)은 물론 이고 인자 주위의 괄호도 생략할 수 있다.
// 코틀린 중위 함수: shl, shr ushr, and, or , xor, inv
infix fun String?.printWithDefault(default: String) = print(this?: default)



fun main(){
    ("마드리갈이 그 건물에서 나왔습니다.".addEnthusiasm()).easyPrint()
    42.easyPrint()
    // 함수 호출 전과 후에서 easyPrint 함수를 각각 호출하게 변경/ 아래는 왜 에러가 날까?
    // > easyPrint 로 반환된 값이 Any 라서.
    // generic 으로 바꾼 후
    "마드리갈 그 건물에서 나옴".easyPrint().addEnthusiasm().easyPrint()

    // 확장 속성 사용하기
    "How many vowels?".numVowels.easyPrint()

    //infix 키워드 쓴 확장 함수 (중위 함수)
    null printWithDefault "기본 문자열"         // infix 키워드 지정된 중위 함수에서만 사용 가능
    null.printWithDefault("기본 문자열") // 중위 함수와 일반 함수 모두에서 사용 가능한 상태


}

//// shuffled.first() 이 함수가 자주 반복되었는데, 이런 중복된 코드는 확장 함수로 추출 한다.
//// ↓ 자주 반복 되는 것 확장 함수로 추출하기
//// shuffled와 first는 List와 Set 타입 모두에 대해 연쇄 호출됨. 따라서 두 타입 모두에 확장 함수를 사용할 수 있게 하려면
//// 두 타입의 슈퍼 타입인 Iterable을 수신자 타입으로 정의해야한다.
//private fun <T> Iterable<T>.random():T = this.shuffled().first()

//// 확장 함수 이름 변경해서 쓰기 as
//import mypkg.io.extractKey
//import mypkg.io.extractKey as extracKeyUtil
//
//
//val value1 = extractKey()
//val value2 = extracKeyUtil()

 

null 가능 타입의 확장 함수. 

 

함수형 프로그래밍

https://www.youtube.com/watch?v=6iZDjLvhMN8

 

시퀀스 / 성능 측정

/**
 * 시퀀스 : 내장된 지연(lazy) 컬렉션 타입
 *
 * asSequence 함수를 사용해서 List를 시퀀스로 쉽게 변환할 수 있다.
 *
 * 성능 측정
 * - 코드 성능을 알려주는 measureNanoTime , measureTimeInMillis
 * >> 
 * */


fun main() {
    val toList = (1..5000).toList().filter{it.isPrime()}.take(1000)

    // 위의 내용을 지연 시퀀스를 사용하면
    val oneThousandPrimes = generateSequence(3) {
        value -> value+1
    }.filter { it.isPrime() }.take(1000)
}

// 소수인지를 결정하는 Int 타입의 확장 함수
fun Int.isPrime(): Boolean{
    (2 until this).map{
        if(this % it == 0){
            return false
        }
    }
    return true
}


//