//일반적인 변환함수
static double converter(double x, double f, double b){
  return x * f + b;
}

//사용할때마다 변환할 값과 함께 기준값을 지정해주어야 한다
converter(36.5, 9, 32);

//변환함수 팩토리함수
static DoubleUnaryOperator curriedConverter(double f, double b){
  return (double x) -> x * f + b;
}

//원하는대로 함수를 만들어 사용할 수 있다.
DoubleUnaryOperator convertCtoF = curriedConverter(9.0/5, 32);
DoubleUnaryOperator convertUSDtoGBP = curriedConverter(0.6, 0);
DoubleUnaryOperator convertKmtoMi = curriedConverter(0.6214, 0);

//사용할 때는 변환할 값만 apply한다.
convertCtoF.applyAsDouble(1000);

Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.base/java.util.stream.AbstractPipeline.<init>(AbstractPipeline.java:203)
	at java.base/java.util.stream.IntPipeline.<init>(IntPipeline.java:91)
	at java.base/java.util.stream.IntPipeline$StatefulOp.<init>(IntPipeline.java:655)
	at java.base/java.util.stream.SliceOps$2.<init>(SliceOps.java:231)
	at java.base/java.util.stream.SliceOps.makeInt(SliceOps.java:231)
	at java.base/java.util.stream.IntPipeline.skip(IntPipeline.java:410)
	at CHAPTER19.PrimeNumber.tail(Chapter19Main.java:23)
	at CHAPTER19.PrimeNumber.primes(Chapter19Main.java:30)
	at CHAPTER19.Chapter19Main.main(Chapter19Main.java:7)

package CHAPTER19;

import java.util.stream.IntStream;

public class Chapter19Main {
    public static void main(String[] args){
        PrimeNumber.primes(PrimeNumber.numbers()).forEach(System.out::println);
    }
}

class PrimeNumber{
    static IntStream numbers(){
        return IntStream.iterate(2, n -> n + 1);
    }

    static int head(IntStream numbers){
        return numbers.findFirst().getAsInt();
    }

    static IntStream tail(IntStream numbers){
        return numbers.skip(1);
    }

    static IntStream primes(IntStream numbers){
        int head = head(numbers);
        return IntStream.concat(
                IntStream.of(head),
                primes(tail(numbers).filter(n->n%head!=0))
        );
    }

}

package CHAPTER19;

import java.util.function.Predicate;
import java.util.function.Supplier;

public class MyLinkedListMain{
    public static void main(String args[]){
        /* 게으르게 재귀적으로 늘어나는 숫자 리스트 */
        System.out.println("1. ===========================");
        MyLinkedList<Integer> numbers = from(2);
        int two = primes(numbers).head();
        System.out.println(two);
        int three = primes(numbers).tail().head();
        System.out.println(three);
        int five = primes(numbers).tail().tail().head();
        System.out.println(five);

        /* 계속 수행하면 스택오버플로우가 발생한다 */
        System.out.println("2. ===========================");
        try{
            printAll(primes(from(2)));
        } catch(StackOverflowError e){
            //e.printStackTrace();
            System.out.println("stack overflow");
        } catch(IllegalStateException e){
            System.out.println("BREAK");
        }
    }

    public static MyLinkedList<Integer> primes(MyLinkedList<Integer> numbers){
        return new MyLinkedList<Integer>(
                numbers.head(),
                ()->primes(
                        numbers.tail()
                                .filter(n->{
                                            System.out.print("filter "+n+" by "+numbers.head()+"/ ");
                                            return (n%numbers.head()!=0);
                                        }
                                )
                ));
    }

    public static MyLinkedList<Integer> from(int n){
        System.out.print("from@"+n+"/ ");
        return new MyLinkedList<Integer>(n, ()->from(n+1));
    }

    public static void printAll(MyLinkedList<Integer> list){
        if(list.isEmpty()) return;
        System.out.println(list.head());
        printAll(primes(list.tail()));
    }
}

class MyLinkedList<T> implements MyList<T> {
    public static int cnt = 0;
    private final T head;
    private final Supplier<MyLinkedList<T>> tail;

    public MyLinkedList(T head, Supplier<MyLinkedList<T>> tail){
        this.head = head;
        this.tail = tail;
    }

