Pink Spider Pink-Spider

spring:
  datasource:
    url: jdbc:postgresql://localhost:5433/your_database_name
    username: your_db_username
    password: your_db_password
    driver-class-name: org.postgresql.Driver
  
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
        format_sql: true

# SSH 터널 설정 (커스텀 프로퍼티)
app:
    ssh:
      tunnel:
        host: your-ssh-server.com
        port: 22
        username: ssh_username
        private-key-path: ~/.ssh/id_rsa
        local-port: 5433
        remote-host: localhost  # SSH 서버에서 본 DB 호스트
        remote-port: 5432       # 실제 PostgreSQL 포트

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.postgresql:postgresql'
    implementation 'com.github.mwiede:jsch:0.2.17'
    
    // 기타 필요한 의존성들...
}

sudo apt update
sudo apt install postgresql postgresql-contrib

sudo systemctl status postgresql

sudo -i -u postgres
psql

CREATE USER myuser WITH PASSWORD 'mypassword';
CREATE DATABASE mydb OWNER myuser;

function add(a, b, c) {
    return a + b + c;
}

add(1, 2, 3); // 6

function curriedAdd(a) {
    return function(b) {
        return function(c) {
            return a + b + c;
        };
    };
}

curriedAdd(1)(2)(3); // 6

const curriedAdd = a => b => c => a + b + c;

const result = curriedAdd(1)(2)(3); // 6

const curriedAdd = a => b => c => a + b + c;

// 부분 적용
const add5 = curriedAdd(5);
const add5And3 = add5(3);

console.log(add5And3(2)); // 10 (5 + 3 + 2)
console.log(add5(4)(1)); // 10 (5 + 4 + 1)

const hasSubstring = substring => str => str.includes(substring);

const hasReact = hasSubstring('React');
const hasVue = hasSubstring('Vue');

console.log(hasReact('React 개발자')); // true
console.log(hasVue('Vue.js 프레임워크')); // true

// 배열에서 활용
const frameworks = ['React', 'Angular', 'Vue', 'Svelte'];
const reactItems = frameworks.filter(hasReact);
console.log(reactItems); // ['React']

const multiply = a => b => a * b;
const divide = a => b => a / b;

const double = multiply(2);
const triple = multiply(3);
const half = divide(1/2); // 또는 multiply(0.5)

console.log(double(5)); // 10
console.log(triple(4)); // 12

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(double);
console.log(doubled); // [2, 4, 6, 8, 10]

const log = level => message => {
    console.log(`[${level}] ${message}`);
};

const logError = log('ERROR');
const logInfo = log('INFO');

logError('데이터베이스 연결 실패'); // [ERROR] 데이터베이스 연결 실패
logInfo('서버 시작됨'); // [INFO] 서버 시작됨

const apiRequest = method => url => data => {
    return fetch(url, {
        method: method,
        headers: { 'Content-Type': 'application/json' },
        body: data ? JSON.stringify(data) : undefined
    });
};

const get = apiRequest('GET');
const post = apiRequest('POST');
const put = apiRequest('PUT');

// 사용
get('/api/users')();
post('/api/users')({ name: '김철수', email: 'kim@example.com' });

function curry(fn) {
    return function curried(...args) {
        if (args.length >= fn.length) {
            return fn.apply(this, args);
        } else {
            return function(...nextArgs) {
                return curried.apply(this, args.concat(nextArgs));
            };
        }
    };
}

// 사용 예
function add(a, b, c) {
    return a + b + c;
}

const curriedAdd = curry(add);

console.log(curriedAdd(1)(2)(3)); // 6
console.log(curriedAdd(1, 2)(3)); // 6
console.log(curriedAdd(1)(2, 3)); // 6
console.log(curriedAdd(1, 2, 3)); // 6

const _ = require('lodash');

const add = (a, b, c) => a + b + c;
const curriedAdd = _.curry(add);

console.log(curriedAdd(1)(2)(3)); // 6

const R = require('ramda');

const users = [
    { name: '김철수', age: 25 },
    { name: '이영희', age: 30 },
    { name: '박민수', age: 35 }
];

const getProperty = R.curry((prop, obj) => obj[prop]);
const getName = getProperty('name');

const names = users.map(getName);
console.log(names); // ['김철수', '이영희', '박민수']

import java.util.function.Function;

public class CurryingExample {
    
    // 3개 인자를 받는 함수를 커링
    public static Function<Integer, Function<Integer, Function<Integer, Integer>>> 
           curriedAdd() {
        return a -> b -> c -> a + b + c;
    }
    
    public static void main(String[] args) {
        // 사용 예
        Function<Integer, Function<Integer, Function<Integer, Integer>>> add = curriedAdd();
        
        int result1 = add.apply(1).apply(2).apply(3); // 6
        System.out.println(result1);
        
        // 부분 적용
        Function<Integer, Function<Integer, Integer>> add5 = add.apply(5);
        Function<Integer, Integer> add5And3 = add5.apply(3);
        
        int result2 = add5And3.apply(2); // 10
        System.out.println(result2);
    }
}

