fork(1) download 
  1. {-|
  2. Module: Ex1
  3. Description: Exercise 1: Getting Started with Racket and Haskell
  4. Copyright: (c) University of Toronto, 2019
  5.                CSC324 Principles of Programming Languages, Fall 2019
  6.  
  7. Before starting, please review the exercise guidelines at
  8. <https://w...content-available-to-author-only...o.edu/~david/csc324/homework.html>.
  9.  
  10. This part of the exercise is similar in spirit to the Racket part, except using
  11. the Haskell programming language instead.
  12.  
  13. We strongly recommend completing the functions in Racket (and verifying their
  14. correctness) first, so that way your work in this part can be done by translating
  15. the syntax of Racket into Haskell.
  16.  
  17. The one /new/ idea here is the use of the QuickCheck library to use a different
  18. kind of approach to testing called /property-based testing/. We illustrate a few simple property-based tests throughout this file.
  19. -}
  20. -- This lists what this module. Don't change this!
  21. module Ex1
  22.   ( celsiusToFahrenheit
  23.   , nCopies
  24.   , numEvens
  25.   , numManyEvens
  26.   )
  27. where
  28.  
  29. -- Imports used for testing purposes only.
  30. import Test.QuickCheck (Property, quickCheck, (==>))
  31.  
  32. -------------------------------------------------------------------------------
  33. -- * Note about type signatures
  34. --
  35. -- Unlike Racket, Haskell is /statically-typed/. We'll go into more detail about
  36. -- what this means later in the course, but for now we've provided type signatures
  37. --  for the functions here to simplify any compiler error messages you might
  38. -- receive. (Don't change them; they're required to compile against our tests.)
  39. -------------------------------------------------------------------------------
  40.  
  41. -- | Converts a temperature from Celsius to Fahrenheit.
  42. -- __Note__: use the @round@ function to convert from floating-point types
  43. -- to @Int@.
  44. celsiusToFahrenheit :: Float -> Int
  45. celsiusToFahrenheit temp =
  46.     -- TODO: replace `undefined` with a proper function body.
  47.     undefined
  48.  
  49. -- | The simplest "property-based test" is simply a unit test; note the type.
  50. prop_celsius0 :: Bool
  51. prop_celsius0 = celsiusToFahrenheit 0 == 32
  52. prop_celsius37 :: Bool
  53. prop_celsius37 = celsiusToFahrenheit 37 == 99
  54.  
  55. -------------------------------------------------------------------------------
  56. -- * Recursion with numbers
  57. --
  58. -- For the recursive functions, we recommend doing these in two ways:
  59. --
  60. --   1. First, write them using @if@ expressions, as you would in Racket.
  61. --   2. Then when that works, use /pattern-matching/ to simplify the definitions
  62. --      (<http://l...content-available-to-author-only...l.com/syntax-in-functions#pattern-matching>).
  63. --
  64. -- Remember: Strings are simply lists of characters. (@String === [Char]@)
  65. -- Read more about manipulating lists at
  66. -- <http://l...content-available-to-author-only...l.com/starting-out#an-intro-to-lists>.
  67.  
  68. -- | Returns a new string that contains @n@ copies of the input string.
  69. nCopies :: String -> Int -> String
  70. nCopies s n =
  71.     undefined
  72.  
  73.  
  74. -- | This is a QuickCheck property that says,
  75. -- "If n >= 0, then when you call nCopies on a string s and int n,
  76. -- the length of the resulting string is equal to
  77. -- n * the length of the original string."
  78. --
  79. -- QuickCheck verifies this property holds for a random selection of
  80. -- inputs (by default, choosing 100 different inputs).
  81. prop_nCopiesLength :: String -> Int -> Property
  82. prop_nCopiesLength s n = n >= 0 ==> length (nCopies s n) == (length s * n)
  83.  
  84. -------------------------------------------------------------------------------
  85. -- * Recursion with lists
  86. -------------------------------------------------------------------------------
  87.  
  88. -- | Returns the number of even elements in the given list.
  89. --
  90. -- We've given you a recursive template here to start from.
  91. -- But noted as above, you can later try simplifying this definition
  92. -- using pattern matching.
  93. numEvens :: [Int] -> Int
  94. numEvens numbers =
  95.     undefined
  96.     -- if null numbers
  97.     -- then
  98.     --   ...
  99.     -- else
  100.     --   let firstNumber = head numbers
  101.     --     pickBetterName = numEvens (tail numbers)
  102.     --   in
  103.     --     ...
  104.  
  105. -- | Returns the number of inner lists that contain three or more even integers.
  106. numManyEvens :: [[Int]] -> Int
  107. numManyEvens listsOfNums =
  108.     undefined
  109.  
  110.  
  111. -- | This is a property that says, "the number returned by numEvens is
  112. -- less than or equal to the length of the original list."
  113. prop_numEvensLength :: [Int] -> Bool
  114. prop_numEvensLength nums = numEvens nums <= length nums
  115.  
  116. -- | What do you think this property says?
  117. prop_numManyEvensDoubled :: [[Int]] -> Bool
  118. prop_numManyEvensDoubled listsOfNums =
  119.   let doubled = listsOfNums ++ listsOfNums
  120.   in numManyEvens doubled == 2 * numManyEvens listsOfNums
  121.  
  122. -------------------------------------------------------------------------------
  123. -- * Main function (for testing purposes only)
  124. -------------------------------------------------------------------------------
  125.  
  126. -- This main function is executed when you compile and run this Haskell file.
  127. -- It runs the QuickCheck tests; we'll talk about "do" notation much later in
  128. -- the course, but for now if you want to add your own tests, just define them
  129. -- above, and add a new `quickCheck` line below.
  130. main :: IO ()
  131. main = do
  132.   quickCheck prop_celsius0
  133.   quickCheck prop_celsius37
  134.   quickCheck prop_nCopiesLength
  135.   quickCheck prop_numEvensLength
  136.   quickCheck prop_numManyEvensDoubled
Compilation error #stdin compilation error #stdout 0s 0KB
comments (?)
stdin 
Standard input is empty
compilation info 
[1 of 1] Compiling Ex1              ( prog.hs, prog.o )

prog.hs:30:1: error:
    Could not find module ‘Test.QuickCheck’
    Use -v to see a list of the files searched for.
   |
30 | import Test.QuickCheck (Property, quickCheck, (==>))
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
stdout 
Standard output is empty
https://ideone.com/v7vuWn
language:
Haskell (ghc 8.4.4)
created:
6 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!