plum

# Data-oriented alternative to the Visitor pattern.
# Based on: https://wimdetroyer.com/blog/visitor-pattern-in-dop
#
# Instead of a Visitable/BookVisitor double-dispatch hierarchy, the shape of
# the data is declared once with a sealed `enum` and every operation on it is
# a single exhaustive `match`. Two features make this read close to the
# article's Java (sealed interfaces implemented directly by records, switch
# with `when` guards and deconstruction):
#
#   - Each variant carries its fields inline, right in the enum (e.g.
#     `FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)`), so
#     there's no separate `type` declaration to wrap — the named fields are
#     just call-site sugar (`FantasyBook(title: ..., ...)` or positional
#     `FantasyBook(...)`), and a match arm still destructures purely by
#     position (`FantasyBook(title, pages, hasMythicalCreatures)`).
#   - A `when <expr>` guard on a match case (`FantasyBook(title, _,
#     hasMythicalCreatures) when hasMythicalCreatures => ...`) stands in for
#     Java's guarded switch patterns; a guard that evaluates false falls
#     through to the next case, same as a genuine pattern mismatch.
#
# The checker's exhaustiveness check on enums stands in for the compile-time
# guarantee sealed interfaces + switch give in Java.
#
# DOP vs. OOP (see the `trait`/`type`-per-shape rewrite in
# `oop_visitor.plum`):
#   - Adding a new operation (a new function that matches on `Book`) touches
#     one place here, and the exhaustiveness checker forces every variant to
#     be handled. In the OOP version it means adding a new method to every
#     `type`, with nothing catching a variant you forgot to update.
#   - Adding a new variant instead means touching every `match` on `Book`
#     here (again caught by exhaustiveness if missed); the OOP version adds
#     it in one new, self-contained `type`, untouched elsewhere.
#   - So DOP fits best when operations change often and the shapes are
#     stable; OOP fits best when shapes multiply and operations are stable.
#     plum has no dynamic dispatch through a trait type (see
#     `oop_visitor.plum`'s header), which tilts things further toward DOP
#     for anything that needs to treat the shapes polymorphically.

import std/Os
import std/Bool
import std/Number
import std/Str

enum Rating =
  | Good(name: Str)
  | Bad(name: Str)

enum Book =
  | FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)
  | ScifiBook(title: Str, pages: Int, theme: Str)
  | ChildrensTaleBook(title: Str, pages: Int, moralLesson: Str)
  | NonFictionBook(title: Str, pages: Int, rating1: Rating, rating2: Rating)

fun collectInterestingInfo(book: Book) -> Str =
  match book
    FantasyBook(title, _, hasMythicalCreatures) when hasMythicalCreatures => "Fantasy book \"{title}\" features mythical creatures"
    FantasyBook(title, _, _) => "Fantasy book \"{title}\" has no mythical creatures"
    ScifiBook(title, _, theme) when theme == "space exploration" => "Scifi book \"{title}\" explores space exploration"
    ScifiBook(title, _, theme) => "Scifi book \"{title}\" has theme {theme}"
    ChildrensTaleBook(title, pages, _) when pages == 0 => "Childrens book \"{title}\" is empty"
    ChildrensTaleBook(title, _, moralLesson) => "Childrens book \"{title}\" teaches: {moralLesson}"
    NonFictionBook(title, _, rating1, rating2) =>
      match rating1, rating2
        Good(name1), Good(name2) => "Non-fiction book \"{title}\" praised by {name1} and {name2}"
        _, _ => "Non-fiction book \"{title}\" has mixed reviews"

fun describeFantasy() -> Str =
  collectInterestingInfo(FantasyBook(title: "Dragon Tales", pages: 200, hasMythicalCreatures: True))

fun main() =
  printLn(describeFantasy())

test "fantasy book with mythical creatures is called out"
  assert describeFantasy() == "Fantasy book \"Dragon Tales\" features mythical creatures"

test "fantasy book without mythical creatures is called out"
  book := FantasyBook(title: "Plain Fantasy", pages: 150, hasMythicalCreatures: False)
  assert collectInterestingInfo(book) == "Fantasy book \"Plain Fantasy\" has no mythical creatures"

test "scifi book with space exploration theme is called out"
  book := ScifiBook(title: "Starbound", pages: 300, theme: "space exploration")
  assert collectInterestingInfo(book) == "Scifi book \"Starbound\" explores space exploration"

test "scifi book with other theme falls through to generic case"
  book := ScifiBook(title: "Timeloop", pages: 250, theme: "time travel")
  assert collectInterestingInfo(book) == "Scifi book \"Timeloop\" has theme time travel"

test "empty childrens book is handled via a when guard on pages"
  book := ChildrensTaleBook(title: "Nothing", pages: 0, moralLesson: "none")
  assert collectInterestingInfo(book) == "Childrens book \"Nothing\" is empty"

test "childrens book with pages reports its moral lesson"
  book := ChildrensTaleBook(title: "The Tortoise", pages: 40, moralLesson: "patience wins")
  assert collectInterestingInfo(book) == "Childrens book \"The Tortoise\" teaches: patience wins"

test "non fiction book praised by both reviewers via nested deconstruction"
  book := NonFictionBook(
    title: "True Facts",
    pages: 120,
    rating1: Good(name: "Alice"),
    rating2: Good(name: "Bob"),
  )
  assert collectInterestingInfo(book) == "Non-fiction book \"True Facts\" praised by Alice and Bob"

test "non fiction book with a bad rating reports mixed reviews"
  book := NonFictionBook(
    title: "Shaky Claims",
    pages: 80,
    rating1: Good(name: "Alice"),
    rating2: Bad(name: "Carol"),
  )
  assert collectInterestingInfo(book) == "Non-fiction book \"Shaky Claims\" has mixed reviews"