YangSiJun528 · September 8, 2025 07:38
diff --git a/2-17,2-18,2-20,2-21,2-23.js b/2-17,2-18,2-20,2-21,2-23.js
 // 2-17

 function last_pair(items) {
    return is_null(tail(items))
    ? head(items)
    : last_pair(tail(items));
 }

 const odds = list(1, 3, 5, 7);
 last_pair(odds);

 const odds2 = list(1, 3, 5, 7, 9);
 last_pair(odds2);


 // 2-18

 function reverse(items) {
    function reverse_iter(items, rs) {
        return is_null(items)
                ? rs
                : reverse_iter(tail(items),
                        pair(head(items), rs));
    }
    return reverse_iter(items, null);
 }

 reverse(list(1, 4, 5, 9, 16, 25));


 // 2-20
 function plus_curried(x) {
    return y => x + y;
 }

 // function brooks(curried, items) {
 //     return is_null(tail(items))
 //         ? curried(head(items)) 
 //         : brooks(curried(head(items)), tail(items));
 // }

 // 이게 좀 더 나은 이유가, 위 방식이면 체크를 한 번 더 할듯?
 function brooks(curried, items) {
    return is_null(items)
        ? curried 
        : brooks(curried(head(items)), tail(items));
 }

 brooks(plus_curried, list(3, 4));

 function brooks_curried(items) {
    return brooks(head(items), tail(items));
 }
 brooks_curried(list(plus_curried, 3, 4));


 // 2-21

 // function square_list(items) {
 //     return is_null(items)
 //             ? null
 //             : pair(head(items) * head(items), square_list(tail(items)));
 // }
 // square_list(list(1, 2, 3, 4));

 function square_list(items) {
    return map(x => x*x, items);
 }
 square_list(list(1, 2, 3, 4));


 // 2-23
 function for_each(fun, items) {
    if (is_null(items)) {
        return null;
    }
    else {
        fun(head(items));
        for_each(fun, tail(items));
    }
    return true;
 }

 for_each(x => display(x), list(57, 321, 88));
diff --git a/2-27,2-28,2-30,2-31.js b/2-27,2-28,2-30,2-31.js
 // 2-27

 const x = list(list(1, 2), list(3, 4));

 function deep_reverse(items) {
    function reverse_iter(items, rs) {
        return is_null(items)
            ? rs
            : !is_pair(head(items))
            ? reverse_iter(tail(items), pair(head(items), rs))  // 그냥 값이면 그대로 붙임, 순서가 없는 상태일꺼니까
            : reverse_iter(tail(items), pair(deep_reverse(head(items)), rs)); // pair면 재귀로 반대로 붙임
            // 소트 머지 정렬이랑 알고리즘이 비슷함
    }
    return reverse_iter(items, null);
 }
 deep_reverse(x);


 // 2-28

 // const x = list(list(1, 2), list(3, 4));
 function fringe(items) {
    if (is_null(items)) {
        // 리스트가 비었으면 null
        return null;
    } else if (!is_pair(items)) {
        // 원자(leaf)면, 그 값을 하나짜리 리스트로
        return pair(items, null);
    } else {
        // pair라면 head와 tail을 각각 fringe로 구해서 이어 붙인다
        return append(fringe(head(items)), fringe(tail(items)));
    }
 }
 fringe(x);



 // 2-30
 function square_tree(tree) {
    return is_null(tree)
        ? null
        : ! is_pair(tree)
        ? tree * tree
        : pair(square_tree(head(tree)),square_tree(tail(tree)));
 }
 square_tree(list(1, list(2, list(3, 4), 5), list(6, 7)));

 // function square_tree(tree) {
 //     return map(sub_tree => is_pair(sub_tree)
 //                     ? square_tree(sub_tree)
 //                     : sub_tree * sub_tree, 
 //                 tree);
 // }
 // square_tree(list(1, list(2, list(3, 4), 5), list(6, 7)));


 // 2-31
 function tree_map(func, tree) {
    return is_null(tree)
        ? null
        : ! is_pair(tree)
        ? func(tree)
        : pair(tree_map(head(tree)),tree_map(tail(tree)));
 }

 function square_tree_map(tree) { 
    return tree_map(x => x*x, tree); 
    
 }
