[Design Patterns] 18. 함수형 프로그래밍과 디자인 패턴: 패러다임의 진화

1
2
3
4
5
6

import java.util.*;
import java.util.function.*;
import java.util.stream.*;
import java.util.concurrent.*;
import java.util.concurrent.atomic.*;
import java.time.Duration;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

// 이 글의 여러 절(Strategy, Factory, Monad, 성능 벤치마크)이 공통으로 참조하는 도메인 타입
enum UserRole { USER, ADMIN, PREMIUM, MANAGER }

final class PaymentResult {
    private final String method;
    private final double amount;
    private final boolean success;

    public PaymentResult(String method, double amount, boolean success) {
        this.method = method;
        this.amount = amount;
        this.success = success;
    }

    public String getMethod() { return method; }
    public double getAmount() { return amount; }
    public boolean isSuccess() { return success; }

    @Override
    public String toString() {
        return method + " $" + amount + " (" + (success ? "성공" : "실패") + ")";
    }
}

class User {
    private final String name;
    private final String email;
    private final UserRole role;

    public User(String name, String email, UserRole role) {
        this.name = name;
        this.email = email;
        this.role = role;
    }

    public String getName() { return name; }
    public String getEmail() { return email; }
    public UserRole getRole() { return role; }
}

// User와 필드 구성은 같지만, 관리자 전용 로직을 얹을 확장 지점으로 타입을 분리한다
class Admin extends User {
    public Admin(String name, String email, UserRole role) {
        super(name, email, role);
    }
}

class UserRequest {
    private final String name;
    private final String domain;
    private final boolean manager;
    private final boolean admin;
    private final boolean premium;

    // FunctionalFactoryDemo에서 사용하는 3개 인자 생성자 (일반 사용자/매니저 후보)
    public UserRequest(String name, String domain, boolean manager) {
        this(name, domain, manager, false, false);
    }

    // conditionalFactory처럼 관리자·프리미엄 여부까지 필요한 전체 생성자
    public UserRequest(String name, String domain, boolean manager, boolean admin, boolean premium) {
        this.name = name;
        this.domain = domain;
        this.manager = manager;
        this.admin = admin;
        this.premium = premium;
    }

    public String getName() { return name; }
    public String getDomain() { return domain; }
    public String getEmail() { return name.toLowerCase() + "@" + domain; }
    public boolean isManager() { return manager; }
    public boolean isAdmin() { return admin; }
    public boolean isPremium() { return premium; }
}

// "성능과 실용성 분석" 절의 전통적 Observer 패턴 벤치마크에서만 사용하는 타입
interface Observer {
    void update(String message);
}

