Making our own types and typeclasses

Making our own types and typeclasses

1. Record syntax

   • Here's how we could achieve a functionality with record syntax
     • data Person Person { firstName:: String, lastName:: String, age:: Int, height: Float, phoneNumber: String, flavor:: String deriving (Show)
       • We use curly brackets
       • firstNam then we write a double colon
       • First we write the name of the field, for instance

2. Derived instances

   • we first make our data type and then we think about what it can act like
   • a typeclass is a sort of an interface that defines some behavior
     • Haskell can derive the behavior of our types in these contexts if we use the deriving keyword when making our data type
     • A type can be made an instance of a typeclass if it supports that behavior

3. Type parameters

   • A value constructor can take some values parameters and then produce a new value.
     • data Maybe a Nothing | Just a
   • Type parameters are useful because we can make different types with them depending on what kind of types we want contained in our data type.

4. Algebraic data types

   • data means that we're defining a new data type. Ther part before the=denotes the type
     • If we wanted to export the functions and types that we defined here in a module
       • module Shapes (Point (..), Shape (..). surface, nudge, baseCircle, baseRect) where
     • if we add deriving at the end of a data declaration, Haskell automagically makes that type part of the show typeclass
     • data means that we're difining a new data type. The part before the = denotes the type
       • To make our own type to represent a shape
         • a shape can be a circle or a rectangle
           • data Shape = Circle Float Float Float | Rectangle Float Float Float Float

5. Kinds

   • :k -> Type of a Type
     • * mean a concrete type

6. The Functor

   • For things who can be mapped out
     • Using fmap

7. Yes-no classes

   • To play with the boolean definition
     • class YesNo a where yesno :: a -> Bool
     • Made an instance for each type

8. Recursive data structures

   • Declaration of inflix functions
     • Left-associative
       • inflix <code> <operator>
     • Right-associative
       • ifixr <code> <operator>

9. Type synonyms

   • They're just about givingsome types different names so that they make more sense to someone reading our code and documentation
     • Type synonyms can also be parameterized
       • if we want a type that represents an association list type
         • type AssocList k v = [(k,v)]