diff --git a/2-33,2-35,2-38,2-39,2-40.js b/2-33,2-35,2-38,2-39,2-40.js
 // 2-33
 // 그냥 구현하고 답이랑 체크함, 중복구현이라 실행 안됨.
 // function map(f, sequence) {
 //     return accumulate((x, y) => pair(f(x), y), null, sequence);
 // }

 // function append(seq1, seq2) {
 //     return accumulate(pair, seq2, seq1);
 // }

 // function length(sequence) {
 //     return accumulate((x, y) => y + 1, 0, sequence);
 // }



 // 2-35
 // 포기, 어케 잘 하면 될거같긴 한데, 익명함수를 쓰면 푸는 방법이 생각이 안남.




 // 2-38
 // op가 실행 순서가 무관해야 함. 각 요소를 개별적으로 계산하는 map이나 그런건 상관없는데, pair같은건 fold-l, r 순서에 영향을 받음
 // 결합 법칙(associativity)을 만족해야 함



 // 2-39
 const fold_right = accumulate;
 function fold_left(op, initial, sequence) {
    function iter(result, rest) {
        return is_null(rest)
            ? result
            : iter(op(result, head(rest)),
              tail(rest));
    }
    return iter(initial, sequence);
 }

 // function reverse(sequence) {
 //     return fold_right((x, y) => append(y, pair(x, null)), null, sequence);
 // }
 // reverse(list(1, 4, 5, 9, 16, 25));

 function reverse(sequence) {
    return fold_left((x, y) => pair(y, x), null, sequence);
 }
 reverse(list(1, 4, 5, 9, 16, 25));



 // 2-40
 function square(x) {
    return x * x;
 }

 function smallest_divisor(n) {
    return find_divisor(n, 2);
 }
 function find_divisor(n, test_divisor) {
    return square(test_divisor) > n
           ? n
           : divides(test_divisor, n)
           ? test_divisor
           : find_divisor(n, test_divisor + 1);
 }
 function divides(a, b) {
    return b % a === 0;
 }

 function enumerate_interval(low, high) {
 return low > high
    ? null
    : pair(low,
    enumerate_interval(low + 1, high));
 }

 function flatmap(f, seq) {
    return accumulate(append, null, map(f, seq));
 }

 function unique_pairs(n) {
    return flatmap(i => map(j => list(i, j),
        enumerate_interval(1, i - 1)),
        enumerate_interval(1, n));
 }

 unique_pairs(3);

 function is_prime(n) {
    return n === smallest_divisor(n);
 }

 function is_prime_sum(pair) {
    return is_prime(head(pair) + head(tail(pair)));
 }

 function make_pair_sum(pair) {
    return list(head(pair), head(tail(pair)),
    head(pair) + head(tail(pair)));
 }

 function prime_sum_pairs(n) {
    return map(make_pair_sum,
        filter(is_prime_sum, unique_pairs(n)));
 }

 prime_sum_pairs(3);
diff --git a/2-54.js b/2-54.js
 // 2-54
 // 뭔가 잘하면 더 줄어들거 같은데 흠...
 function equal(l1, l2) {
    return is_null(l1) && is_null(l2)
        ? true
        : is_null(l1) || is_null(l2)
        ? false
        : is_list(l1) && is_list(l2)
        ? equal(head(l1), head(l2)) && equal(tail(l1), tail(l2))
        : is_list(l1) || is_list(l2)
        ? false
        : l1 === l2;
 }

 equal(list("this", "is", "a", "list"), list("this", "is", "a", "list"));
 //equal(list("this", "is", "a", "list"), list("this", list("is", "a"), "list"));
diff --git a/4.1.7 Separating Syntactic Analysis from Execution 정리.md b/4.1.7 Separating Syntactic Analysis from Execution 정리.md
diff --git a/4.3.3 Implementing the amb Evaluator.md b/4.3.3 Implementing the amb Evaluator.md
diff --git a/4.4.4 Implementing the Query System.md b/4.4.4 Implementing the Query System.md
diff --git a/5.2 A Register-Machine Simulator.md b/5.2 A Register-Machine Simulator.md
diff --git a/5.3 Storage Allocation and Garbage Collection.md b/5.3 Storage Allocation and Garbage Collection.md
diff --git a/5.5 Compilation.md b/5.5 Compilation.md
diff --git a/README.md b/README.md
diff --git a/Explicit-Control Evaluator.md b/Explicit-Control Evaluator.md
diff --git a/practice_2-2.js b/practice_2-2.js
 // const z = pair(1, 2);
 // head(z);
 // tail(z);

 const make_point = pair;
 const x_point = head;
 const y_point = tail;

 const make_segment = pair;
 const start_segment = head;
 const end_segment = tail;

 function midpoint_segment(line) {
    return make_segment(
        (x_point(start_segment(line)) + x_point(end_segment(line)))/2,
        (y_point(start_segment(line)) + y_point(end_segment(line)))/2
    );
 }

 function print_point(p) {
    return display("(" + stringify(x_point(p)) + ", "
        + stringify(y_point(p)) + ")");
 }

 // GPT 생성 테스트 코드

 // 점 생성
 const p1 = make_point(0, 0);
 const p2 = make_point(4, 6);

 // 선분 생성
 const seg = make_segment(p1, p2);

 // 중점 계산
 const mid = midpoint_segment(seg);

 // 출력
 print_point(p1); // 예상: (0, 0)
 print_point(p2); // 예상: (4, 6)
 print_point(mid); // 예상: (2, 3)