import java.util.function.Function;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StringCurrying {
    
    // 문자열 포함 검사 함수
    public static Function<String, Function<String, Boolean>> contains() {
        return substring -> str -> str.contains(substring);
    }
    
    // 문자열 변환 함수
    public static Function<String, Function<String, String>> replace() {
        return target -> replacement -> str -> str.replace(target, replacement);
    }
    
    public static void main(String[] args) {
        List<String> frameworks = Arrays.asList("React", "Angular", "Vue", "Svelte");
        
        // 부분 적용된 함수 생성
        Function<String, Boolean> hasReact = contains().apply("React");
        
        // 스트림과 함께 사용
        List<String> reactItems = frameworks.stream()
            .filter(hasReact::apply)
            .collect(Collectors.toList());
        
        System.out.println(reactItems); // [React]
        
        // 문자열 치환
        Function<String, String> replaceJavaWithKotlin = 
            replace().apply("Java").apply("Kotlin");
        
        String result = replaceJavaWithKotlin.apply("I love Java programming");
        System.out.println(result); // I love Kotlin programming
    }
}

import java.util.function.*;

public class CurryUtil {
    
    // 2개 인자 함수 커링
    public static <A, B, R> Function<A, Function<B, R>> 
           curry(BiFunction<A, B, R> function) {
        return a -> b -> function.apply(a, b);
    }
    
    // 3개 인자 함수를 위한 함수형 인터페이스
    @FunctionalInterface
    public interface TriFunction<A, B, C, R> {
        R apply(A a, B b, C c);
    }
    
    // 3개 인자 함수 커링
    public static <A, B, C, R> Function<A, Function<B, Function<C, R>>> 
           curry(TriFunction<A, B, C, R> function) {
        return a -> b -> c -> function.apply(a, b, c);
    }
    
    public static void main(String[] args) {
        // BiFunction 커링
        BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
        Function<Integer, Function<Integer, Integer>> curriedMultiply = curry(multiply);
        
        Function<Integer, Integer> double_ = curriedMultiply.apply(2);
        System.out.println(double_.apply(5)); // 10
        
        // TriFunction 커링
        TriFunction<Integer, Integer, Integer, Integer> add3 = (a, b, c) -> a + b + c;
        Function<Integer, Function<Integer, Function<Integer, Integer>>> curriedAdd3 = curry(add3);
        
        int result = curriedAdd3.apply(1).apply(2).apply(3);
        System.out.println(result); // 6
    }
}

public class MathOperations {
    
    public static class CurriedAdd {
        private final int first;
        
        private CurriedAdd(int first) {
            this.first = first;
        }
        
        public static CurriedAdd of(int first) {
            return new CurriedAdd(first);
        }
        
        public CurriedAddSecond with(int second) {
            return new CurriedAddSecond(first, second);
        }
        
        public class CurriedAddSecond {
            private final int second;
            
            private CurriedAddSecond(int first, int second) {
                this.second = second;
            }
            
            public int and(int third) {
                return first + second + third;
            }
        }
    }
    
    public static void main(String[] args) {
        int result = CurriedAdd.of(1).with(2).and(3); // 6
        System.out.println(result);
        
        // 부분 적용
        CurriedAdd add5 = CurriedAdd.of(5);
        CurriedAdd.CurriedAddSecond add5And3 = add5.with(3);
        
        int result2 = add5And3.and(2); // 10
        System.out.println(result2);
    }
}

import java.util.function.Function;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.URI;

public class CurriedHttpClient {
    
    public static Function<String, Function<String, Function<String, HttpRequest>>> 
           httpRequest() {
        return method -> url -> body -> {
            HttpRequest.Builder builder = HttpRequest.newBuilder()
                .uri(URI.create(url));
            
            switch (method.toUpperCase()) {
                case "GET":
                    builder.GET();
                    break;
                case "POST":
                    builder.POST(HttpRequest.BodyPublishers.ofString(body));
                    break;
                case "PUT":
                    builder.PUT(HttpRequest.BodyPublishers.ofString(body));
                    break;
            }
            
            return builder.build();
        };
    }
    
    public static void main(String[] args) {
        // 부분 적용된 함수들 생성
        Function<String, Function<String, HttpRequest>> get = 
            httpRequest().apply("GET");
        Function<String, Function<String, HttpRequest>> post = 
            httpRequest().apply("POST");
        
        // 사용
        HttpRequest getRequest = get.apply("https://api.example.com/users").apply("");
        HttpRequest postRequest = post.apply("https://api.example.com/users")
            .apply("{\"name\":\"김철수\"}");
        
        System.out.println("GET: " + getRequest.uri());
        System.out.println("POST: " + postRequest.uri());
    }
}