[Chapter3] - 함수 정의와 호출

val set = hashSetOf(1, 7, 53)  
val list = arrayListOf(1, 7, 53)  
val map = hashMapOf(1 to "one", 7 to "seven", 53 to "fifty-three")  

public fun <K, V> hashMapOf(vararg pairs: Pair<K, V>): HashMap<K, V> =
	HashMap<K, V>(mapCapacity(pairs.size)).apply { putAll(pairs) }  
  
public fun <K, V> MutableMap<in K, in V>.putAll(pairs: Array<out Pair<K, V>>): Unit {  
	for ((key, value) in pairs) {  
		put(key, value)  
	}  
}  

println(set.javaClass)  
println(list.javaClass)  
println(map.javaClass)  

val list = arrayListOf(1, 7, 53)  
  
// 출력 : [1, 7, 53]println(list)  

fun <T> joinToString(  
	collection: Collection<T>,  
	separator: String,  
	prefix: String,  
	postfix: String  
): String {  
	val result = StringBuilder(prefix)  
	for ((idx, element) in collection.withIndex()) {  
		if (idx > 0) result.append(separator)  
			result.append(element)  
	}  
	result.append(postfix)  
	return result.toString()  
}  

// 출력 : [1, 7, 53]println(list)  
// 출력 : {1 - 7 - 53}println(joinToString(list, " - ", "{", "}"))  

println(joinToString(list, " ", " ", "."))  

println(joinToString(list, separator = " ", prefix = " ", postfix = "."))  

// 컴파일 에러 발생 : Named arguments are not allowed for non-Kotlin functionsprintln(UtilClass.joinToString(list, separator = " - ", "{", "}"))  

fun main() {  
	println(joinToString(list))  
}  
  
fun <T> joinToString(  
	collection: Collection<T>,  
	separator: String = ", ",  
	prefix: String = "",  
	postfix: String = ""  
): String { ... }  

// separator 생략  
println(joinToString(list, prefix = "{", postfix = "}"))  

@JvmOverloads  
fun <T> joinToString(  
collection: Collection<T>,  
separator: String = ", ",  
prefix: String = "",  
postfix: String = ""  
): String { ... }  

// CollectionTest.kt 파일  
@file:JvmName("StringFunctions")  
  
package action.chapter03.part1  
  
import java.lang.StringBuilder  
  
@JvmOverloads  
fun <T> joinToString(  
	collection: Collection<T>,  
	separator: String = ", ",  
	prefix: String = "",  
	postfix: String = ""  
): String { ... }  

var opCount = 0  
val UNIX_LINE_SEPARATOR = "\n"  
  
fun performOperation() {  
	opCount++  
}  
  
fun reportOperationCount() {  
	println("Operation performed $opCount times")  
}  

const val UNIX_LINE_SEPARATOR = "\n"  

fun String.lastChar(): Char = this[this.length - 1]  

// String : 수신 객체 타입  
// this : 수신 객체  
fun String.lastChar(): Char = this[this.length - 1]  
// fun String.lastChar(): Char = get(length - 1)  
  
fun main() {  
	val ch = "Hello".lastChar()  
	  
	// 출력 : oprintln(ch)  
}  

// 특정 함수 importimport action.chapter03.part3.lastChar  
// 특정 함수 import에 대한 별칭 지정  
import action.chapter03.part3.lastChar as last  
// 전체 임포트  
import action.chapter03.part3.*  
  
val c = "Kotlin".lastChar()  
val c = "Kotlin".last()  

fun <T> Collection<T>.joinToString(  
separator: String = ", ",  
prefix: String = "",  
postfix: String = ""  
): String {  
	val result = StringBuilder(prefix)  
	for ((idx, element) in this.withIndex()) {  
		if (idx > 0) result.append(separator)  
		result.append(element)  
	}  
	result.append(postfix)  
	return result.toString()  
}  

// 출력 : 1, 7, 53val list = arrayListOf(1, 7, 53)  
println(list.joinToString(", "))  

fun Collection<String>.join(  
	separator: String = ", ",  
	prefix: String = "",  
	postfix: String = ""  
) = joinToString(separator, prefix, postfix)  
  
// 출력 : One, Two, Eightval strList = arrayListOf("One", "Two", "Eight")  
println("join = ${strList.join()}")  

open class View {  
	open fun click() = println("View clicked")  
}  
  
class Button : View() {  
	override fun click() = println("Button clicked")  
}  
  
fun main() {  
	// 출력 : Button clickedval view: View = Button()  
	view.click()  
}  

fun View.showOff() = println("I'm View!")  
fun Button.showOff() = println("I'm Button!")  
  
fun main() {  
	val view: View = Button()  
	  
	// 출력 : Button clickedview.click()  
	// 출력 : I'm View!view.showOff()  
}  

abstract class Foo<out T : Any> : IFoo {  
	abstract fun foo(a: Int): T  
}  
  
class FooImpl : Foo() {  
	constructor(x: String) : this(x) { /*...*/ }  
	val x = object : IFoo { /*...*/ }  
}  
  
