CPSC 370: Functional and Logic Programming ( Fall 2023)

1. How many binary Bool functions are there?
2. How mamy of these are monoids?
3. How many are semigroups but not monoids?

Write a function
isSorted::(Ord a) => ArrayNE a -> Bool
that returns True iff its argument is sorted in non-decreasing (≤) order.

Hoogle the Down newtype. What is it for?

Show how to use your previous isSorted function for ArrayNEs, Down, and fmap to determine if an ArrayNE is sorted in non-increasing (≥) order.

With a newtype wrapper

newtype Cx = Cx { getCs :: Int }

around Int, is

instance Semigroup Cx where
    x <> y = Cx (1 + getCx x)

a legitimate semigroup definition? Why or why not?

data OneValueType = ThisIsIt
instance Semigroup OneValueType where 
    (<>) = const
instance Monoid OneValueType where
   mempty = ThisIsIt
 

(yes, this example is perverse.)

1. Functor,
2. Foldable, and
3. Applicative

data RoseTree a
  = Pure a
  | Nest [RoseTree a]

Write a definition for the uncurry function.

Yes, it is possible to Hoogle the answer.

The preferred approach is to look hard at your answers to Question 14-(7,8) until you are sure you know what uncurry is doing.

Next, climb a 10 000' mountain. Ignore the sweat dripping into your eyes, and obtain a state of Zen-like calm. Wait for the solution to arrive.

When it doesn’t, climb back down the mountain. Be sure to have a pencil and piece of paper with you. When the answer suddenly occurs to you, write it down.

When you get home, try it out in ghci.

The Maybe type gets used a lot, partially because it provides a way to make partial functions total, partially because Maybe is an instance of important classes like Monad and Applicative.

Consequently there are a lot of small, but useful functions for Maybe. Many of them can be written wusing maybe (that's the function, not the type).

For each of the following maybe expressions;

• Determine its type. (See if you can cmopute the type in your head. Check it with :type)
• Try to figure out what it might be useful for.
• Determine its standard name (using Hoogle on its type).

Try these:

1. maybe Nothing Just
2. maybe Nothing (Just . f) (Here f must be a function. Try specific functions to see if you can get a pattern.)
3. flip maybe id
4. maybe Nothing id
5. maybe True (const False). Also, what does const do? Why is it necessary here?
6. maybe [] (:[]).

Using the notion of guards from Chapter 3, wrote code to compute the sin function using the formulas on this page. Hote that you can ignore everything after the word Bonus.

The point of this question is to learn how to use guard notation (and possibly let or where). If you are having difficulty reading the math notation, ask me!

Think about exch expression. See if you can work out in your head what the type is (or determine that there is something wrong).

Use ghci to determine which of these expressions are legal. For the legal values, use “:type” to determine what the type of the expression is.

Do any of the results surprise you?

The arc hyperbolic cosine is defined by
arc cosh y = log ( y ± sqrt ( y^2 - 1))
Use the totalSqrt and totalLog defined in the previous question to write a
totalArcCosh :: Double -> Maybe Double
function. The point of this question is to experience using functions like totalSqrt. It is possible to code a function totalArcCosh :: Double -> Maybe Double directly, but that is not the point of this question.

(The arc cosh is the inverse of the cosh function, defined by
cosh x = ((exp x) + (exp (-x)))/2 .
You can use this fact to test your arc cosh function: you should have (arc cosh (cosh x)) = x.)

totalDot :: (b -> Maybe c) 
         -> (a -> Maybe b) 
         -> (a -> Maybe c)

(.) :: (b -> c) -> (a -> b) -> (a -> c)

1. What is the type of maybe?
2. Can you see a way to use maybe to give very consice defintion of totalDot?

Use ghci to determine which of these expressions are legal. For the legal values, use “:type” to determine what the type of the expression is.

Do any of the results surprise you?

public class Oooops {
/* /* Don’t try this */ at home */
}