diff --git a/SICP in JS 2.3.2-2.3.4 요약 및 학습 가이드.md b/SICP in JS 2.3.2-2.3.4 요약 및 학습 가이드.md
	// 2-17

	function last_pair(items) {
	return is_null(tail(items))
	? head(items)
	: last_pair(tail(items));
	}

	const odds = list(1, 3, 5, 7);
	last_pair(odds);

	const odds2 = list(1, 3, 5, 7, 9);
	last_pair(odds2);


	// 2-18

	function reverse(items) {
	function reverse_iter(items, rs) {
	return is_null(items)
	? rs
	: reverse_iter(tail(items),
	pair(head(items), rs));
	}
	return reverse_iter(items, null);
	}

	reverse(list(1, 4, 5, 9, 16, 25));


	// 2-20
	function plus_curried(x) {
	return y => x + y;
	}

	// function brooks(curried, items) {
	// return is_null(tail(items))
	// ? curried(head(items))
	// : brooks(curried(head(items)), tail(items));
	// }

	// 이게 좀 더 나은 이유가, 위 방식이면 체크를 한 번 더 할듯?
	function brooks(curried, items) {
	return is_null(items)
	? curried
	: brooks(curried(head(items)), tail(items));
	}

	brooks(plus_curried, list(3, 4));

	function brooks_curried(items) {
	return brooks(head(items), tail(items));
	}
	brooks_curried(list(plus_curried, 3, 4));


	// 2-21

	// function square_list(items) {
	// return is_null(items)
	// ? null
	// : pair(head(items) * head(items), square_list(tail(items)));
	// }
	// square_list(list(1, 2, 3, 4));

	function square_list(items) {
	return map(x => x*x, items);
	}
	square_list(list(1, 2, 3, 4));


	// 2-23
	function for_each(fun, items) {
	if (is_null(items)) {
	return null;
	}
	else {
	fun(head(items));
	for_each(fun, tail(items));
	}
	return true;
	}

	for_each(x => display(x), list(57, 321, 88));
	// 2-27

	const x = list(list(1, 2), list(3, 4));

	function deep_reverse(items) {
	function reverse_iter(items, rs) {
	return is_null(items)
	? rs
	: !is_pair(head(items))
	? reverse_iter(tail(items), pair(head(items), rs)) // 그냥 값이면 그대로 붙임, 순서가 없는 상태일꺼니까
	: reverse_iter(tail(items), pair(deep_reverse(head(items)), rs)); // pair면 재귀로 반대로 붙임
	// 소트 머지 정렬이랑 알고리즘이 비슷함
	}
	return reverse_iter(items, null);
	}
	deep_reverse(x);


	// 2-28

	// const x = list(list(1, 2), list(3, 4));
	function fringe(items) {
	if (is_null(items)) {
	// 리스트가 비었으면 null
	return null;
	} else if (!is_pair(items)) {
	// 원자(leaf)면, 그 값을 하나짜리 리스트로
	return pair(items, null);
	} else {
	// pair라면 head와 tail을 각각 fringe로 구해서 이어 붙인다
	return append(fringe(head(items)), fringe(tail(items)));
	}
	}
	fringe(x);



	// 2-30
	function square_tree(tree) {
	return is_null(tree)
	? null
	: ! is_pair(tree)
	? tree * tree
	: pair(square_tree(head(tree)),square_tree(tail(tree)));
	}
	square_tree(list(1, list(2, list(3, 4), 5), list(6, 7)));

	// function square_tree(tree) {
	// return map(sub_tree => is_pair(sub_tree)
	// ? square_tree(sub_tree)
	// : sub_tree * sub_tree,
	// tree);
	// }
	// square_tree(list(1, list(2, list(3, 4), 5), list(6, 7)));


	// 2-31
	function tree_map(func, tree) {
	return is_null(tree)
	? null
	: ! is_pair(tree)
	? func(tree)
	: pair(tree_map(head(tree)),tree_map(tail(tree)));
	}

	function square_tree_map(tree) {
	return tree_map(x => x*x, tree);

	}
	// 2-33
	// 그냥 구현하고 답이랑 체크함, 중복구현이라 실행 안됨.
	// function map(f, sequence) {
	// return accumulate((x, y) => pair(f(x), y), null, sequence);
	// }

	// function append(seq1, seq2) {
	// return accumulate(pair, seq2, seq1);
	// }

	// function length(sequence) {
	// return accumulate((x, y) => y + 1, 0, sequence);
	// }



	// 2-35
	// 포기, 어케 잘 하면 될거같긴 한데, 익명함수를 쓰면 푸는 방법이 생각이 안남.




	// 2-38
	// op가 실행 순서가 무관해야 함. 각 요소를 개별적으로 계산하는 map이나 그런건 상관없는데, pair같은건 fold-l, r 순서에 영향을 받음
	// 결합 법칙(associativity)을 만족해야 함



	// 2-39
	const fold_right = accumulate;
	function fold_left(op, initial, sequence) {
	function iter(result, rest) {
	return is_null(rest)
	? result
	: iter(op(result, head(rest)),
	tail(rest));
	}
	return iter(initial, sequence);
	}

	// function reverse(sequence) {
	// return fold_right((x, y) => append(y, pair(x, null)), null, sequence);
	// }
	// reverse(list(1, 4, 5, 9, 16, 25));

	function reverse(sequence) {
	return fold_left((x, y) => pair(y, x), null, sequence);
	}
	reverse(list(1, 4, 5, 9, 16, 25));



	// 2-40
	function square(x) {
	return x * x;
	}

	function smallest_divisor(n) {
	return find_divisor(n, 2);
	}
	function find_divisor(n, test_divisor) {
	return square(test_divisor) > n
	? n
	: divides(test_divisor, n)
	? test_divisor
	: find_divisor(n, test_divisor + 1);
	}
	function divides(a, b) {
	return b % a === 0;
	}

	function enumerate_interval(low, high) {
	return low > high
	? null
	: pair(low,
	enumerate_interval(low + 1, high));
	}

	function flatmap(f, seq) {
	return accumulate(append, null, map(f, seq));
	}

	function unique_pairs(n) {
	return flatmap(i => map(j => list(i, j),
	enumerate_interval(1, i - 1)),
	enumerate_interval(1, n));
	}

	unique_pairs(3);

	function is_prime(n) {
	return n === smallest_divisor(n);
	}

	function is_prime_sum(pair) {
	return is_prime(head(pair) + head(tail(pair)));
	}

	function make_pair_sum(pair) {
	return list(head(pair), head(tail(pair)),
	head(pair) + head(tail(pair)));
	}

	function prime_sum_pairs(n) {
	return map(make_pair_sum,
	filter(is_prime_sum, unique_pairs(n)));
	}

	prime_sum_pairs(3);
	// 2-54
	// 뭔가 잘하면 더 줄어들거 같은데 흠...
	function equal(l1, l2) {
	return is_null(l1) && is_null(l2)
	? true
	: is_null(l1) \|\| is_null(l2)
	? false
	: is_list(l1) && is_list(l2)
	? equal(head(l1), head(l2)) && equal(tail(l1), tail(l2))
	: is_list(l1) \|\| is_list(l2)
	? false
	: l1 === l2;
	}

	equal(list("this", "is", "a", "list"), list("this", "is", "a", "list"));
	//equal(list("this", "is", "a", "list"), list("this", list("is", "a"), "list"));
	// const z = pair(1, 2);
	// head(z);
	// tail(z);

	const make_point = pair;
	const x_point = head;
	const y_point = tail;

	const make_segment = pair;
	const start_segment = head;
	const end_segment = tail;

	function midpoint_segment(line) {
	return make_segment(
	(x_point(start_segment(line)) + x_point(end_segment(line)))/2,
	(y_point(start_segment(line)) + y_point(end_segment(line)))/2
	);
	}

	function print_point(p) {
	return display("(" + stringify(x_point(p)) + ", "
	+ stringify(y_point(p)) + ")");
	}

	// GPT 생성 테스트 코드

	// 점 생성
	const p1 = make_point(0, 0);
	const p2 = make_point(4, 6);

	// 선분 생성
	const seg = make_segment(p1, p2);

	// 중점 계산
	const mid = midpoint_segment(seg);

	// 출력
	print_point(p1); // 예상: (0, 0)
	print_point(p2); // 예상: (4, 6)
	print_point(mid); // 예상: (2, 3)