val mutableCollection: MutableSet<String> = HashSet()  

val String.lastChar: Char  
get() = get(length - 1)  

var StringBuilder.lastChar: Char  
	get() = get(length - 1)  
	set(value) {  
		this.setCharAt(length - 1, value)  
	}  

// 출력 : nprintln("Kotlin".lastChar)  
  
val sb = StringBuilder("Kotlin?")  
sb.lastChar = '!'  
  
// 출력 : Kotlin!println(sb.toString())  
// 출력 : !println(sb.lastChar)  

fun main() {  
	val strings = listOf("first", "second", "fourteenth")  
	println(strings.last())  
	  
	val numbers = setOf(1, 14, 2)  
	println(numbers.max())  
}  

public fun <T> List<T>.last(): T {  
	if (isEmpty())  
		throw NoSuchElementException("List is empty.")  
	return this[lastIndex]  
}  
  
@Deprecated("Use maxOrNull instead.", ReplaceWith("this.maxOrNull()"))  
@DeprecatedSinceKotlin(warningSince = "1.4", errorSince = "1.5", hiddenSince = "1.6")  
@Suppress("CONFLICTING_OVERLOADS")  
public fun <T : Comparable<T>> Iterable<T>.max(): T? {  
	return maxOrNull()  
}  
  
@SinceKotlin("1.4")  
public fun <T : Comparable<T>> Iterable<T>.maxOrNull(): T? {  
	val iterator = iterator()  
	if (!iterator.hasNext()) return null  
	var max = iterator.next()  
	while (iterator.hasNext()) {  
		val e = iterator.next()  
		if (max < e) max = e  
	}  
	return max  
}  

val list = listOf(2, 3, 5, 7, 11)  

public fun <T> listOf(vararg elements: T): List<T> = /*...*/  

fun main() {  
	val args = arrayOf("First", "Second", "Third")  
	val argList = listOf("args: ", *args)  
	  
	println(argList)  
}  

val map = mapOf(1 to "One", 7 to "Seven", 53 to "fifty-three")  

public infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)  

1.to("One")  
1 to "One"  

val (number, name) = 1 to "One"  

val map = mapOf(1 to "One", 7 to "Seven", 53 to "fifty-three")  
for ((key, value) in map.entries) {  
	println("${key} = ${value}")  
}  

val list = listOf(2, 3, 5, 7, 11)  
  
for ((index, element) in list.withIndex()) {  
	println("${index} = ${element}")  
}  
  
list.forEachIndexed { index, element -> 
	println("${index} = ${element}")  
}  

fun main() {  
	val str = "12.345-6.A"  
	// .과 -을 기준으로 문자열을 분리하는 정규식을 명시적으로 만든다.  
	println(str.split("\\.|-".toRegex()))  
}  

println(str.split(".", "-"))  

fun main() {  
	val path = "/users/yole/kotlin-book/chapter.adoc"  
	parsePath(path)  
}  
  
fun parsePath(path: String) {  
	val directory = path.substringBeforeLast("/")  
	val fullName = path.substringAfterLast("/")  
	val fileName = fullName.substringBeforeLast(".")  
	val extension = fullName.substringAfterLast(".")  
	  
	// 출력 : dir : /users/yole/kotlin-book, name : chapter, ext : adocprintln("dir : ${directory}, name : ${fileName}, ext : ${extension}")  
}  

fun parsePathVer2(path: String) {  
	val regex = """(.+)/(.+)\.(.+)""".toRegex()  
	val mathResult = regex.matchEntire(path)  
	if (mathResult != null) {  
	val (dir, name, ext) = mathResult.destructured  
		println("dir : ${dir}, name : ${name}, ext : ${ext}")  
	}  
}  

val kotlinLogo = """| //  
| //  
|/ \"""  
println(kotlinLogo)  

val kotlinLogo = """| //  
.| //  
.|/ \"""  
println(kotlinLogo.trimMargin("."))  

class User(val id: Int, val name: String, val address: String)  
  
fun saveUser(user: User) {  
	if (user.name.isEmpty()) {  
		throw IllegalArgumentException("Can't save user ${user.id} : empty name")  
	}  
	if (user.address.isEmpty()) {  
		throw IllegalArgumentException("Can't save user ${user.id} : empty address")
	}  
	save(user)  
}  

fun saveUser(user: User) {  
	fun validate(value: String, fieldName: String) {  
	if (value.isEmpty()) {  
	// 바깥 함수 파라미터에 직접 접근할 수 있다.  
	throw IllegalArgumentException("Can't save user ${user.id} : empty $fieldName")  
	}  
	}  
	validate(user.name, "Name")  
	validate(user.address, "Address")  
	  
	save(user)  
}  

fun User.validateBeforeSave() {  
fun validate(value: String, fieldName: String) {  
if (value.isEmpty()) {  
throw IllegalArgumentException(  
"Can't save user $id : empty $fieldName"  
)  
}  
}  
  
validate(name, "Name")  
validate(address, "Address")  
}