Last updated on Friday, December 13, 2024

Find, with a higher-order function

In the context of our labs, a callback is a small modification to a previous lab that uses a newly introduced concept to simplify the code. In this week’s callback, you will re-implement different find* functions from the Find lab using a higher-order function.

Obtaining the lab files

Run the following commands to obtain a copy of the lab:

$ git clone https://gitlab.epfl.ch/lamp/cs-214/find-hof.git
$ cd find-hof

The provided code contains possible solutions to the previous labs. You will need to modify the find.scala file to complete this lab.

Step 1: Implement findAndPrint

Add a findAndPrint function in find.scala.

This function should take two arguments:

1. a root cs214.Entry to search in,
2. a predicate function that takes an cs214.Entry and returns a Boolean.

The function should print the path of all entries in the tree that satisfy the predicate, and—like your existing find* functions—return true if any entry was found and false otherwise.

Step 2: Rewrite the find* functions

Rewrite findAllAndPrint, findByNameAndPrint, findBySizeEqAndPrint, findBySizeGtAndPrint and findEmptyAndPrint using findAndPrint. Each function should call findAndPrint with the appropriate predicate function.

@munit.IgnoreSuite
class FindFirstHOFTest extends munit.FunSuite, FindTestOps:
  test("`find food -name tomato.txt -print -quit` returns the first tomato (0pt)"):
    testFind("""
      $ find food -name tomato.txt -print -quit
      food/fruits/tomato.txt
     """)

Testing

As refactoring the code should not change the behavior of the program, the test suite FindTest is exactly the same as the one from the Find lab.

In addition, there is a new test suite FindHOFTest that checks that you have indeed added the findAndPrint function and that you have rewritten the 5 find* functions mentioned above using it. This is the test suite that will be used to grade this callback. You do not need to understand how this test suite works.

You can run all suites as usual with:

$ sbt test

Submit your patch!

Once your are done, you should submit your code on Moodle. Since we are revisiting old code, rather than writing new code, the submission is done as a patch.

1. If you forgot how to create patches, you can re-watch the online lecture, or redo the introductory exercises on patching.

2. Select files to commit using git add. Make sure to select only relevant files. In this assignment, you should be including exactly two files, src/main/find/find.scala and src/main/HowManyHoursISpentOnThisLab.scala.

3. Save your work using git add, followed by git commit, with the right parameters. Make sure that your commit message if correctly formatted. We enforce the following format:

   <Scope>: <Summary>
   
   <Description>
   

   • The scope indicates what part of the course the code relates to. In this assignment, the scope should be find-hof.
   • The summary gives a high-level overview your changes. It should start with a capital letter.
   • The description describes the changes in detail—this includes information such as why the changes were necessary, which functions were changed, or what implementation decisions were taken. Here are some examples.
   • The complete header line (scope + summary) should be at most 80 characters.
   • Note that the < and > symbols are often used to show places where you should fill in a value: do not actually write these symbols in your message!

   A plain call to git commit will open your $GIT_EDITOR, which lets you input the header line and the body line separately. If you prefer to stay on the command line, you can pass the -m option multiple times: git commit -m "<Scope>: <Summary>" -m "<Description>".

4. Create a patch from your commit, using git format-patch with the correct arguments, and rename it to lab.patch.

5. Submit your patch (named lab.patch) to Moodle.

If you need help, review the lecture about version control and the corresponding exercise set.

© 2023, 2024 EPFL. All rights reserved.