plum

# Classic OOP alternative to the DOP version in `dop_visitor.plum`: instead of

# one sealed `enum` + one exhaustive `match`, each book shape gets its own

# `type`, declares it implements the `Book` trait, and defines its own

# `collectInterestingInfo` method — the direct translation of the blog post's

# Java (sealed interface implemented by records, each overriding a method).

# Based on: https://wimdetroyer.com/blog/visitor-pattern-in-dop

#

# One real limitation this example runs into: plum's `trait` is a

# compile-time structural check only ("does this type declare these

# methods with matching signatures?") — there is no vtable or runtime

# dispatch. A function can't take a bare `book: Book` parameter and call

# `book.collectInterestingInfo()` polymorphically across different concrete

# types, and there's no way to hold a heterogeneous list of `Book`s. So

# unlike the Java original (or the enum/match version), there's no single

# `describe(book: Book)` entry point here — each concrete type's method is

# called directly at its own call site.

#

# OOP vs. DOP (see the `enum`/`match` version in `dop_visitor.plum`):

#   - Adding a new variant (a new `type(Book) = ...`) is self-contained here

#     and doesn't touch existing types. In the DOP version it means adding

#     a new arm to every `match` on `Book` (caught by the checker's

#     exhaustiveness check if missed).

#   - Adding a new operation instead means adding a method to every `type`

#     here, with nothing enforcing that you updated all of them; the DOP

#     version adds one new function with one exhaustive `match`.

#   - So OOP fits best when shapes multiply and operations are stable; DOP

#     fits best when operations change often and the shapes are stable.

#     plum's lack of dynamic dispatch through a trait type (see above)

#     removes OOP's usual "call through one interface" benefit entirely,

#     which is a real cost specific to this language.

import std/Os

import std/Bool

import std/Number

import std/Str

enum Rating =

  | Good(name: Str)

  | Bad(name: Str)

trait Book =

  collectInterestingInfo() -> Str

enum FantasyBook(Book) =

  | FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)

  fun collectInterestingInfo(self) -> Str =

    if self.hasMythicalCreatures

      "Fantasy book \"{self.title}\" features mythical creatures"

    else

      "Fantasy book \"{self.title}\" has no mythical creatures"

enum ScifiBook(Book) =

  | ScifiBook(title: Str, pages: Int, theme: Str)

  fun collectInterestingInfo(self) -> Str =

    if self.theme == "space exploration"

      "Scifi book \"{self.title}\" explores space exploration"

    else

      "Scifi book \"{self.title}\" has theme {self.theme}"

enum ChildrensTaleBook(Book) =

  | ChildrensTaleBook(title: Str, pages: Int, moralLesson: Str)

  fun collectInterestingInfo(self) -> Str =

    if self.pages == 0

      "Childrens book \"{self.title}\" is empty"

    else

      "Childrens book \"{self.title}\" teaches: {self.moralLesson}"

enum NonFictionBook(Book) =

  | NonFictionBook(title: Str, pages: Int, rating1: Rating, rating2: Rating)

  fun collectInterestingInfo(self) -> Str =

    match self.rating1, self.rating2

      Good(name1), Good(name2) => "Non-fiction book \"{self.title}\" praised by {name1} and {name2}"

      _, _ => "Non-fiction book \"{self.title}\" has mixed reviews"

fun describeFantasy() -> Str =

  FantasyBook(title: "Dragon Tales", pages: 200, hasMythicalCreatures: True).collectInterestingInfo()

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 book.collectInterestingInfo() == "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 book.collectInterestingInfo() == "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 book.collectInterestingInfo() == "Scifi book \"Timeloop\" has theme time travel"

test "empty childrens book is handled via a plain if on pages"

  book := ChildrensTaleBook(title: "Nothing", pages: 0, moralLesson: "none")

  assert book.collectInterestingInfo() == "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 book.collectInterestingInfo() == "Childrens book \"The Tortoise\" teaches: patience wins"

test "non fiction book praised by both reviewers via nested match"

  book := NonFictionBook(

    title: "True Facts",

    pages: 120,

    rating1: Good(name: "Alice"),

    rating2: Good(name: "Bob"),

  )

  assert book.collectInterestingInfo() == "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 book.collectInterestingInfo() == "Non-fiction book \"Shaky Claims\" has mixed reviews"