207: Prism Laws — What Makes a Prism Well-Behaved

// Example 207: Prism Laws — ReviewPreview and PreviewReview

struct Prism<S, A> {
    preview: Box<dyn Fn(&S) -> Option<A>>,
    review: Box<dyn Fn(A) -> S>,
}

impl<S: 'static, A: 'static> Prism<S, A> {
    fn new(
        preview: impl Fn(&S) -> Option<A> + 'static,
        review: impl Fn(A) -> S + 'static,
    ) -> Self {
        Prism { preview: Box::new(preview), review: Box::new(review) }
    }
}

// Approach 1: Lawful prisms for a JSON type
#[derive(Debug, Clone, PartialEq)]
enum Json {
    JString(String),
    JInt(i64),
    JBool(bool),
    JNull,
    JArray(Vec<Json>),
}

fn jstring_prism() -> Prism<Json, String> {
    Prism::new(
        |j| match j { Json::JString(s) => Some(s.clone()), _ => None },
        |s| Json::JString(s),
    )
}

fn jint_prism() -> Prism<Json, i64> {
    Prism::new(
        |j| match j { Json::JInt(n) => Some(*n), _ => None },
        |n| Json::JInt(n),
    )
}

fn jbool_prism() -> Prism<Json, bool> {
    Prism::new(
        |j| match j { Json::JBool(b) => Some(*b), _ => None },
        |b| Json::JBool(b),
    )
}

// Approach 2: An UNLAWFUL prism
fn bad_prism() -> Prism<Json, String> {
    Prism::new(
        |j| match j { Json::JString(s) => Some(s.to_uppercase()), _ => None },
        |s| Json::JString(s), // review doesn't uppercase!
    )
}

// Approach 3: Law verification
fn check_review_preview<S: PartialEq, A: Clone + PartialEq>(
    prism: &Prism<S, A>, a: &A,
) -> bool {
    let s = (prism.review)(a.clone());
    (prism.preview)(&s) == Some(a.clone())
}

fn check_preview_review<S: PartialEq + Clone, A: Clone>(
    prism: &Prism<S, A>, s: &S,
) -> bool {
    match (prism.preview)(s) {
        None => true,
        Some(a) => (prism.review)(a) == *s,
    }
}

fn main() {
    // jstring_prism is lawful
    let p = jstring_prism();
    for val in &["hello".to_string(), "world".into(), "".into()] {
        assert!(check_review_preview(&p, val));
    }
    for src in &[Json::JString("hello".into()), Json::JInt(42), Json::JNull] {
        assert!(check_preview_review(&p, src));
    }

    // jint_prism is lawful
    let p = jint_prism();
    for val in &[1i64, 0, -99] {
        assert!(check_review_preview(&p, val));
    }

    // bad_prism violates ReviewPreview
    let bp = bad_prism();
    assert!(!check_review_preview(&bp, &"hello".to_string()));
    // preview(review("hello")) = Some("HELLO") ≠ Some("hello")

    // Also violates PreviewReview
    let s = Json::JString("hello".into());
    assert!(!check_preview_review(&bp, &s));
    // preview gives "HELLO", review("HELLO") = JString("HELLO") ≠ JString("hello")

    println!("✓ All tests passed");
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_review_preview_law() {
        let p = jbool_prism();
        assert!(check_review_preview(&p, &true));
        assert!(check_review_preview(&p, &false));
    }

    #[test]
    fn test_preview_review_law() {
        let p = jint_prism();
        assert!(check_preview_review(&p, &Json::JInt(42)));
        assert!(check_preview_review(&p, &Json::JString("x".into())));
    }

    #[test]
    fn test_bad_prism_violates() {
        let bp = bad_prism();
        assert!(!check_review_preview(&bp, &"test".to_string()));
    }
}