Links

• https://www.medicalnewstoday.com/
• https://www.medicalnewstoday.com/articles/324558.php
• https://mediabiasfactcheck.com/medical-news-today/
• https://www.quora.com/How-can-I-find-a-replication-of-a-study
• https://en.m.wikipedia.org/wiki/Web_of_Science
• https://www.nature.com/articles/s41551-019-0356-9#MOESM1
• https://www.nature.com/natbiomedeng/
• https://www.nature.com/articles/s41551-019-0356-9
• https://www.palain.com/?page_id=404

• Link to HPR 2112 (Home Server) episode mentioned in this podcast
  http://hackerpublicradio.org/eps.php?id=2112

• My first MP3 player was a Jelly Bean shaped MP3 player apparently known as an S1 MP3 player
  https://en.wikipedia.org/wiki/S1_MP3_player

• Sansa Clip info on wikipedia
  http://en.wikipedia.org/wiki/Sansa_Clip#Sansa_Clip

• Raspberry Pi
  https://en.wikipedia.org/wiki/Raspberry_Pi

• Music On Console (MOC) is an ncurses-based console audio player for Linux/UNIX
  

  • Here is a link to information about moc on wikipedia
    https://en.wikipedia.org/wiki/Music_on_Console

  • On a Debian based system Moc can be installed by issuing the following command
    

        sudo apt-get install moc

  • Link to Moc, Music On Console homepage
    https://moc.daper.net/

Type classes are Haskell’s way of doing ad hoc polymorphics or overloading. They are used to defined set of functions that can operate more than one specific type of data.

Equality

In Haskell there’s no default equality, it has to be defined.

There’s two parts to the puzzle. First is type class Eq that comes with the standard library and defines function signatures for equality and non-equality comparisons. There’s type parameter a in the definition, which is filled by user when they define instance of Eq for their data. In that instance definition, a is filled with concrete type.

class  Eq a where
  (==) :: a -> a -> Bool
  (/=) :: a -> a -> Bool

  x /= y = not (x == y)

Definition above can be read as “class Eq a that has two functions with following signatures and implementations”. In other words, given two a, this function determines are they equal or not (thus Bool as return type). /= is defined in terms of ==, so it’s enough to define one and you get other one for free. But you can still define both if you’re so included (maybe some optimization case).

If we define our own Size type, like below, we can compare sizes:

data Size = Small | Medium | Large
    deriving (Show, Read)

instance Eq Size where
    Small == Small = True
    Medium == Medium = True
    Large == Large = True
    _ == _ = False

And here’s couple example comparisons.

> Small == Small
True
> Large /= Large
False

Writing these by hand is both tedious and error prone, so we usually use automatic derivation for them. Note how the second line now reads deriving (Show, Read, Eq).

data Size = Small | Medium | Large
    deriving (Show, Read, Eq)

Hierarchy between type classes

There can be hierarchy between type classes, meaning one requires presence of another. Common example is Ord, which is used to order data.

class Eq a => Ord a where
    compare :: a -> a -> Ordering
    (<) :: a -> a -> Bool
    (>=) :: a -> a -> Bool
    (>) :: a -> a -> Bool
    (<=) :: a -> a -> Bool
    max :: a -> a -> a
    min :: a -> a -> a

This definition can be read as “class Ord a, where a has instance of Eq, with pile of functions as follows”. Ord has default implementation for quite many of these, in terms of others, so it’s enough to implement either compare or <=.

For our Size, instance of Ord could be defined as:

instance Ord Size where
    Small <= _ = True
    Medium <= Small = False
    Medium <= _ = True
    Large <= Large = True
    Large <= _ = False

Writing generic code

There’s lots and lots of type classes in standard library:

• Num for numeric operations
• Integral for integer numbers
• Floating for floating numbers
• Show for turning data into strings
• Read for turning strings to data
• Enum for sequentially ordered types (these can be enumerated)
• Bounded for things with upper and lower bound
• and so on…

Type classes allow you to write really generic code. Following is contrived example using Ord and Show:

check :: (Ord a, Show a) => a -> a -> String
check a b =
    case compare a b of
        LT ->
            show a ++ " is smaller than " ++ show b
        GT ->
            show a ++ " is greater than " ++ show b
        EQ ->
            show a ++ " and " ++ show b ++ " are equal"