class Subject {
    private final List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) { observers.add(observer); }
    public void removeObserver(Observer observer) { observers.remove(observer); }
    public void notifyObservers(String message) {
        observers.forEach(o -> o.update(message));
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

// 전통적인 객체지향 Strategy 패턴
interface PaymentStrategy {
    PaymentResult process(double amount);
}

class CreditCardStrategy implements PaymentStrategy {
    @Override
    public PaymentResult process(double amount) {
        return new PaymentResult("Credit Card", amount, true);
    }
}

class PayPalStrategy implements PaymentStrategy {
    @Override
    public PaymentResult process(double amount) {
        return new PaymentResult("PayPal", amount, true);
    }
}

class PaymentProcessor {
    private PaymentStrategy strategy;
    
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public PaymentResult processPayment(double amount) {
        return strategy.process(amount);
    }
}

// 함수형 접근법 - 함수가 곧 전략
@FunctionalInterface
interface PaymentFunction {
    PaymentResult apply(double amount);
}

class FunctionalPaymentProcessor {
    // 전략들을 함수로 정의
    public static final PaymentFunction CREDIT_CARD = 
        amount -> new PaymentResult("Credit Card", amount, true);
    
    public static final PaymentFunction PAYPAL = 
        amount -> new PaymentResult("PayPal", amount, true);
    
    public static final PaymentFunction CRYPTOCURRENCY = 
        amount -> new PaymentResult("Crypto", amount, amount <= 10000);
    
    // 함수 합성으로 복합 전략 생성
    public static PaymentFunction withLogging(PaymentFunction payment) {
        return amount -> {
            System.out.println("Processing payment: $" + amount);
            PaymentResult result = payment.apply(amount);
            System.out.println("Result: " + result);
            return result;
        };
    }
    
    public static PaymentFunction withRetry(PaymentFunction payment, int maxRetries) {
        return amount -> {
            for (int i = 0; i < maxRetries; i++) {
                try {
                    PaymentResult result = payment.apply(amount);
                    if (result.isSuccess()) {
                        return result;
                    }
                } catch (Exception e) {
                    if (i == maxRetries - 1) {
                        throw e;
                    }
                    System.out.println("Retry attempt: " + (i + 1));
                }
            }
            return new PaymentResult("Failed", amount, false);
        };
    }
    
    public static PaymentFunction conditional(
            Predicate<Double> condition, 
            PaymentFunction primary, 
            PaymentFunction fallback) {
        return amount -> condition.test(amount) ? 
            primary.apply(amount) : fallback.apply(amount);
    }
    
    // 실제 처리
    public PaymentResult processPayment(double amount, PaymentFunction strategy) {
        return strategy.apply(amount);
    }
}

// 사용 예시
public class FunctionalStrategyDemo {
    public static void main(String[] args) {
        FunctionalPaymentProcessor processor = new FunctionalPaymentProcessor();
        
        // 기본 전략 사용
        PaymentResult result1 = processor.processPayment(100.0, 
            FunctionalPaymentProcessor.CREDIT_CARD);
        
        // 함수 합성으로 향상된 전략
        PaymentFunction enhancedStrategy = FunctionalPaymentProcessor.withLogging(
            FunctionalPaymentProcessor.withRetry(
                FunctionalPaymentProcessor.PAYPAL, 3
            )
        );
        
        PaymentResult result2 = processor.processPayment(100.0, enhancedStrategy);
        
        // 조건부 전략 (고액은 암호화폐, 소액은 신용카드)
        PaymentFunction smartStrategy = FunctionalPaymentProcessor.conditional(
            amount -> amount > 1000,
            FunctionalPaymentProcessor.CRYPTOCURRENCY,
            FunctionalPaymentProcessor.CREDIT_CARD
        );
        
        PaymentResult result3 = processor.processPayment(1500.0, smartStrategy);
        
        // 람다로 즉석 전략
        PaymentResult result4 = processor.processPayment(50.0, amount -> {
            if (amount < 100) {
                return new PaymentResult("Quick Pay", amount, true);
            } else {
                return FunctionalPaymentProcessor.CREDIT_CARD.apply(amount);
            }
        });
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

// 함수형 Reactive Observer
public class ReactiveEventStream<T> {
    private final List<Consumer<T>> observers = new CopyOnWriteArrayList<>();
    private final List<Predicate<T>> filters = new ArrayList<>();
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
    
    // 기본 구독
    public Subscription subscribe(Consumer<T> observer) {
        observers.add(observer);
        return () -> observers.remove(observer);
    }
    
    // 필터링과 함께 구독
    public ReactiveEventStream<T> filter(Predicate<T> predicate) {
        ReactiveEventStream<T> filtered = new ReactiveEventStream<>();
        this.subscribe(event -> {
            if (predicate.test(event)) {
                filtered.emit(event);
            }
        });
        return filtered;
    }
    
    // 변환과 함께 구독
    public <R> ReactiveEventStream<R> map(Function<T, R> mapper) {
        ReactiveEventStream<R> mapped = new ReactiveEventStream<>();
        this.subscribe(event -> {
            try {
                R transformed = mapper.apply(event);
                mapped.emit(transformed);
            } catch (Exception e) {
                System.err.println("Mapping error: " + e.getMessage());
            }
        });
        return mapped;
    }
    
    // 디바운싱 (연속된 이벤트 중 마지막만 처리)
    public ReactiveEventStream<T> debounce(Duration delay) {
        ReactiveEventStream<T> debounced = new ReactiveEventStream<>();
        AtomicReference<ScheduledFuture<?>> lastTask = new AtomicReference<>();
        
        this.subscribe(event -> {
            ScheduledFuture<?> currentTask = lastTask.get();
            if (currentTask != null) {
                currentTask.cancel(false);
            }
            
            ScheduledFuture<?> newTask = scheduler.schedule(
                () -> debounced.emit(event),
                delay.toMillis(),
                TimeUnit.MILLISECONDS
            );
            lastTask.set(newTask);
        });
        
        return debounced;
    }
    
    // 스로틀링 (지정된 시간 간격으로만 이벤트 처리)
    public ReactiveEventStream<T> throttle(Duration interval) {
        ReactiveEventStream<T> throttled = new ReactiveEventStream<>();
        AtomicLong lastEmit = new AtomicLong(0);
        
        this.subscribe(event -> {
            long now = System.currentTimeMillis();
            long last = lastEmit.get();
            
            if (now - last >= interval.toMillis()) {
                if (lastEmit.compareAndSet(last, now)) {
                    throttled.emit(event);
                }
            }
        });
        
        return throttled;
    }
    
    // 여러 스트림 결합
    public static <T> ReactiveEventStream<T> merge(ReactiveEventStream<T>... streams) {
        ReactiveEventStream<T> merged = new ReactiveEventStream<>();
        
        for (ReactiveEventStream<T> stream : streams) {
            stream.subscribe(merged::emit);
        }
        
        return merged;
    }
    
    // 에러 처리
    public ReactiveEventStream<T> onErrorContinue(Consumer<Exception> errorHandler) {
        ReactiveEventStream<T> errorHandled = new ReactiveEventStream<>();
        
        this.subscribe(event -> {
            try {
                errorHandled.emit(event);
            } catch (Exception e) {
                errorHandler.accept(e);
            }
        });
        
        return errorHandled;
    }
    
    public void emit(T event) {
        observers.forEach(observer -> {
            try {
                observer.accept(event);
            } catch (Exception e) {
                System.err.println("Observer error: " + e.getMessage());
            }
        });
    }
    
    public void shutdown() {
        scheduler.shutdown();
    }
    
    @FunctionalInterface
    interface Subscription {
        void unsubscribe();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// 실제 사용 예시
public class ReactivePatternDemo {
    public static void main(String[] args) throws InterruptedException {
        ReactiveEventStream<String> userActions = new ReactiveEventStream<>();
        
        // 복잡한 이벤트 처리 파이프라인
        ReactiveEventStream<String> processedActions = userActions
            .filter(action -> action.startsWith("CLICK"))  // 클릭 이벤트만
            .debounce(Duration.ofMillis(300))              // 300ms 디바운싱
            .map(action -> "Processed: " + action.toUpperCase()) // 변환
            .throttle(Duration.ofSeconds(1));              // 1초 스로틀링
        
        // 구독자 등록
        Subscription sub1 = processedActions.subscribe(action -> 
            System.out.println("Subscriber 1: " + action));
        
        Subscription sub2 = processedActions.subscribe(action -> 
            System.out.println("Subscriber 2: " + action));
        
        // 이벤트 발생
        userActions.emit("CLICK_BUTTON_1");
        userActions.emit("CLICK_BUTTON_2");  // 디바운싱으로 무시됨
        userActions.emit("CLICK_BUTTON_3");  // 디바운싱으로 무시됨
        Thread.sleep(400);
        userActions.emit("CLICK_BUTTON_4");  // 처리됨
        Thread.sleep(1200);
        userActions.emit("CLICK_BUTTON_5");  // 처리됨
        
        Thread.sleep(2000);
        
        // 구독 해제
        sub1.unsubscribe();
        sub2.unsubscribe();
        userActions.shutdown();
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

// 함수형 Factory 패턴
public class FunctionalFactory {
    
    // 기본 생성 함수들
    public static final Function<String, User> createUser = 
        name -> new User(name, "user@example.com", UserRole.USER);
    
    public static final Function<String, Admin> createAdmin = 
        name -> new Admin(name, "admin@example.com", UserRole.ADMIN);
    
    // 고차 함수로 팩토리 커스터마이징
    public static Function<String, User> withEmail(String emailDomain) {
        return name -> new User(name, name.toLowerCase() + "@" + emailDomain, UserRole.USER);
    }
    
    public static Function<String, User> withRole(UserRole role) {
        return name -> new User(name, "default@example.com", role);
    }
    
    // 함수 합성으로 복잡한 팩토리 생성
    public static Function<UserRequest, User> compositeUserFactory(
            Function<UserRequest, String> nameExtractor,
            Function<UserRequest, String> emailExtractor,
            Function<UserRequest, UserRole> roleExtractor) {
        
        return request -> new User(
            nameExtractor.apply(request),
            emailExtractor.apply(request),
            roleExtractor.apply(request)
        );
    }
    
    // 조건부 팩토리 (함수형 Abstract Factory)
    public static Function<UserRequest, User> conditionalFactory() {
        return request -> {
            if (request.isAdmin()) {
                return createAdmin.apply(request.getName());
            } else if (request.isPremium()) {
                return withRole(UserRole.PREMIUM).apply(request.getName());
            } else {
                return createUser.apply(request.getName());
            }
        };
    }
    
    // 빌더 패턴의 함수형 변형
    public static class UserBuilderFunction {
        
        public static Function<String, Function<String, Function<UserRole, User>>> 
                curry() {
            return name -> email -> role -> new User(name, email, role);
        }
        
        // 부분 적용(Partial Application)
        public static Function<String, Function<UserRole, User>> 
                withFixedEmail(String email) {
            return name -> role -> new User(name, email, role);
        }
        
        // 체이닝 가능한 빌더
        public static UserBuilder builder() {
            return new UserBuilder();
        }
        
        public static class UserBuilder {
            private Function<String, User> builder = name -> new User(name, "default@example.com", UserRole.USER);
            
            public UserBuilder withEmail(String email) {
                Function<String, User> currentBuilder = builder;
                builder = name -> {
                    User user = currentBuilder.apply(name);
                    return new User(name, email, user.getRole());
                };
                return this;
            }
            
            public UserBuilder withRole(UserRole role) {
                Function<String, User> currentBuilder = builder;
                builder = name -> {
                    User user = currentBuilder.apply(name);
                    return new User(name, user.getEmail(), role);
                };
                return this;
            }
            
            public User build(String name) {
                return builder.apply(name);
            }
        }
    }
}

// 사용 예시
public class FunctionalFactoryDemo {
    public static void main(String[] args) {
        // 기본 팩토리 사용
        User user1 = FunctionalFactory.createUser.apply("John");
        
        // 커스터마이징된 팩토리
        Function<String, User> corporateUserFactory = 
            FunctionalFactory.withEmail("company.com");
        User employee = corporateUserFactory.apply("Alice");
        
        // 함수 합성으로 복잡한 팩토리
        Function<UserRequest, User> complexFactory = 
            FunctionalFactory.compositeUserFactory(
                UserRequest::getName,
                req -> req.getName().toLowerCase() + "@" + req.getDomain(),
                req -> req.isManager() ? UserRole.MANAGER : UserRole.USER
            );
        
        UserRequest request = new UserRequest("Bob", "company.com", true);
        User manager = complexFactory.apply(request);
        
        // 커링 사용
        Function<String, Function<String, Function<UserRole, User>>> curry = 
            FunctionalFactory.UserBuilderFunction.curry();
        
        User user2 = curry
            .apply("Charlie")
            .apply("charlie@company.com")
            .apply(UserRole.ADMIN);
        
        // 빌더 패턴의 함수형 버전
        User user3 = FunctionalFactory.UserBuilderFunction.builder()
            .withEmail("david@company.com")
            .withRole(UserRole.MANAGER)
            .build("David");
    }
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310

// Maybe Monad (Optional의 확장)
public abstract class Maybe<T> {
    
    public abstract boolean isPresent();
    public abstract T get();
    
    public static <T> Maybe<T> of(T value) {
        return value != null ? new Some<>(value) : new None<>();
    }
    
    public static <T> Maybe<T> empty() {
        return new None<>();
    }
    
    // Functor 구현
    public abstract <U> Maybe<U> map(Function<T, U> mapper);
    
    // Monad 구현
    public abstract <U> Maybe<U> flatMap(Function<T, Maybe<U>> mapper);
    
    // Applicative 구현
    public static <T, U, R> Maybe<R> lift2(
            Function<T, Function<U, R>> f, 
            Maybe<T> maybeT, 
            Maybe<U> maybeU) {
        return maybeT.flatMap(t -> maybeU.map(u -> f.apply(t).apply(u)));
    }
    
    // 유틸리티 메서드들
    public abstract Maybe<T> filter(Predicate<T> predicate);
    public abstract T orElse(T defaultValue);
    public abstract T orElseGet(Supplier<T> supplier);
    public abstract Maybe<T> or(Supplier<Maybe<T>> alternative);
    
    // Some 구현
    private static class Some<T> extends Maybe<T> {
        private final T value;
        
        Some(T value) {
            this.value = value;
        }
        
        @Override
        public boolean isPresent() {
            return true;
        }
        
        @Override
        public T get() {
            return value;
        }
        
        @Override
        public <U> Maybe<U> map(Function<T, U> mapper) {
            try {
                return Maybe.of(mapper.apply(value));
            } catch (Exception e) {
                return Maybe.empty();
            }
        }
        
        @Override
        public <U> Maybe<U> flatMap(Function<T, Maybe<U>> mapper) {
            try {
                return mapper.apply(value);
            } catch (Exception e) {
                return Maybe.empty();
            }
        }
        
        @Override
        public Maybe<T> filter(Predicate<T> predicate) {
            return predicate.test(value) ? this : Maybe.empty();
        }
        
        @Override
        public T orElse(T defaultValue) {
            return value;
        }
        
        @Override
        public T orElseGet(Supplier<T> supplier) {
            return value;
        }
        
        @Override
        public Maybe<T> or(Supplier<Maybe<T>> alternative) {
            return this;
        }
    }
    
    // None 구현
    private static class None<T> extends Maybe<T> {
        
        @Override
        public boolean isPresent() {
            return false;
        }
        
        @Override
        public T get() {
            throw new NoSuchElementException("No value present");
        }
        
        @Override
        public <U> Maybe<U> map(Function<T, U> mapper) {
            return Maybe.empty();
        }
        
        @Override
        public <U> Maybe<U> flatMap(Function<T, Maybe<U>> mapper) {
            return Maybe.empty();
        }
        
        @Override
        public Maybe<T> filter(Predicate<T> predicate) {
            return this;
        }
        
        @Override
        public T orElse(T defaultValue) {
            return defaultValue;
        }
        
        @Override
        public T orElseGet(Supplier<T> supplier) {
            return supplier.get();
        }
        
        @Override
        public Maybe<T> or(Supplier<Maybe<T>> alternative) {
            return alternative.get();
        }
    }
}

// Either Monad (성공/실패 처리)
public abstract class Either<L, R> {
    
    public abstract boolean isLeft();
    public abstract boolean isRight();
    public abstract L getLeft();
    public abstract R getRight();
    
    public static <L, R> Either<L, R> left(L value) {
        return new Left<>(value);
    }
    
    public static <L, R> Either<L, R> right(R value) {
        return new Right<>(value);
    }
    
    // Functor
    public abstract <T> Either<L, T> map(Function<R, T> mapper);
    
    // Monad
    public abstract <T> Either<L, T> flatMap(Function<R, Either<L, T>> mapper);
    
    // Error handling
    public abstract Either<L, R> mapLeft(Function<L, L> mapper);
    public abstract <T> Either<T, R> mapError(Function<L, T> mapper);
    
    // Left 구현
    private static class Left<L, R> extends Either<L, R> {
        private final L value;
        
        Left(L value) {
            this.value = value;
        }
        
        @Override
        public boolean isLeft() { return true; }
        
        @Override
        public boolean isRight() { return false; }
        
        @Override
        public L getLeft() { return value; }
        
        @Override
        public R getRight() {
            throw new NoSuchElementException("Right value on Left");
        }
        
        @Override
        public <T> Either<L, T> map(Function<R, T> mapper) {
            return Either.left(value);
        }
        
        @Override
        public <T> Either<L, T> flatMap(Function<R, Either<L, T>> mapper) {
            return Either.left(value);
        }
        
        @Override
        public Either<L, R> mapLeft(Function<L, L> mapper) {
            return Either.left(mapper.apply(value));
        }
        
        @Override
        public <T> Either<T, R> mapError(Function<L, T> mapper) {
            return Either.left(mapper.apply(value));
        }
    }
    
    // Right 구현
    private static class Right<L, R> extends Either<L, R> {
        private final R value;
        
        Right(R value) {
            this.value = value;
        }
        
        @Override
        public boolean isLeft() { return false; }
        
        @Override
        public boolean isRight() { return true; }
        
        @Override
        public L getLeft() {
            throw new NoSuchElementException("Left value on Right");
        }
        
        @Override
        public R getRight() { return value; }
        
        @Override
        public <T> Either<L, T> map(Function<R, T> mapper) {
            return Either.right(mapper.apply(value));
        }
        
        @Override
        public <T> Either<L, T> flatMap(Function<R, Either<L, T>> mapper) {
            return mapper.apply(value);
        }
        
        @Override
        public Either<L, R> mapLeft(Function<L, L> mapper) {
            return this;
        }
        
        @Override
        public <T> Either<T, R> mapError(Function<L, T> mapper) {
            return Either.right(value);
        }
    }
}

// 함수형 서비스 구현 예시
public class FunctionalUserService {
    
    public Either<String, User> createUser(UserRequest request) {
        return validateRequest(request)
            .flatMap(this::checkUserNotExists)
            .flatMap(this::createUserEntity)
            .flatMap(this::saveUser)
            .flatMap(this::sendWelcomeEmail);
    }
    
    private Either<String, UserRequest> validateRequest(UserRequest request) {
        if (request.getName() == null || request.getName().trim().isEmpty()) {
            return Either.left("Name is required");
        }
        if (request.getEmail() == null || !request.getEmail().contains("@")) {
            return Either.left("Valid email is required");
        }
        return Either.right(request);
    }
    
    private Either<String, UserRequest> checkUserNotExists(UserRequest request) {
        // 실제로는 데이터베이스 체크
        if (userExists(request.getEmail())) {
            return Either.left("User already exists: " + request.getEmail());
        }
        return Either.right(request);
    }
    
    private Either<String, User> createUserEntity(UserRequest request) {
        try {
            User user = new User(request.getName(), request.getEmail(), UserRole.USER);
            return Either.right(user);
        } catch (Exception e) {
            return Either.left("Failed to create user: " + e.getMessage());
        }
    }
    
    private Either<String, User> saveUser(User user) {
        try {
            // 실제로는 데이터베이스 저장
            return Either.right(user);
        } catch (Exception e) {
            return Either.left("Failed to save user: " + e.getMessage());
        }
    }
    
    private Either<String, User> sendWelcomeEmail(User user) {
        try {
            // 실제로는 이메일 발송
            return Either.right(user);
        } catch (Exception e) {
            return Either.left("Failed to send welcome email: " + e.getMessage());
        }
    }
    
    private boolean userExists(String email) {
        // 실제 구현
        return false;
    }
}