From d3edd4ce82195e83b187a465e4b93dc81995f95d Mon Sep 17 00:00:00 2001
From: parrrate <alisa@parrrate.com>
Date: Fri, 12 Sep 2025 18:33:52 +0000
Subject: [PATCH] calculating with functions

---
 src/SUMMARY.md       |  1 +
 src/exercises/cwf.md | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+)
 create mode 100644 src/exercises/cwf.md

diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index a60aa4e..cd98481 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -13,6 +13,7 @@
   - [Async Fn](./exercises/async_fn.md)
   - [Get Functions](./exercises/get_functions.md)
   - [Linked](./exercises/linked.md)
+  - [Calculating with Functions (based on Codewars)](./exercises/cwf.md)
 - [Chapter 2](./chapter_2.md)
   - [AnyStr](./exercises/anystr.md)
   - [Mode](./exercises/mode.md)
diff --git a/src/exercises/cwf.md b/src/exercises/cwf.md
new file mode 100644
index 0000000..b2193f1
--- /dev/null
+++ b/src/exercises/cwf.md
@@ -0,0 +1,34 @@
+# Calculating with Functions (based on Codewars)
+
+Original: [Calculating with Functions](https://www.codewars.com/kata/525f3eda17c7cd9f9e000b39)
+
+As you might know, on *stable* Rust you can't have variable number of arguments passed to a
+function. However we can alter the exercise to work anyway.
+
+```rust
+# trait Value { fn value(self) -> i32; }
+# trait Op { fn apply(self, value: i32) -> i32; }
+# struct Identity;
+# impl Op for Identity { fn apply(self, value: i32) -> i32 { value } }
+# impl<F: FnOnce(i32) -> i32> Op for F { fn apply(self, value: i32) -> i32 { self(value) } }
+# impl<F: FnOnce(Identity) -> i32> Value for F { fn value(self) -> i32 { self(Identity) } }
+# impl Value for i32 { fn value(self) -> i32 { self } }
+# fn zero(f: impl Op) -> i32 { f.apply(0) }
+# fn one(f: impl Op) -> i32 { f.apply(1) }
+# fn two(f: impl Op) -> i32 { f.apply(2) }
+# fn three(f: impl Op) -> i32 { f.apply(3) }
+# fn four(f: impl Op) -> i32 { f.apply(4) }
+# fn five(f: impl Op) -> i32 { f.apply(5) }
+# fn six(f: impl Op) -> i32 { f.apply(6) }
+# fn seven(f: impl Op) -> i32 { f.apply(7) }
+# fn eight(f: impl Op) -> i32 { f.apply(8) }
+# fn nine(f: impl Op) -> i32 { f.apply(9) }
+# fn plus(x: impl Value) -> impl FnOnce(i32) -> i32 { |y| y + x.value() }
+# fn minus(x: impl Value) -> impl FnOnce(i32) -> i32 { |y| y - x.value() }
+# fn times(x: impl Value) -> impl FnOnce(i32) -> i32 { |y| y * x.value() }
+# fn divided_by(x: impl Value) -> impl FnOnce(i32) -> i32 { |y| y / x.value() }
+assert_eq!(seven(times(five)), 35);
+assert_eq!(four(plus(nine)), 13);
+assert_eq!(eight(minus(three)), 5);
+assert_eq!(six(divided_by(two)), 3);
+```