Check takes two parameters that are same type and that type has to have Ord and Show instances. Ord is for ordering and Show is for turning data into string (handy for displaying it). The end result is string telling result of comparison. Below is some examples of usage. Note how our function can handle different types of data: Size, Int and [Int].

> check Medium Small
"Medium is greater than Small"
> check Small Large
"Small is smaller than Large"
> check 7 3
"7 is greater than 3"
> check [1, 2] [1, 1, 1]
"[1, 2] is greater than [1, 1, 1]"

There are many extensions to type classes that add more behaviour. These aren’t part of standard Haskell, but can be enabled with a pragma definition or compiler flag. They can be somewhat more complicated to use, have special cases that need careful consideration, but offer interesting options.

In closing

Thank you for listening. Question, comments and feedback welcome. Best way to catch me nowadays is either by email or in fediverse, where I’m tuturto@mastodon.social.

I use pdmenu a lot to help me do work on my main desktop PC. I did an HPR show on pdmenu on 13 December 2017 and the author Joey Hess responded in show 2459.

In the intervening time I have also integrated Zenity into my menus. This is a GUI tool which generates a number of different pop-up windows known as dialogs, which can display information, or into which information can be typed. The capabilities provided by pdmenu are a little too basic to enable me to do what I need to do.

I thought it might be of interest to show some examples of how I use this tool with pdmenu.

Long notes

I have provided detailed notes as usual for this episode, and these can be viewed here.

Links

• Pdmenu:
  • Pdmenu website
  • Joey Hess
• Zenity
  • Wikipedia page
  • Zenity Manual

Ingredients:

• 1 lb (500g) Sausage (chicken or pork works)
• 1 ½ cups (192g) Orzo
• 2 tbsp (40g) Butter
• Olive oil
• Zucchini
• Shallot
• 1 - 2 tbsp (20-40g) Italian Seasoning
• Pepper
• 2 cups (475ml) water
• 1 tsp (4g) stock concentrate
• 16oz (450g?? One normal can, whatever that is) Crushed or diced tomatoes
• 1 cup (226g) Mozzarella cheese (shredded)
• Panko Breadcrumbs
• Salt (Optional)

1. Mince half the shallot (or all of it, I'm not the boss of you). Trim and shred the zucchini. Prepare a mixing bowl lined with a paper towel.
2. Preheat oven to 500 F
3. Drizzle some oil into a large oven-proof pan (if you've got one) and cook the sausage, with half the Italian seasoning, over medium heat, breaking it into bite-sized pieces as you cook it. Transfer to the mixing bowl for later.
4. Add another drizzle of olive oil, and shred the zucchini into the pan. Add shallot, and cook until the zucchini shrinks to ⅔ of its size (about 5 minutes). Transfer to the mixing bowl with the sausage.
5. Wipe out the pan with a paper towel. Melt 1 tbsp of butter over medium heat, and add orzo, stirring pretty frequently for 2-3 minutes.
6. Stir in the rest of the Italian seasoning, along with the water, tomatoes, and stock concentrate. Bring to a boil and stir until orzo is done - around 12 - 14 minutes.
7. Drain excess liquid from the zucchini and sausage.
8. Mix sausage & zucchini into orzo mixture, with 1 tbsp of butter. Season with salt & pepper, if you want.
9. If you don't have an oven-proof pan, you're going to want to transfer everything over to a large baking dish of some kind. 13x9" works for me.
10. Cover the mixture in mozzarella cheese and panko breadcrumbs - in that order!
11. Place dish in the oven for 2-3 minutes, until the breadcrumbs are toasted.

Note: If these metric measurements seem crazy, they probably are.

https://sites.google.com/site/recycledrecumbents/ez-clone-drawings

Pictures

One of the donors

Dross

The gold

First cut

Cutting tubes

Workmate

Frame 2 parts

Frame 1 parts

Links to Stuff Mentioned in the Episode

• Flickr Photo Album
• Assorted cassette deck belts on eBay
• Kahoot! Make Learning Awesome.

• Shoe Laces Ted Talk with over 6.5 million views
  https://www.ted.com/talks/terry_moore_how_to_tie_your_shoes?language=en

• Some further info on the shoe lace knot from the wonderful wikipedia site
  https://en.wikipedia.org/wiki/Shoelace_knot

• Fast tie shoe laces recommended for anyone in a hurry
  https://www.amazon.co.uk/Gritin-Elastic-Laces-Black-Reflective/dp/B07GYM9RC8/ref=cts_sp_3_vtp