    @Override
    public T head() {
        return head;
    }

    @Override
    public MyLinkedList<T> tail() {
        //제한을 둠
        if((int)head>=50) throw new IllegalStateException("BREAK");
        return tail.get();
    }

    @Override
    public boolean isEmpty(){
        return false;
    }

    public MyLinkedList<T> filter(Predicate<T> p){
        return isEmpty() ?
                this :
                p.test(head()) ? //평가한 tail이 head로 filter해서 나누어떨어지지 않으면
                        new MyLinkedList<T>(head(), ()->tail().filter(p)) : //참이면 소수이므로, 새로운 서플라이어를 전달하고 종료
                        tail().filter(p); //거짓이면 소수가 아니므로, tail을 다시 평가하고 filter를 재귀호출
    }
}

interface MyList<T>{
    T head();
    MyList<T> tail();
    default boolean isEmpty(){
        return true;
    }
}

class Empty<T> implements MyList<T>{
    @Override
    public T head(){
        throw new UnsupportedOperationException();
    }

    @Override
    public MyList<T> tail(){
        throw new UnsupportedOperationException();
    }
}

Expression simplyfyExpression(Expression expr){
	if(expr instanceof BiOperation
		&& ((BiOperation)expr).opname.equals("+")
		&& ((BiOperation)expr).right intanceof Number
		&& ((Number)((BiOperation)expr).right).value.equals(0))
			return (BiOperation)expr.left;
}

public class SimplifyVisitor{
	public Expr visit(BinOp e){
		if("+".equals(e.opname) && e.right.instanceof Number && ...){
			return e.left;
		}
		return e;
	}
}

class BinOp extends Expr{
	public Expr accept(SimplifyExprVisitor v){
		return v.visit(this);
	}
}

//사용
myIf(n%2==0, ()->42억*42억, ()->42억);
myIf(do(something).IsSucceed(), ()->successHandler, ()->failHandler);

//구현
static <T> T myIf(boolean b, Supplier<T> truecase, Supplier<T> falsecase){
	return b ? truecase.get() : falsecase.get();
}

//사용
simplify(new BiOperation("+", new Number(5), new Number(0)));

//구현
interface TriFunction<S, T, U, R>{
  R apply(S s, T t, U u);
}

static <T> T patternMatchExpr(
	Expr e,
  TriFunction<String, Expr, Expr, T> binopcase,
  Function<Integer, T> numcase,
  Supplier<T> defaultcase){
  
  return
    (e instanceof BinOp) ?
    	binopcase.apply(((BinOp)e).opname, ((BinOp)e).left,
                      									 ((BinOp)e).right) :
  	(e instanceof Number) ?
      numcase.apply(((Number)e).val) :
  		defaultcase.get();
}

public static Expr simplify(Expr e){
  TriFunction<String, Expr, Expr, Expr> binopcase = 
    (opname, left, right) -> {
  		if("+".equals(opname)){
        if(left instanceof Number && ((Number)left).val==0){
          return right;
        }
        if(right instanceof Number && ((Number)right).val==0){
          return left;
        }
      } 
    	if("*".equals(opname)){
        //do something;
      }
    	return new BinOp(opname, left, right);
  };
  Function<Integer, Expr> numcase = val -> new Number(val);
  Supplier<Expr> defaultcase = () -> new Number(0);
  
  return patternMatchExpr(e, binopcase, numcase, defaultcase);
}

final Map<Range, Integer> numberOfNodes = new HashMap<>();

//직접구현
Integer computeNumberOfNodesUsingCache(Range range){
	Integer result = numberOfNodes.get(range);
	if(result!=null) return result;
	result = computeNumberOfNodes(range);
	numberOfNodes.put(range, result);
	return result;
}

//computeIfAbsent사용
Integer computeNumberOfNodesUsingCache(Range range){
	return numberOfNodes.computeIfAbsent(range, this::computeNumberOfNodesUsingCache);
}

repeat(3, (Integer x) -> 2*x);

static <A> Function<A,A> repeat(int n, Function<A,A> f){
	return n==0 ? x->x : compose(f, repeat(n-1, f));
}