Merge pull request #76 from JasonShin/revamp

Update project

Author: JasonShin

.github/workflows/rust.yml

@@ -0,0 +1,49 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+env:
+  RUST_BACKTRACE: 1
+  CARGO_TERM_COLOR: always
+
+jobs:
+  fmt:
+    name: Format Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+      - name: Check formatting
+        run: cargo fmt --all -- --check
+
+  clippy:
+    name: Clippy (Lint)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+      - name: Run clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+        # -D warnings makes lint warnings fail CI (fixes Issue #34)
+
+  test:
+    name: Test Suite
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - name: Run tests
+        run: cargo test --all-features --workspace
+      - name: Run doc tests
+        run: cargo test --doc --workspace

.travis.yml

@@ -27,21 +27,47 @@ NOTE: Be sure to merge the latest from "upstream" before making a pull request!
 
 ## Development Environments
 
-| type   | version                |
-| ------ | ---------------------- |
-| nodejs | Greater than 8.11.0    |
-| OS     | Linux, Windows and Mac |
+| type | version                |
+| ---- | ---------------------- |
+| OS   | Linux, Windows and Mac |
 
-You will need to install Rust to work on this project. Installation instruction can be found https://www.rust-lang.org/tools/install.
+You will need to install Rust to work on this project. Installation instruction can be found at https://www.rust-lang.org/tools/install.
 
-I have used following versions of Rust and its dependencies while developing
+### Requirements
 
-| type   | version                                     |
-| ------ | ------------------------------------------- |
-| rustc  | rustc 1.36.0-nightly (7158ed9cb 2019-05-15) |
-| cargo  | cargo 1.36.0-nightly (759b6161a 2019-05-06) |
+- **Rust stable** (1.70.0 or later recommended)
+- **No nightly features required** - this project uses only stable Rust features
 
-Also I've enabled nightly mode to use some of the latest features of Rust, follow this instruction: https://github.com/rust-lang/rustup.rs#working-with-nightly-rust
+The project automatically uses the correct Rust version via `rust-toolchain.toml`.
+
+### Running Tests
+
+```bash
+# Run all tests
+cargo test --workspace
+
+# Run tests for a specific package
+cargo test -p fp-core
+
+# Run with output
+cargo test -- --nocapture
+```
+
+### Code Quality Checks
+
+```bash
+# Format code
+cargo fmt --all
+
+# Check formatting
+cargo fmt --all -- --check
+
+# Run clippy lints
+cargo clippy --all-targets --all-features
+
+# Fix clippy warnings automatically (where possible)
+cargo clippy --all-targets --all-features --fix
+```
 
 ## Copyright and Licensing
 
