Function를 언어별로 비교하기

// String 확장 함수
fun String.isValidEmail(): Boolean =
    contains("@") && contains(".") && length > 5

// Int 확장 함수
fun Int.isEven() = this % 2 == 0
fun Int.factorial(): Long {
    if (this < 0) throw IllegalArgumentException("음수 불가")
    return (1..this).fold(1L) { acc, n -> acc * n }
}

// Nullable 수신자
fun String?.orEmpty(): String = this ?: ""

// Generic 확장 함수
fun <T> List<T>.secondOrNull(): T? =
    if (size >= 2) this[1] else null

fun main() {
    println("dev@kotlin.io".isValidEmail())  // true
    println(4.isEven())                       // true
    println(5.factorial())                    // 120

    val nullStr: String? = null
    println(nullStr.orEmpty())               // ""

    println(listOf(1, 2, 3).secondOrNull())  // 2
    println(listOf(1).secondOrNull())        // null
}

<span class="cm">// FastAPI 기초 예제
// data/prompts.js의 생성 프롬프트로 상세 코드 생성 가능</span>
fun main() { println("FastAPI 기초") }

package main

import (
	"errors"
	"fmt"
	"strconv"
)

// 다중 반환값 — Go의 관용구
func divide(a, b float64) (float64, error) {
	if b == 0 {
		return 0, errors.New("0으로 나눌 수 없습니다")
	}
	return a / b, nil
}

// Named return values
func minMax(nums []int) (min, max int) {
	min, max = nums[0], nums[0]
	for _, n := range nums[1:] {
		if n < min { min = n }
		if n > max { max = n }
	}
	return // naked return
}

// 가변 인자
func sum(nums ...int) int {
	total := 0
	for _, n := range nums { total += n }
	return total
}

// 함수를 값으로 (일급 함수)
func apply(fn func(int) int, vals []int) []int {
	result := make([]int, len(vals))
	for i, v := range vals {
		result[i] = fn(v)
	}
	return result
}

func main() {
	// 에러 처리 패턴
	result, err := divide(10, 3)
	if err != nil {
		fmt.Println("에러:", err)
	} else {
		fmt.Printf("%.4f
", result)
	}

	_, err = divide(5, 0)
	if err != nil { fmt.Println(err) }

	// Named return
	lo, hi := minMax([]int{3, 1, 4, 1, 5, 9, 2, 6})
	fmt.Println("min:", lo, "max:", hi)

	// 가변 인자
	fmt.Println(sum(1, 2, 3, 4, 5))
	nums := []int{1, 2, 3}
	fmt.Println(sum(nums...)) // 슬라이스 전개

	// 고차 함수
	doubled := apply(func(n int) int { return n * 2 }, nums)
	fmt.Println(doubled)

	_ = strconv.Itoa(0)
}

import java.util.function.*;

public class Lambdas {
    public static void main(String[] args) {
        // 기본 람다
        Runnable r = () -> System.out.println("실행!");
        r.run();

        // Function<T, R> — T 입력, R 출력
        Function<String, Integer> strLen = String::length;
        Function<Integer, Integer> double_ = n -> n * 2;
        Function<String, Integer> composed = strLen.andThen(double_);
        System.out.println(composed.apply("Hello")); // 10

        // Predicate<T> — boolean 반환
        Predicate<String> notEmpty = s -> !s.isEmpty();
        Predicate<String> longStr  = s -> s.length() > 5;
        Predicate<String> both     = notEmpty.and(longStr);
        System.out.println(both.test("Hello World")); // true

        // Consumer<T> — 반환 없음
        Consumer<String> print = System.out::println;
        Consumer<String> printUpper = s -> System.out.println(s.toUpperCase());
        print.andThen(printUpper).accept("java");

        // Supplier<T> — 인자 없음
        Supplier<String> greeting = () -> "Hello, Java!";
        System.out.println(greeting.get());

        // BiFunction<T, U, R>
        BiFunction<Integer, Integer, Integer> add = Integer::sum;
        System.out.println(add.apply(3, 4)); // 7

        // UnaryOperator, BinaryOperator
        UnaryOperator<Integer>   square = n -> n * n;
        BinaryOperator<Integer> multiply = (a, b) -> a * b;
        System.out.println(square.apply(5));    // 25
        System.out.println(multiply.apply(3,4)); // 12
    }
}

<?php
function createUser(string $name, string $role = 'member', bool $active = true): array {
    return compact('name', 'role', 'active');
}

print_r(createUser(name: 'mida', active: false));

// 기본 함수 선언
function add(a, b) {
  return a + b;
}
console.log(add(1, 2));

// 기본 함수 선언
function add(a: number, b: number): number {
  return a + b;
}
console.log(add(1, 2));

// 기본 함수 선언
using System;

int Add(int a, int b) => a + b;
Console.WriteLine(Add(1, 2));

// 기본 함수 선언
#include <iostream>

int add(int a, int b) { return a + b; }
int main() {
    std::cout << add(1, 2) << "\n";
}

// 기본 함수 선언
fn add(a: i32, b: i32) -> i32 { a + b }
fn main() {
    println!("{}", add(1, 2));
}