F＃列表比较

Question

I'm asking for help to solve a programming exercice in F#. I have to create a list where books and movies are listed in. All the books that have the same name as the movies sbould be listed in another list. I link what I've done until now and what the inputs are and what results i should get. Thank you in advance.

type Movie =
{ movieName: string
  duration: Nat
  fileSize: Nat }

type Book =
{ bookName: string
  pages: Nat }

type Activity =
 | Watch of Movie
 | Read of Book

let booksWithMovie(activities: Activity list): Book list =
   match activities with
    | [] -> []
    | [Read book] -> match activities with
      | x :: xs -> match x with
      | Watch same -> if (same.bookName = same.movieName) then [same] else 
        booksWithMovie(xs)

Here are the inputs:

Set.ofList (booksWithMovie [
            Read { bookName = "The Hobbit"; pages = 304N }
            Watch { movieName = "The Fellowship of the Ring"; duration = 228N; fileSize = 50N }
            Read { bookName = "The Name of the Wind"; pages = 662N }
            Watch { movieName = "The Emoji Movie"; duration = 86N; fileSize = 1024N }
            Watch { movieName = "The Hobbit"; duration = 164N; fileSize = 9001N }
            Read { bookName = "The Fellowship of the Ring"; pages = 700N }

And that's the result I should get:

Set.ofList [
            { bookName = "The Hobbit"; pages = 304N }
            { bookName = "The Fellowship of the Ring"; pages = 700N }

Answer 1

Since this looks like a learning exercise, rather than an actual problem (correct me if I'm wrong), I will try to give you a hint so that you can find the solution yourself, rather than just giving the solution.

As you mentioned in the comments, you wanted to iterate over all movies for every book (to check if a movie with the same title exists). This is a good plan. The best way to implement it is to use two recursive functions - one to walk over books and another to walk over movies (looking for a movie with a specific title).

The structure of the code should look something like this:

let rec movieWithTitleExists title (activities:Activity list) = 
  match activities with
  | [] -> false
  | Watch movie :: xs when movie.movieName = title -> (...)
  | x :: xs -> (...)

let rec booksWithMovie (activities: Activity list): Book list =
  match activities with
  | [] -> []
  | Book book :: xs when movieWithTitleExists book.bookName -> (...)
  | x :: xs -> (...)

I left a couple of things out, so that you can still learn something from completing the exercise. However, I hope the example of the syntax helps! In movieWithTitleExists , we are looking for movie such that it has the specified title. In booksWithMovie , we are looking for book such that the title is also a movie name.

Filling the (...) in movieWithTitleExists should be easier - you want to return a boolean value, so you either need to return a constant or make a recursive call.

In booksWithMovie , you want to return a list of books, so you will need to call the function recursively and then either just return that, or append the current book to the front using the :: operator.