@@ -62,7 +88,7 @@ You can copy and paste the MIT license summary from below.
 ```
 MIT License
 
-Copyright (c) 2019 Jason Shin
+Copyright (c) 2026 Jason Shin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

CONTRIBUTING.md

@@ -1,4 +1,4 @@
-Copyright (c) 2019 Jason Shin
+Copyright (c) 2026 Jason Shin
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

LICENSE

@@ -1,7 +1,7 @@
 use crate::functor::Functor;
 use crate::hkt::HKT;
 
-type Applicator<B, S: HKT<B>> = <S as HKT<Box<dyn Fn(<S as HKT<B>>::Current) -> B>>>::Target;
+type Applicator<B, S> = <S as HKT<Box<dyn Fn(<S as HKT<B>>::Current) -> B>>>::Target;
 
 pub trait Apply<B>: Functor<B> + HKT<Box<dyn Fn(<Self as HKT<B>>::Current) -> B>> {
     fn ap(self, f: Applicator<B, Self>) -> <Self as HKT<B>>::Target;

fp-core/src/apply.rs

@@ -1,7 +1,7 @@
 pub trait Lens<S, A> {
     fn over(s: &S, f: &dyn Fn(Option<&A>) -> A) -> S {
         let result: A = f(Self::get(s));
-        Self::set(result, &s)
+        Self::set(result, s)
     }
     fn get(s: &S) -> Option<&A>;
     fn set(a: A, s: &S) -> S;

fp-core/src/lens.rs

@@ -14,4 +14,97 @@ mod example {
         let x = Result::<_, ()>::of(1).ap(Ok(Box::new(|x| x + 1)));
         assert_eq!(x, Ok(2));
     }
+
+    // Additional comprehensive applicative tests
+    #[test]
+    fn test_option_pure() {
+        let result = Option::of(5);
+        assert_eq!(result, Some(5));
+    }
+
+    #[test]
+    fn test_result_pure() {
+        let result: Result<i32, String> = Result::of(5);
+        assert_eq!(result, Ok(5));
+    }
+
+    #[test]
+    fn test_option_apply() {
+        let value = Some(5);
+        let func = Some(Box::new(|x: i32| x * 2) as Box<dyn Fn(i32) -> i32>);
+        let result = value.ap(func);
+        assert_eq!(result, Some(10));
+    }
+
+    #[test]
+    fn test_option_apply_none_value() {
+        let value: Option<i32> = None;
+        let func = Some(Box::new(|x: i32| x * 2) as Box<dyn Fn(i32) -> i32>);
+        let result = value.ap(func);
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_option_apply_none_func() {
+        let value = Some(5);
+        let func: Option<Box<dyn Fn(i32) -> i32>> = None;
+        let result = value.ap(func);
+        assert_eq!(result, None);
+    }
+
+    #[test]
+    fn test_result_apply_ok() {
+        let value: Result<i32, String> = Ok(5);
+        let func: Result<Box<dyn Fn(i32) -> i32>, String> =
+            Ok(Box::new(|x: i32| x * 2) as Box<dyn Fn(i32) -> i32>);
+        let result = value.ap(func);
+        assert_eq!(result, Ok(10));
+    }
+
+    #[test]
+    fn test_result_apply_err_value() {
+        let value: Result<i32, String> = Err("value error".to_string());
+        let func: Result<Box<dyn Fn(i32) -> i32>, String> =
+            Ok(Box::new(|x: i32| x * 2) as Box<dyn Fn(i32) -> i32>);
+        let result = value.ap(func);
+        assert_eq!(result, Err("value error".to_string()));
+    }
+
+    #[test]
+    fn test_result_apply_err_func() {
+        let value: Result<i32, String> = Ok(5);
+        let func: Result<Box<dyn Fn(i32) -> i32>, String> = Err("func error".to_string());
+        let result = value.ap(func);
+        assert_eq!(result, Err("func error".to_string()));
+    }
+
+    // Applicative Laws
+    #[test]
+    fn test_applicative_identity_law_option() {
+        // Identity: pure(id).ap(v) == v
+        let v = Some(42);
+        let id_func = Some(Box::new(|x: i32| x) as Box<dyn Fn(i32) -> i32>);
+        let result = v.ap(id_func);
+        assert_eq!(result, Some(42));
+    }
+
+    #[test]
+    fn test_applicative_homomorphism_option() {
+        // Homomorphism: pure(f).ap(pure(x)) == pure(f(x))
+        let x = 5;
+        let f = |n: i32| n * 2;
+
+        let left = Option::of(x).ap(Some(Box::new(f) as Box<dyn Fn(i32) -> i32>));
+        let right = Option::of(f(x));
+
+        assert_eq!(left, right);
+    }
+
+    #[test]
+    fn test_apply_with_type_change() {
+        let value = Some(42);
+        let func = Some(Box::new(|x: i32| x.to_string()) as Box<dyn Fn(i32) -> String>);
+        let result = value.ap(func);
+        assert_eq!(result, Some("42".to_string()));
+    }
 }

fp-examples/src/applicative_example.rs

@@ -1,5 +1,6 @@
 #[cfg(test)]
 mod example {
+    use fp_core::empty::Empty;
     use fp_core::foldable::*;
 
     /*
@@ -20,8 +21,126 @@ mod example {
 
     #[test]
     fn fold_map_example() {
-        let k = vec![Some(1 as i64), Some(2 as i64), Some(3 as i64), None];
-        let result = fold_map(k, |&opt| if let Some(x) = opt { x } else { 0 });
+        let k = vec![Some(1_i64), Some(2_i64), Some(3_i64), None];
+        let result = fold_map(k, |&opt| opt.unwrap_or_default());
         assert_eq!(result, 6);
     }
+
+    // Additional comprehensive foldable tests
+    #[test]
+    fn test_vec_reduce() {
+        let vec = vec![1, 2, 3, 4, 5];
+        let result = vec.reduce(0, |acc, x| acc + x);
+        assert_eq!(result, 15);
+    }
+
+    #[test]
+    fn test_vec_reduce_empty() {
+        let vec: Vec<i32> = vec![];
+        let result = vec.reduce(0, |acc, x| acc + x);
+        assert_eq!(result, 0);
+    }
+
+    #[test]
+    fn test_vec_reduce_multiply() {
+        let vec = vec![1, 2, 3, 4];
+        let result = vec.reduce(1, |acc, x| acc * x);
+        assert_eq!(result, 24);
+    }
+
+    #[test]
+    fn test_vec_reduce_string_concat() {
+        let vec = vec!["hello", " ", "world"];
+        let result = vec.reduce(String::new(), |acc, x| acc + x);
+        assert_eq!(result, "hello world");
+    }
+
+    #[test]
+    fn test_vec_reduce_max() {
+        let vec = vec![5, 2, 8, 1, 9, 3];
+        let result = vec.reduce(i32::MIN, |acc, x| acc.max(*x));
+        assert_eq!(result, 9);
+    }
+
+    #[test]
+    fn test_fold_map_sum() {
+        let vec = vec![1, 2, 3, 4, 5];
+        let result: i32 = fold_map(vec, |x| *x);
+        assert_eq!(result, 15);
+    }
+
+    #[test]
+    fn test_fold_map_string_concat() {
+        let vec = vec![1, 2, 3];
+        let result: String = fold_map(vec, |x| x.to_string());
+        assert_eq!(result, "123");
+    }
+
+    #[test]
+    fn test_fold_map_with_transformation() {
+        let vec = vec![1, 2, 3];
+        let result: i32 = fold_map(vec, |x| x * 2);
+        assert_eq!(result, 12); // 2 + 4 + 6
+    }
+
+    #[test]
+    fn test_fold_map_empty_vec() {
+        let vec: Vec<i32> = vec![];
+        let result: i32 = fold_map(vec, |x| *x);
+        assert_eq!(result, i32::empty());
+    }
+
+    #[test]
+    fn test_reduce_filter_operation() {
+        let vec = vec![1, 2, 3, 4, 5, 6];
+        let evens = vec.reduce(Vec::new(), |mut acc, x| {
+            if x % 2 == 0 {
+                acc.push(*x);
+            }
+            acc
+        });
+        assert_eq!(evens, vec![2, 4, 6]);
+    }
+
+    #[test]
+    fn test_reduce_partition() {
+        #[derive(Debug, PartialEq)]
+        struct Partitioned {
+            evens: Vec<i32>,
+            odds: Vec<i32>,
+        }
+
+        let vec = vec![1, 2, 3, 4, 5];
+        let result = vec.reduce(
+            Partitioned {
+                evens: vec![],
+                odds: vec![],
+            },
+            |mut acc, x| {
+                if x % 2 == 0 {
+                    acc.evens.push(*x);
+                } else {
+                    acc.odds.push(*x);
+                }
+                acc
+            },
+        );
+
+        assert_eq!(result.evens, vec![2, 4]);
+        assert_eq!(result.odds, vec![1, 3, 5]);
+    }
+
+    #[test]
+    fn test_reduce_count() {
+        let vec = vec![1, 2, 3, 4, 5];
+        let count = vec.reduce(0, |acc, _| acc + 1);
+        assert_eq!(count, 5);
+    }
+
+    #[test]
+    fn test_vec_reduce_right() {
+        let vec = vec![1, 2, 3, 4];
+        let result = vec.reduce_right(0, |x, acc| x + acc);
+        assert_eq!(result, 10);
+    }
 }