stefan@stefans-MacBook-Pro curs5 % ghci
ghci
GHCi, version 8.10.7: https://www.haskell.org/ghc/  :? for help
Prelude> :l curs5
:l curs5
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> f 10
f 10
11
*Main> :q
:q
Leaving GHCi.
stefan@stefans-MacBook-Pro curs5 % ghci
ghci
GHCi, version 8.10.7: https://www.haskell.org/ghc/  :? for help
Prelude> :l curs5
:l curs5
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> Mon
Mon

<interactive>:2:1: error:
    • No instance for (Show Dow) arising from a use of ‘print’
    • In a stmt of an interactive GHCi command: print it
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> Mon
Mon
Mon
*Main> :i Show
:i Show
type Show :: * -> Constraint
class Show a where
  showsPrec :: Int -> a -> ShowS
  show :: a -> String
  showList :: [a] -> ShowS
  {-# MINIMAL showsPrec | show #-}
  	-- Defined in ‘GHC.Show’
instance [safe] Show Dow -- Defined at curs5.hs:6:61
instance (Show a, Show b) => Show (Either a b)
  -- Defined in ‘Data.Either’
instance Show a => Show [a] -- Defined in ‘GHC.Show’
instance Show Word -- Defined in ‘GHC.Show’
instance Show GHC.Types.RuntimeRep -- Defined in ‘GHC.Show’
instance Show Ordering -- Defined in ‘GHC.Show’
instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
instance Show Integer -- Defined in ‘GHC.Show’
instance Show Int -- Defined in ‘GHC.Show’
instance Show Char -- Defined in ‘GHC.Show’
instance Show Bool -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g,
          Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) =>
         Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g,
          Show h, Show i, Show j, Show k, Show l, Show m, Show n) =>
         Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g,
          Show h, Show i, Show j, Show k, Show l, Show m) =>
         Show (a, b, c, d, e, f, g, h, i, j, k, l, m)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g,
          Show h, Show i, Show j, Show k, Show l) =>
         Show (a, b, c, d, e, f, g, h, i, j, k, l)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g,
          Show h, Show i, Show j, Show k) =>
         Show (a, b, c, d, e, f, g, h, i, j, k)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g,
          Show h, Show i, Show j) =>
         Show (a, b, c, d, e, f, g, h, i, j)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g,
          Show h, Show i) =>
         Show (a, b, c, d, e, f, g, h, i)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g,
          Show h) =>
         Show (a, b, c, d, e, f, g, h)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f,
          Show g) =>
         Show (a, b, c, d, e, f, g)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e, Show f) =>
         Show (a, b, c, d, e, f)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d, Show e) =>
         Show (a, b, c, d, e)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c, Show d) => Show (a, b, c, d)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b, Show c) => Show (a, b, c)
  -- Defined in ‘GHC.Show’
instance (Show a, Show b) => Show (a, b) -- Defined in ‘GHC.Show’
instance Show () -- Defined in ‘GHC.Show’
instance Show Float -- Defined in ‘GHC.Float’
instance Show Double -- Defined in ‘GHC.Float’
*Main> show Mon
show Mon
"Mon"
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> show Mon
show Mon
"Luni"
*Main> Mon
Mon
Luni
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> Succ (Succ (Succ Zero))
Succ (Succ (Succ Zero))
Succ (Succ (Succ Zero))
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> trei == doi
trei == doi

<interactive>:14:1: error:
    • No instance for (Eq Nat) arising from a use of ‘==’
    • In the expression: trei == doi
      In an equation for ‘it’: it = trei == doi
*Main> :i (==)
:i (==)
type Eq :: * -> Constraint
class Eq a where
  (==) :: a -> a -> Bool
  ...
  	-- Defined in ‘GHC.Classes’
infix 4 ==
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> trei == doi
trei == doi
False
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> trei == doi
trei == doi
False
*Main> trei == trei
trei == trei
True
*Main> Zero == doi
Zero == doi
False
*Main> Zero == Zero
Zero == Zero
True
*Main> :i Eq
:i Eq
type Eq :: * -> Constraint
class Eq a where
  (==) :: a -> a -> Bool
  (/=) :: a -> a -> Bool
  {-# MINIMAL (==) | (/=) #-}
  	-- Defined in ‘GHC.Classes’
instance [safe] Eq Nat -- Defined at curs5.hs:35:10
instance Eq a => Eq [a] -- Defined in ‘GHC.Classes’
instance Eq Word -- Defined in ‘GHC.Classes’
instance Eq Ordering -- Defined in ‘GHC.Classes’
instance Eq Int -- Defined in ‘GHC.Classes’
instance Eq Float -- Defined in ‘GHC.Classes’
instance Eq Double -- Defined in ‘GHC.Classes’
instance Eq Char -- Defined in ‘GHC.Classes’
instance Eq Bool -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
          Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) =>
         Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
          Eq j, Eq k, Eq l, Eq m, Eq n) =>
         Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
          Eq j, Eq k, Eq l, Eq m) =>
         Eq (a, b, c, d, e, f, g, h, i, j, k, l, m)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
          Eq j, Eq k, Eq l) =>
         Eq (a, b, c, d, e, f, g, h, i, j, k, l)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
          Eq j, Eq k) =>
         Eq (a, b, c, d, e, f, g, h, i, j, k)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i,
          Eq j) =>
         Eq (a, b, c, d, e, f, g, h, i, j)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) =>
         Eq (a, b, c, d, e, f, g, h, i)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) =>
         Eq (a, b, c, d, e, f, g, h)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) =>
         Eq (a, b, c, d, e, f, g)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) =>
         Eq (a, b, c, d, e, f)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b, Eq c) => Eq (a, b, c)
  -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b) => Eq (a, b) -- Defined in ‘GHC.Classes’
instance Eq () -- Defined in ‘GHC.Classes’
instance (Eq a, Eq b) => Eq (Either a b)
  -- Defined in ‘Data.Either’
instance Eq a => Eq (Maybe a) -- Defined in ‘GHC.Maybe’
instance Eq Integer
  -- Defined in ‘integer-gmp-1.0.3.0:GHC.Integer.Type’
*Main> trei /= doi
trei /= doi
True
*Main> trei /= trei
trei /= trei
False
*Main> Lr
Lr

<interactive>:26:1: error:
    • Data constructor not in scope: Lr
    • Perhaps you meant one of these:
        ‘LT’ (imported from Prelude), variable ‘or’ (imported from Prelude)
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> Zero /= Zero
Zero /= Zero
False
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> egal trei doi
egal trei doi
False
*Main> egal trei trei
egal trei trei
True
*Main> notegal trei trei
notegal trei trei
False
*Main> notegal trei doi
notegal trei doi
True
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:49:10: warning: [-Wmissing-methods]
    • No explicit implementation for
        ‘notegal’
    • In the instance declaration for ‘MyEq Nat’
   |
49 | instance MyEq Nat where 
   |          ^^^^^^^^
Ok, one module loaded.
*Main> notegal Zero Zero
notegal Zero Zero
*** Exception: curs5.hs:49:10-17: No instance nor default method for class operation notegal

*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> notegal Zero Zero
notegal Zero Zero
False
*Main> notegal trei Zero
notegal trei Zero
True
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:50:10: warning: [-Wmissing-methods]
    • No explicit implementation for
        ‘egal’
    • In the instance declaration for ‘MyEq Nat’
   |
50 | instance MyEq Nat where 
   |          ^^^^^^^^
Ok, one module loaded.
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> :r
:r
Ok, one module loaded.
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> :i MyEq
:i MyEq
type MyEq :: * -> Constraint
class MyEq a where
  egal :: a -> a -> Bool
  notegal :: a -> a -> Bool
  	-- Defined at curs5.hs:45:1
instance [safe] MyEq Nat -- Defined at curs5.hs:51:10
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> trei
trei
Succ (Succ (Succ Zero))
*Main> iminustrei
iminustrei
Neg (Succ (Succ (Succ Zero)))
*Main> itrei
itrei
Pos (Succ (Succ (Succ Zero)))
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> (==) (Pos Zero) (Neg Zero)
(==) (Pos Zero) (Neg Zero)
False
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> (==) (Pos Zero) (Neg Zero)
(==) (Pos Zero) (Neg Zero)
True
*Main> (==) (Pos Zero) (Neg trei)
(==) (Pos Zero) (Neg trei)
False
*Main> (==) (Pos trei) (Neg trei)
(==) (Pos trei) (Neg trei)
False
*Main> (==) (Pos doi) (Neg trei)
(==) (Pos doi) (Neg trei)
False
*Main> (==) (Neg doi) (Neg trei)
(==) (Neg doi) (Neg trei)
False
*Main> (==) (Neg doi) (Neg doi)
(==) (Neg doi) (Neg doi)
True
*Main> (==) (Pos doi) (Pos doi)
(==) (Pos doi) (Pos doi)
True
*Main> (==) (Pos doi) (Neg doi)
(==) (Pos doi) (Neg doi)
False
*Main> :i Ord
:i Ord
type Ord :: * -> Constraint
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
  {-# MINIMAL compare | (<=) #-}
  	-- Defined in ‘GHC.Classes’
instance Ord a => Ord [a] -- Defined in ‘GHC.Classes’
instance Ord Word -- Defined in ‘GHC.Classes’
instance Ord Ordering -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Ord Float -- Defined in ‘GHC.Classes’
instance Ord Double -- Defined in ‘GHC.Classes’
instance Ord Char -- Defined in ‘GHC.Classes’
instance Ord Bool -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l, Ord m) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j) =>
         Ord (a, b, c, d, e, f, g, h, i, j)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i) =>
         Ord (a, b, c, d, e, f, g, h, i)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
          Ord h) =>
         Ord (a, b, c, d, e, f, g, h)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) =>
         Ord (a, b, c, d, e, f, g)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) =>
         Ord (a, b, c, d, e, f)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b) => Ord (a, b) -- Defined in ‘GHC.Classes’
instance Ord () -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b) => Ord (Either a b)
  -- Defined in ‘Data.Either’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Maybe’
instance Ord Integer
  -- Defined in ‘integer-gmp-1.0.3.0:GHC.Integer.Type’
*Main> :i Ordering
:i Ordering
type Ordering :: *
data Ordering = LT | EQ | GT
  	-- Defined in ‘GHC.Types’
instance Eq Ordering -- Defined in ‘GHC.Classes’
instance Monoid Ordering -- Defined in ‘GHC.Base’
instance Ord Ordering -- Defined in ‘GHC.Classes’
instance Semigroup Ordering -- Defined in ‘GHC.Base’
instance Enum Ordering -- Defined in ‘GHC.Enum’
instance Show Ordering -- Defined in ‘GHC.Show’
instance Read Ordering -- Defined in ‘GHC.Read’
instance Bounded Ordering -- Defined in ‘GHC.Enum’
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> Zero < (Succ Zero)
Zero < (Succ Zero)
True
*Main> Zero < Zero
Zero < Zero
False
*Main> Zero < (Succ (Succ zero))
 Zero < (Succ (Succ zero))

<interactive>:65:21: error:
    • Variable not in scope: zero :: Nat
    • Perhaps you meant data constructor ‘Zero’ (line 30)
*Main>  Zero < (Succ (Succ Z~ero))
 Zero < (Succ (Succ Z~ero))

<interactive>:66:22: error:
    Pattern syntax in expression context: ~ero
*Main>  Zero < (Succ (Succ Zero))
 Zero < (Succ (Succ Zero))
True
*Main> (Succ Zero) < (Succ (Succ Zero))
(Succ Zero) < (Succ (Succ Zero))
True
*Main> (Succ (Succ Zero)) < (Succ (Succ Zero))
(Succ (Succ Zero)) < (Succ (Succ Zero))
False
*Main> trei < (Succ (Succ Zero))
 trei < (Succ (Succ Zero))
False
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> Zero < (Succ Zero)
Zero < (Succ Zero)
False
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:31:44: error:
    • Overlapping instances for Ord Nat
        arising from the first field of ‘Succ’ (type ‘Nat’)
      Matching instances:
        instance Ord Nat -- Defined at curs5.hs:31:44
        instance Ord Nat -- Defined at curs5.hs:46:10
    • When deriving the instance for (Ord Nat)
   |
31 | data Nat = Succ Nat | Zero deriving (Show, Ord)
   |                                            ^^^
Failed, no modules loaded.
Prelude> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:46:10: warning: [-Wmissing-methods]
    • No explicit implementation for
        either ‘compare’ or ‘<=’
    • In the instance declaration for ‘Ord Nat’
   |
46 | instance Ord Nat where
   |          ^^^^^^^
Ok, one module loaded.
*Main> :i
:i
syntax: ':i <thing-you-want-info-about>'
*Main> :i Ord
:i Ord
type Ord :: * -> Constraint
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
  {-# MINIMAL compare | (<=) #-}
  	-- Defined in ‘GHC.Classes’
instance [safe] Ord Nat -- Defined at curs5.hs:46:10
instance Ord a => Ord [a] -- Defined in ‘GHC.Classes’
instance Ord Word -- Defined in ‘GHC.Classes’
instance Ord Ordering -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Ord Float -- Defined in ‘GHC.Classes’
instance Ord Double -- Defined in ‘GHC.Classes’
instance Ord Char -- Defined in ‘GHC.Classes’
instance Ord Bool -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l, Ord m) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j) =>
         Ord (a, b, c, d, e, f, g, h, i, j)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i) =>
         Ord (a, b, c, d, e, f, g, h, i)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
          Ord h) =>
         Ord (a, b, c, d, e, f, g, h)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) =>
         Ord (a, b, c, d, e, f, g)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) =>
         Ord (a, b, c, d, e, f)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b) => Ord (a, b) -- Defined in ‘GHC.Classes’
instance Ord () -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b) => Ord (Either a b)
  -- Defined in ‘Data.Either’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Maybe’
instance Ord Integer
  -- Defined in ‘integer-gmp-1.0.3.0:GHC.Integer.Type’
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> trei < doi
trei < doi
False
*Main> doi < doi
doi < doi
False
*Main> doi <= doi
doi <= doi
True
*Main> doi <= trei
doi <= trei
True
*Main> Zero <= trei
Zero <= trei
True
*Main> :r
:r
Ok, one module loaded.
*Main> :i Nat
:i Nat
type Nat :: *
data Nat = Succ Nat | Zero
  	-- Defined at curs5.hs:31:1
instance [safe] Show Nat -- Defined at curs5.hs:31:37
instance [safe] Eq Nat -- Defined at curs5.hs:36:10
instance [safe] MyEq Nat -- Defined at curs5.hs:58:10
instance [safe] Ord Nat -- Defined at curs5.hs:46:10
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:46:10: error:
    • No instance for (Eq Nat)
        arising from the superclasses of an instance declaration
    • In the instance declaration for ‘Ord Nat’
   |
46 | instance Ord Nat where
   |          ^^^^^^^
Failed, no modules loaded.
Prelude> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:46:10: error:
    • No instance for (Eq Nat)
        arising from the superclasses of an instance declaration
    • In the instance declaration for ‘Ord Nat’
   |
46 | instance Ord Nat where
   |          ^^^^^^^
Failed, no modules loaded.
Prelude> :i Ord
:i Ord
type Ord :: * -> Constraint
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
  {-# MINIMAL compare | (<=) #-}
  	-- Defined in ‘GHC.Classes’
instance Ord a => Ord [a] -- Defined in ‘GHC.Classes’
instance Ord Word -- Defined in ‘GHC.Classes’
instance Ord Ordering -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Ord Float -- Defined in ‘GHC.Classes’
instance Ord Double -- Defined in ‘GHC.Classes’
instance Ord Char -- Defined in ‘GHC.Classes’
instance Ord Bool -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l, Ord m) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l, m)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k, Ord l) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k, l)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j, Ord k) =>
         Ord (a, b, c, d, e, f, g, h, i, j, k)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i, Ord j) =>
         Ord (a, b, c, d, e, f, g, h, i, j)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h,
          Ord i) =>
         Ord (a, b, c, d, e, f, g, h, i)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g,
          Ord h) =>
         Ord (a, b, c, d, e, f, g, h)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) =>
         Ord (a, b, c, d, e, f, g)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) =>
         Ord (a, b, c, d, e, f)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b, Ord c) => Ord (a, b, c)
  -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b) => Ord (a, b) -- Defined in ‘GHC.Classes’
instance Ord () -- Defined in ‘GHC.Classes’
instance (Ord a, Ord b) => Ord (Either a b)
  -- Defined in ‘Data.Either’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Maybe’
instance Ord Integer
  -- Defined in ‘integer-gmp-1.0.3.0:GHC.Integer.Type’
Prelude> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> :i Bounded
:i Bounded
type Bounded :: * -> Constraint
class Bounded a where
  minBound :: a
  maxBound :: a
  {-# MINIMAL minBound, maxBound #-}
  	-- Defined in ‘GHC.Enum’
instance Bounded Word -- Defined in ‘GHC.Enum’
instance Bounded Ordering -- Defined in ‘GHC.Enum’
instance Bounded Int -- Defined in ‘GHC.Enum’
instance Bounded Char -- Defined in ‘GHC.Enum’
instance Bounded Bool -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l, Bounded m, Bounded n, Bounded o) =>
         Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l, Bounded m, Bounded n) =>
         Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l, Bounded m) =>
         Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l) =>
         Bounded (a, b, c, d, e, f, g, h, i, j, k, l)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j,
          Bounded k) =>
         Bounded (a, b, c, d, e, f, g, h, i, j, k)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) =>
         Bounded (a, b, c, d, e, f, g, h, i, j)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i) =>
         Bounded (a, b, c, d, e, f, g, h, i)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h) =>
         Bounded (a, b, c, d, e, f, g, h)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g) =>
         Bounded (a, b, c, d, e, f, g)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f) =>
         Bounded (a, b, c, d, e, f)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) =>
         Bounded (a, b, c, d, e)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d) =>
         Bounded (a, b, c, d)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b) => Bounded (a, b)
  -- Defined in ‘GHC.Enum’
instance Bounded () -- Defined in ‘GHC.Enum’
*Main> :i Int
:i Int
type Int :: *
data Int = GHC.Types.I# GHC.Prim.Int#
  	-- Defined in ‘GHC.Types’
instance Eq Int -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Enum Int -- Defined in ‘GHC.Enum’
instance Num Int -- Defined in ‘GHC.Num’
instance Real Int -- Defined in ‘GHC.Real’
instance Show Int -- Defined in ‘GHC.Show’
instance Read Int -- Defined in ‘GHC.Read’
instance Bounded Int -- Defined in ‘GHC.Enum’
instance Integral Int -- Defined in ‘GHC.Real’
*Main> :i Integer
:i Integer
type Integer :: *
data Integer
  = integer-gmp-1.0.3.0:GHC.Integer.Type.S# GHC.Prim.Int#
  | integer-gmp-1.0.3.0:GHC.Integer.Type.Jp# {-# UNPACK #-}integer-gmp-1.0.3.0:GHC.Integer.Type.BigNat
  | integer-gmp-1.0.3.0:GHC.Integer.Type.Jn# {-# UNPACK #-}integer-gmp-1.0.3.0:GHC.Integer.Type.BigNat
  	-- Defined in ‘integer-gmp-1.0.3.0:GHC.Integer.Type’
instance Eq Integer
  -- Defined in ‘integer-gmp-1.0.3.0:GHC.Integer.Type’
instance Ord Integer
  -- Defined in ‘integer-gmp-1.0.3.0:GHC.Integer.Type’
instance Enum Integer -- Defined in ‘GHC.Enum’
instance Num Integer -- Defined in ‘GHC.Num’
instance Real Integer -- Defined in ‘GHC.Real’
instance Show Integer -- Defined in ‘GHC.Show’
instance Read Integer -- Defined in ‘GHC.Read’
instance Integral Integer -- Defined in ‘GHC.Real’
*Main> minBound :: Int
minBound :: Int
-9223372036854775808
*Main> -2^63
-2^63
-9223372036854775808
*Main> maxBound :: Int
maxBound :: Int
9223372036854775807
*Main> 2^63
2^63
9223372036854775808
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> minBound
minBound
()
*Main> minBound :: Dow
minBound :: Dow
Luni
*Main> maxBound :: Dow
maxBound :: Dow
Duminica
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:31:44: error:
    • Can't make a derived instance of ‘Bounded Nat’:
        ‘Nat’ must be an enumeration type
        (an enumeration consists of one or more nullary, non-GADT constructors)
          or
        ‘Nat’ must have precisely one constructor
    • In the data declaration for ‘Nat’
   |
31 | data Nat = Succ Nat | Zero deriving (Show, Bounded)
   |                                            ^^^^^^^
Failed, no modules loaded.
Prelude> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> :i Int
:i Int
type Int :: *
data Int = GHC.Types.I# GHC.Prim.Int#
  	-- Defined in ‘GHC.Types’
instance Eq Int -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Enum Int -- Defined in ‘GHC.Enum’
instance Num Int -- Defined in ‘GHC.Num’
instance Real Int -- Defined in ‘GHC.Real’
instance Show Int -- Defined in ‘GHC.Show’
instance Read Int -- Defined in ‘GHC.Read’
instance Bounded Int -- Defined in ‘GHC.Enum’
instance Integral Int -- Defined in ‘GHC.Real’
*Main> minBound
minBound
()
*Main> :i ()
:i ()
type () :: *
data () = ()
  	-- Defined in ‘GHC.Tuple’
instance Eq () -- Defined in ‘GHC.Classes’
instance Monoid () -- Defined in ‘GHC.Base’
instance Ord () -- Defined in ‘GHC.Classes’
instance Semigroup () -- Defined in ‘GHC.Base’
instance Enum () -- Defined in ‘GHC.Enum’
instance Show () -- Defined in ‘GHC.Show’
instance Read () -- Defined in ‘GHC.Read’
instance Bounded () -- Defined in ‘GHC.Enum’
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> asdf ()
asdf ()
3
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:89:1: error:
    Duplicate type signatures for ‘asdf’
    at curs5.hs:86:1-4
       curs5.hs:89:1-4
   |
89 | asdf :: Int -> ()
   | ^^^^

curs5.hs:90:1: error:
    Multiple declarations of ‘asdf’
    Declared at: curs5.hs:87:1
                 curs5.hs:90:1
   |
90 | asdf _ = ()
   | ^^^^
Failed, no modules loaded.
Prelude> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> asdf' 3
asdf' 3
()
*Main> asdf' 7
asdf' 7
()
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:92:1: error:
    Duplicate type signatures for ‘asdf'’
    at curs5.hs:89:1-5
       curs5.hs:92:1-5
   |
92 | asdf' :: Int -> ()
   | ^^^^^

curs5.hs:93:1: error:
    Multiple declarations of ‘asdf'’
    Declared at: curs5.hs:90:1
                 curs5.hs:93:1
   |
93 | asdf' 3 = ()
   | ^^^^^
Failed, no modules loaded.
Prelude> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> asdf'' 3
asdf'' 3
()
*Main> asdf'' 7
asdf'' 7
  ^C ^C^CInterrupted.
*Main> minBound
minBound
()
*Main> maxBound
maxBound
()
*Main> :i Bounded
:i Bounded
type Bounded :: * -> Constraint
class Bounded a where
  minBound :: a
  maxBound :: a
  {-# MINIMAL minBound, maxBound #-}
  	-- Defined in ‘GHC.Enum’
instance [safe] Bounded Dow -- Defined at curs5.hs:6:61
instance Bounded Word -- Defined in ‘GHC.Enum’
instance Bounded Ordering -- Defined in ‘GHC.Enum’
instance Bounded Int -- Defined in ‘GHC.Enum’
instance Bounded Char -- Defined in ‘GHC.Enum’
instance Bounded Bool -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l, Bounded m, Bounded n, Bounded o) =>
         Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l, Bounded m, Bounded n) =>
         Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l, Bounded m) =>
         Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k,
          Bounded l) =>
         Bounded (a, b, c, d, e, f, g, h, i, j, k, l)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j,
          Bounded k) =>
         Bounded (a, b, c, d, e, f, g, h, i, j, k)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) =>
         Bounded (a, b, c, d, e, f, g, h, i, j)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h, Bounded i) =>
         Bounded (a, b, c, d, e, f, g, h, i)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g, Bounded h) =>
         Bounded (a, b, c, d, e, f, g, h)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f, Bounded g) =>
         Bounded (a, b, c, d, e, f, g)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e,
          Bounded f) =>
         Bounded (a, b, c, d, e, f)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) =>
         Bounded (a, b, c, d, e)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c, Bounded d) =>
         Bounded (a, b, c, d)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b, Bounded c) => Bounded (a, b, c)
  -- Defined in ‘GHC.Enum’
instance (Bounded a, Bounded b) => Bounded (a, b)
  -- Defined in ‘GHC.Enum’
instance Bounded () -- Defined in ‘GHC.Enum’
*Main> :i minBound
:i minBound
type Bounded :: * -> Constraint
class Bounded a where
  minBound :: a
  ...
  	-- Defined in ‘GHC.Enum’
*Main> minBound :: ()
minBound :: ()
()
*Main> minBound :: Inyt
minBound :: Inyt

<interactive>:121:13: error:
    Not in scope: type constructor or class ‘Inyt’
    Perhaps you meant ‘Int’ (imported from Prelude)
*Main> minBound :: Int
minBound :: Int
-9223372036854775808
*Main> :i Int
:i Int
type Int :: *
data Int = GHC.Types.I# GHC.Prim.Int#
  	-- Defined in ‘GHC.Types’
instance Eq Int -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Enum Int -- Defined in ‘GHC.Enum’
instance Num Int -- Defined in ‘GHC.Num’
instance Real Int -- Defined in ‘GHC.Real’
instance Show Int -- Defined in ‘GHC.Show’
instance Read Int -- Defined in ‘GHC.Read’
instance Bounded Int -- Defined in ‘GHC.Enum’
instance Integral Int -- Defined in ‘GHC.Real’
*Main> :i Enum
:i Enum
type Enum :: * -> Constraint
class Enum a where
  succ :: a -> a
  pred :: a -> a
  toEnum :: Int -> a
  fromEnum :: a -> Int
  enumFrom :: a -> [a]
  enumFromThen :: a -> a -> [a]
  enumFromTo :: a -> a -> [a]
  enumFromThenTo :: a -> a -> a -> [a]
  {-# MINIMAL toEnum, fromEnum #-}
  	-- Defined in ‘GHC.Enum’
instance Enum Word -- Defined in ‘GHC.Enum’
instance Enum Ordering -- Defined in ‘GHC.Enum’
instance Enum Integer -- Defined in ‘GHC.Enum’
instance Enum Int -- Defined in ‘GHC.Enum’
instance Enum Char -- Defined in ‘GHC.Enum’
instance Enum Bool -- Defined in ‘GHC.Enum’
instance Enum () -- Defined in ‘GHC.Enum’
instance Enum Float -- Defined in ‘GHC.Float’
instance Enum Double -- Defined in ‘GHC.Float’
*Main> succ 3
succ 3
4
*Main> pred 3
pred 3
2
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> succ Mon
succ Mon
Marti
*Main> succ Sun
succ Sun
*** Exception: succ{Dow}: tried to take `succ' of last tag in enumeration
CallStack (from HasCallStack):
  error, called at curs5.hs:6:71 in main:Main
*Main> (toEnum 0) :: Dow
(toEnum 0) :: Dow
Luni
*Main> (toEnum 2) :: Dow
(toEnum 2) :: Dow
Miercuri
*Main> (toEnum 0) :: Bool
(toEnum 0) :: Bool
False
*Main> (toEnum 1) :: Bool
(toEnum 1) :: Bool
True
*Main> (toEnum 2) :: Bool
(toEnum 2) :: Bool
*** Exception: Prelude.Enum.Bool.toEnum: bad argument
*Main> (toEnum 0) :: Integer
(toEnum 0) :: Integer
0
*Main> (toEnum 1) :: Integer
(toEnum 1) :: Integer
1
*Main> (toEnum 2) :: Integer
(toEnum 2) :: Integer
2
*Main> (toEnum 3) :: Integer
(toEnum 3) :: Integer
3
*Main> (succ (-3))
(succ (-3))
-2
*Main> fromEnum ((-3) :: Integer)
fromEnum ((-3) :: Integer)
-3
*Main> :i Int
:i Int
type Int :: *
data Int = GHC.Types.I# GHC.Prim.Int#
  	-- Defined in ‘GHC.Types’
instance Eq Int -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Enum Int -- Defined in ‘GHC.Enum’
instance Num Int -- Defined in ‘GHC.Num’
instance Real Int -- Defined in ‘GHC.Real’
instance Show Int -- Defined in ‘GHC.Show’
instance Read Int -- Defined in ‘GHC.Read’
instance Bounded Int -- Defined in ‘GHC.Enum’
instance Integral Int -- Defined in ‘GHC.Real’
*Main> :i Num
:i Num
type Num :: * -> Constraint
class Num a where
  (+) :: a -> a -> a
  (-) :: a -> a -> a
  (*) :: a -> a -> a
  negate :: a -> a
  abs :: a -> a
  signum :: a -> a
  fromInteger :: Integer -> a
  {-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}
  	-- Defined in ‘GHC.Num’
instance Num Word -- Defined in ‘GHC.Num’
instance Num Integer -- Defined in ‘GHC.Num’
instance Num Int -- Defined in ‘GHC.Num’
instance Num Float -- Defined in ‘GHC.Float’
instance Num Double -- Defined in ‘GHC.Float’
*Main> :i Int
:i Int
type Int :: *
data Int = GHC.Types.I# GHC.Prim.Int#
  	-- Defined in ‘GHC.Types’
instance Eq Int -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Enum Int -- Defined in ‘GHC.Enum’
instance Num Int -- Defined in ‘GHC.Num’
instance Real Int -- Defined in ‘GHC.Real’
instance Show Int -- Defined in ‘GHC.Show’
instance Read Int -- Defined in ‘GHC.Read’
instance Bounded Int -- Defined in ‘GHC.Enum’
instance Integral Int -- Defined in ‘GHC.Real’
*Main> :i Real
:i Real
type Real :: * -> Constraint
class (Num a, Ord a) => Real a where
  toRational :: a -> Rational
  {-# MINIMAL toRational #-}
  	-- Defined in ‘GHC.Real’
instance Real Word -- Defined in ‘GHC.Real’
instance Real Integer -- Defined in ‘GHC.Real’
instance Real Int -- Defined in ‘GHC.Real’
instance Real Float -- Defined in ‘GHC.Float’
instance Real Double -- Defined in ‘GHC.Float’
*Main> :i Rational
:i Rational
type Rational :: *
type Rational = GHC.Real.Ratio Integer
  	-- Defined in ‘GHC.Real’
*Main> :i Read
:i Read
type Read :: * -> Constraint
class Read a where
  readsPrec :: Int -> ReadS a
  readList :: ReadS [a]
  GHC.Read.readPrec :: Text.ParserCombinators.ReadPrec.ReadPrec a
  GHC.Read.readListPrec :: Text.ParserCombinators.ReadPrec.ReadPrec
                             [a]
  {-# MINIMAL readsPrec | readPrec #-}
  	-- Defined in ‘GHC.Read’
instance Read a => Read [a] -- Defined in ‘GHC.Read’
instance Read Word -- Defined in ‘GHC.Read’
instance Read Ordering -- Defined in ‘GHC.Read’
instance Read a => Read (Maybe a) -- Defined in ‘GHC.Read’
instance Read Integer -- Defined in ‘GHC.Read’
instance Read Int -- Defined in ‘GHC.Read’
instance Read Float -- Defined in ‘GHC.Read’
instance Read Double -- Defined in ‘GHC.Read’
instance Read Char -- Defined in ‘GHC.Read’
instance Read Bool -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g,
          Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) =>
         Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g,
          Read h, Read i, Read j, Read k, Read l, Read m, Read n) =>
         Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g,
          Read h, Read i, Read j, Read k, Read l, Read m) =>
         Read (a, b, c, d, e, f, g, h, i, j, k, l, m)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g,
          Read h, Read i, Read j, Read k, Read l) =>
         Read (a, b, c, d, e, f, g, h, i, j, k, l)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g,
          Read h, Read i, Read j, Read k) =>
         Read (a, b, c, d, e, f, g, h, i, j, k)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g,
          Read h, Read i, Read j) =>
         Read (a, b, c, d, e, f, g, h, i, j)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g,
          Read h, Read i) =>
         Read (a, b, c, d, e, f, g, h, i)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e, Read f, Read g,
          Read h) =>
         Read (a, b, c, d, e, f, g, h)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e, Read f,
          Read g) =>
         Read (a, b, c, d, e, f, g)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e, Read f) =>
         Read (a, b, c, d, e, f)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d, Read e) =>
         Read (a, b, c, d, e)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c, Read d) => Read (a, b, c, d)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b, Read c) => Read (a, b, c)
  -- Defined in ‘GHC.Read’
instance (Read a, Read b) => Read (a, b) -- Defined in ‘GHC.Read’
instance Read () -- Defined in ‘GHC.Read’
instance (Read a, Read b) => Read (Either a b)
  -- Defined in ‘Data.Either’
*Main> :i ReadS
:i ReadS
type ReadS :: * -> *
type ReadS a = String -> [(a, String)]
  	-- Defined in ‘Text.ParserCombinators.ReadP’
*Main> :i read
:i read
read :: Read a => String -> a 	-- Defined in ‘Text.Read’
*Main> (read '123') :: Int
(read '123') :: Int

<interactive>:149:8: error: parse error on input ‘123’
*Main> (read "123") :: Int
(read "123") :: Int
123
*Main> (read "123") :: Integer
(read "123") :: Integer
123
*Main> (read "123") :: Float
(read "123") :: Float
123.0
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> (read "Mon")
(read "Mon")
*** Exception: Prelude.read: no parse
*Main> (read "Mon") :: Dow
(read "Mon") :: Dow
Luni
*Main> :i Int
:i Int
type Int :: *
data Int = GHC.Types.I# GHC.Prim.Int#
  	-- Defined in ‘GHC.Types’
instance Eq Int -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Enum Int -- Defined in ‘GHC.Enum’
instance Num Int -- Defined in ‘GHC.Num’
instance Real Int -- Defined in ‘GHC.Real’
instance Show Int -- Defined in ‘GHC.Show’
instance Read Int -- Defined in ‘GHC.Read’
instance Bounded Int -- Defined in ‘GHC.Enum’
instance Integral Int -- Defined in ‘GHC.Real’
*Main> :i Integral
:i Integral
type Integral :: * -> Constraint
class (Real a, Enum a) => Integral a where
  quot :: a -> a -> a
  rem :: a -> a -> a
  div :: a -> a -> a
  mod :: a -> a -> a
  quotRem :: a -> a -> (a, a)
  divMod :: a -> a -> (a, a)
  toInteger :: a -> Integer
  {-# MINIMAL quotRem, toInteger #-}
  	-- Defined in ‘GHC.Real’
instance Integral Word -- Defined in ‘GHC.Real’
instance Integral Integer -- Defined in ‘GHC.Real’
instance Integral Int -- Defined in ‘GHC.Real’
*Main> quot 5 3
quot 5 3
1
*Main> div 5 3
div 5 3
1
*Main> quot (-5) 3
quot (-5) 3
-1
*Main> div (-5) 3
div (-5) 3
-2
*Main> :i Int
:i Int
type Int :: *
data Int = GHC.Types.I# GHC.Prim.Int#
  	-- Defined in ‘GHC.Types’
instance Eq Int -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Enum Int -- Defined in ‘GHC.Enum’
instance Num Int -- Defined in ‘GHC.Num’
instance Real Int -- Defined in ‘GHC.Real’
instance Show Int -- Defined in ‘GHC.Show’
instance Read Int -- Defined in ‘GHC.Read’
instance Bounded Int -- Defined in ‘GHC.Enum’
instance Integral Int -- Defined in ‘GHC.Real’
*Main> :i Bool
:i Bool
type Bool :: *
data Bool = False | True
  	-- Defined in ‘GHC.Types’
instance Eq Bool -- Defined in ‘GHC.Classes’
instance Ord Bool -- Defined in ‘GHC.Classes’
instance Enum Bool -- Defined in ‘GHC.Enum’
instance Show Bool -- Defined in ‘GHC.Show’
instance Read Bool -- Defined in ‘GHC.Read’
instance Bounded Bool -- Defined in ‘GHC.Enum’
*Main> :t fmap
:t fmap
fmap :: Functor f => (a -> b) -> f a -> f b
*Main> map (\x -> x + 3) [ 1, 2, 3]
map (\x -> x + 3) [ 1, 2, 3]
[4,5,6]
*Main> fmap (\x -> x + 3) [ 1, 2, 3]
fmap (\x -> x + 3) [ 1, 2, 3]
[4,5,6]
*Main> :i Maybe
:i Maybe
type Maybe :: * -> *
data Maybe a = Nothing | Just a
  	-- Defined in ‘GHC.Maybe’
instance Applicative Maybe -- Defined in ‘GHC.Base’
instance Eq a => Eq (Maybe a) -- Defined in ‘GHC.Maybe’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Monad Maybe -- Defined in ‘GHC.Base’
instance Semigroup a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Maybe’
instance Semigroup a => Semigroup (Maybe a)
  -- Defined in ‘GHC.Base’
instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
instance MonadFail Maybe -- Defined in ‘Control.Monad.Fail’
instance Read a => Read (Maybe a) -- Defined in ‘GHC.Read’
instance Foldable Maybe -- Defined in ‘Data.Foldable’
instance Traversable Maybe -- Defined in ‘Data.Traversable’
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:114:24: error: parse error on input ‘then’
    |
114 |             else x < y then cmmdc x (y - x)
    |                        ^^^^
Failed, no modules loaded.
Prelude> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> cmmdc 12 46
cmmdc 12 46
Just 2
*Main> cmmdc 12 45
cmmdc 12 45
Just 3
*Main> cmmdc (2 * 2 * 3) (2 * 3 * 3)
cmmdc (2 * 2 * 3) (2 * 3 * 3)
Just 6
*Main> cmmdc 0 0 
cmmdc 0 0 
Nothing
*Main> :i Maybe
:i Maybe
type Maybe :: * -> *
data Maybe a = Nothing | Just a
  	-- Defined in ‘GHC.Maybe’
instance Applicative Maybe -- Defined in ‘GHC.Base’
instance Eq a => Eq (Maybe a) -- Defined in ‘GHC.Maybe’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Monad Maybe -- Defined in ‘GHC.Base’
instance Semigroup a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Maybe’
instance Semigroup a => Semigroup (Maybe a)
  -- Defined in ‘GHC.Base’
instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
instance MonadFail Maybe -- Defined in ‘Control.Monad.Fail’
instance Read a => Read (Maybe a) -- Defined in ‘GHC.Read’
instance Foldable Maybe -- Defined in ‘Data.Foldable’
instance Traversable Maybe -- Defined in ‘Data.Traversable’
*Main> :i Functor
:i Functor
type Functor :: (* -> *) -> Constraint
class Functor f where
  fmap :: (a -> b) -> f a -> f b
  (<$) :: a -> f b -> f a
  {-# MINIMAL fmap #-}
  	-- Defined in ‘GHC.Base’
instance Functor (Either a) -- Defined in ‘Data.Either’
instance Functor [] -- Defined in ‘GHC.Base’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Functor IO -- Defined in ‘GHC.Base’
instance Functor ((->) r) -- Defined in ‘GHC.Base’
instance Functor ((,,,) a b c) -- Defined in ‘GHC.Base’
instance Functor ((,,) a b) -- Defined in ‘GHC.Base’
instance Functor ((,) a) -- Defined in ‘GHC.Base’
*Main> :i
:i
syntax: ':i <thing-you-want-info-about>'
*Main> :i Maybe
:i Maybe
type Maybe :: * -> *
data Maybe a = Nothing | Just a
  	-- Defined in ‘GHC.Maybe’
instance Applicative Maybe -- Defined in ‘GHC.Base’
instance Eq a => Eq (Maybe a) -- Defined in ‘GHC.Maybe’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Monad Maybe -- Defined in ‘GHC.Base’
instance Semigroup a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Maybe’
instance Semigroup a => Semigroup (Maybe a)
  -- Defined in ‘GHC.Base’
instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
instance MonadFail Maybe -- Defined in ‘Control.Monad.Fail’
instance Read a => Read (Maybe a) -- Defined in ‘GHC.Read’
instance Foldable Maybe -- Defined in ‘Data.Foldable’
instance Traversable Maybe -- Defined in ‘Data.Traversable’
*Main> :i Functor
:i Functor
type Functor :: (* -> *) -> Constraint
class Functor f where
  fmap :: (a -> b) -> f a -> f b
  (<$) :: a -> f b -> f a
  {-# MINIMAL fmap #-}
  	-- Defined in ‘GHC.Base’
instance Functor (Either a) -- Defined in ‘Data.Either’
instance Functor [] -- Defined in ‘GHC.Base’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Functor IO -- Defined in ‘GHC.Base’
instance Functor ((->) r) -- Defined in ‘GHC.Base’
instance Functor ((,,,) a b c) -- Defined in ‘GHC.Base’
instance Functor ((,,) a b) -- Defined in ‘GHC.Base’
instance Functor ((,) a) -- Defined in ‘GHC.Base’
*Main> :i Maybe
:i Maybe
type Maybe :: * -> *
data Maybe a = Nothing | Just a
  	-- Defined in ‘GHC.Maybe’
instance Applicative Maybe -- Defined in ‘GHC.Base’
instance Eq a => Eq (Maybe a) -- Defined in ‘GHC.Maybe’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Monad Maybe -- Defined in ‘GHC.Base’
instance Semigroup a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Maybe’
instance Semigroup a => Semigroup (Maybe a)
  -- Defined in ‘GHC.Base’
instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
instance MonadFail Maybe -- Defined in ‘Control.Monad.Fail’
instance Read a => Read (Maybe a) -- Defined in ‘GHC.Read’
instance Foldable Maybe -- Defined in ‘Data.Foldable’
instance Traversable Maybe -- Defined in ‘Data.Traversable’
*Main> :i Int
:i Int
type Int :: *
data Int = GHC.Types.I# GHC.Prim.Int#
  	-- Defined in ‘GHC.Types’
instance Eq Int -- Defined in ‘GHC.Classes’
instance Ord Int -- Defined in ‘GHC.Classes’
instance Enum Int -- Defined in ‘GHC.Enum’
instance Num Int -- Defined in ‘GHC.Num’
instance Real Int -- Defined in ‘GHC.Real’
instance Show Int -- Defined in ‘GHC.Show’
instance Read Int -- Defined in ‘GHC.Read’
instance Bounded Int -- Defined in ‘GHC.Enum’
instance Integral Int -- Defined in ‘GHC.Real’
*Main> :i Bool
:i Bool
type Bool :: *
data Bool = False | True
  	-- Defined in ‘GHC.Types’
instance Eq Bool -- Defined in ‘GHC.Classes’
instance Ord Bool -- Defined in ‘GHC.Classes’
instance Enum Bool -- Defined in ‘GHC.Enum’
instance Show Bool -- Defined in ‘GHC.Show’
instance Read Bool -- Defined in ‘GHC.Read’
instance Bounded Bool -- Defined in ‘GHC.Enum’
*Main> :i (Maybe Bool)
:i (Maybe Bool)

<interactive>:1:2: error: parse error on input ‘Maybe’
*Main> :i Maybe
:i Maybe
type Maybe :: * -> *
data Maybe a = Nothing | Just a
  	-- Defined in ‘GHC.Maybe’
instance Applicative Maybe -- Defined in ‘GHC.Base’
instance Eq a => Eq (Maybe a) -- Defined in ‘GHC.Maybe’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Monad Maybe -- Defined in ‘GHC.Base’
instance Semigroup a => Monoid (Maybe a) -- Defined in ‘GHC.Base’
instance Ord a => Ord (Maybe a) -- Defined in ‘GHC.Maybe’
instance Semigroup a => Semigroup (Maybe a)
  -- Defined in ‘GHC.Base’
instance Show a => Show (Maybe a) -- Defined in ‘GHC.Show’
instance MonadFail Maybe -- Defined in ‘Control.Monad.Fail’
instance Read a => Read (Maybe a) -- Defined in ‘GHC.Read’
instance Foldable Maybe -- Defined in ‘Data.Foldable’
instance Traversable Maybe -- Defined in ‘Data.Traversable’
*Main> :i Functor
:i Functor
type Functor :: (* -> *) -> Constraint
class Functor f where
  fmap :: (a -> b) -> f a -> f b
  (<$) :: a -> f b -> f a
  {-# MINIMAL fmap #-}
  	-- Defined in ‘GHC.Base’
instance Functor (Either a) -- Defined in ‘Data.Either’
instance Functor [] -- Defined in ‘GHC.Base’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Functor IO -- Defined in ‘GHC.Base’
instance Functor ((->) r) -- Defined in ‘GHC.Base’
instance Functor ((,,,) a b c) -- Defined in ‘GHC.Base’
instance Functor ((,,) a b) -- Defined in ‘GHC.Base’
instance Functor ((,) a) -- Defined in ‘GHC.Base’
*Main> fmap (\x -> x + 3) Nothing
fmap (\x -> x + 3) Nothing
Nothing
*Main> fmap (\x -> x + 3) (Just 7)
fmap (\x -> x + 3) (Just 7)
Just 10
*Main> :i Either
:i Either
type Either :: * -> * -> *
data Either a b = Left a | Right b
  	-- Defined in ‘Data.Either’
instance Applicative (Either e) -- Defined in ‘Data.Either’
instance (Eq a, Eq b) => Eq (Either a b)
  -- Defined in ‘Data.Either’
instance Functor (Either a) -- Defined in ‘Data.Either’
instance Monad (Either e) -- Defined in ‘Data.Either’
instance (Ord a, Ord b) => Ord (Either a b)
  -- Defined in ‘Data.Either’
instance Semigroup (Either a b) -- Defined in ‘Data.Either’
instance (Show a, Show b) => Show (Either a b)
  -- Defined in ‘Data.Either’
instance (Read a, Read b) => Read (Either a b)
  -- Defined in ‘Data.Either’
instance Foldable (Either a) -- Defined in ‘Data.Foldable’
instance Traversable (Either a) -- Defined in ‘Data.Traversable’
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> impartire' 10 3
impartire' 10 3

<interactive>:190:1: error:
    • No instance for (Show Reason) arising from a use of ‘print’
    • In a stmt of an interactive GHCi command: print it
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> impartire' 10 3
impartire' 10 3
Left 3
*Main> impartire' 10 0
impartire' 10 0
Right DivByZero
*Main> cmmdc' 10 3
cmmdc' 10 3
Left 1
*Main> cmmdc' 0 0
cmmdc' 0 0
Right NotDefined
*Main> :i Either
:i Either
type Either :: * -> * -> *
data Either a b = Left a | Right b
  	-- Defined in ‘Data.Either’
instance Applicative (Either e) -- Defined in ‘Data.Either’
instance (Eq a, Eq b) => Eq (Either a b)
  -- Defined in ‘Data.Either’
instance Functor (Either a) -- Defined in ‘Data.Either’
instance Monad (Either e) -- Defined in ‘Data.Either’
instance (Ord a, Ord b) => Ord (Either a b)
  -- Defined in ‘Data.Either’
instance Semigroup (Either a b) -- Defined in ‘Data.Either’
instance (Show a, Show b) => Show (Either a b)
  -- Defined in ‘Data.Either’
instance (Read a, Read b) => Read (Either a b)
  -- Defined in ‘Data.Either’
instance Foldable (Either a) -- Defined in ‘Data.Foldable’
instance Traversable (Either a) -- Defined in ‘Data.Traversable’
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> fmap (\x -> x + 3) (Left DivByZero)
fmap (\x -> x + 3) (Left DivByZero)
Left DivByZero
*Main>fmap (\x -> x + 3) (Right 13)
fmap (\x -> x + 3) (Right 13)
Right 16
*Main> :i Functor
:i Functor
type Functor :: (* -> *) -> Constraint
class Functor f where
  fmap :: (a -> b) -> f a -> f b
  (<$) :: a -> f b -> f a
  {-# MINIMAL fmap #-}
  	-- Defined in ‘GHC.Base’
instance Functor (Either a) -- Defined in ‘Data.Either’
instance Functor [] -- Defined in ‘GHC.Base’
instance Functor Maybe -- Defined in ‘GHC.Base’
instance Functor IO -- Defined in ‘GHC.Base’
instance Functor ((->) r) -- Defined in ‘GHC.Base’
instance Functor ((,,,) a b c) -- Defined in ‘GHC.Base’
instance Functor ((,,) a b) -- Defined in ‘GHC.Base’
instance Functor ((,) a) -- Defined in ‘GHC.Base’
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:148:28: error:
    • Expecting one more argument to ‘Arb’
      Expected a type, but ‘Arb’ has kind ‘* -> *’
    • In the type ‘Arb’
      In the definition of data constructor ‘Nod’
      In the data declaration for ‘Arb’
    |
148 | data Arb a = Empty | Nod a Arb Arb deriving (Show, Eq)
    |                            ^^^

curs5.hs:148:32: error:
    • Expecting one more argument to ‘Arb’
      Expected a type, but ‘Arb’ has kind ‘* -> *’
    • In the type ‘Arb’
      In the definition of data constructor ‘Nod’
      In the data declaration for ‘Arb’
    |
148 | data Arb a = Empty | Nod a Arb Arb deriving (Show, Eq)
    |                                ^^^
Failed, no modules loaded.
Prelude> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> :i fmap
:i fmap
type Functor :: (* -> *) -> Constraint
class Functor f where
  fmap :: (a -> b) -> f a -> f b
  ...
  	-- Defined in ‘GHC.Base’
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:155:22: error:
    Ambiguous occurrence ‘fmap’
    It could refer to
       either ‘Prelude.fmap’,
              imported from ‘Prelude’ at curs5.hs:1:1
              (and originally defined in ‘GHC.Base’)
           or ‘Main.fmap’, defined at curs5.hs:153:1
    |
155 |        Nod (f info) (fmap f left) (fmap f right)
    |                      ^^^^

curs5.hs:155:36: error:
    Ambiguous occurrence ‘fmap’
    It could refer to
       either ‘Prelude.fmap’,
              imported from ‘Prelude’ at curs5.hs:1:1
              (and originally defined in ‘GHC.Base’)
           or ‘Main.fmap’, defined at curs5.hs:153:1
    |
155 |        Nod (f info) (fmap f left) (fmap f right)
    |                                    ^^^^
Failed, no modules loaded.
Prelude> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> fmap' (\x -> x + 3) (Nod 3 (Nod 4 Empty Empty) Empty)
 Empty)
Nod 6 (Nod 7 Empty Empty) Empty
*Main> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )

curs5.hs:158:11: error:
    • Illegal type signature in instance declaration:
        fmap :: (a -> b) -> ((Arb a) -> (Arb b))
      (Use InstanceSigs to allow this)
    • In the instance declaration for ‘Functor Arb’
    |
158 |   fmap :: (a -> b) -> ((Arb a) -> (Arb b))
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Failed, no modules loaded.
Prelude> :r
:r
[1 of 1] Compiling Main             ( curs5.hs, interpreted )
Ok, one module loaded.
*Main> fmap (\x -> x + 3) (Nod 3 (Nod 4 Empty Empty) Empty)
Empty)
Nod 6 (Nod 7 Empty Empty) Empty
*Main> :k Int
:k Int
Int :: *
*Main> :k Dow
:k Dow
Dow :: *
*Main> :k Arb
:k Arb
Arb :: * -> *
*Main> :k (Arb Int)
:k (Arb Int)
(Arb Int) :: *
*Main> :k (Maybe Int)
:k (Maybe Int)
(Maybe Int) :: *
*Main> :k Maybe
:k Maybe
Maybe :: * -> *
*Main> :k Either
:k Either
Either :: * -> * -> *
*Main> :k (Either Int)
:k (Either Int)
(Either Int) :: * -> *
*Main> :k ((Either Int) Bool)
:k ((Either Int) Bool)
((Either Int) Bool) :: *
*Main> :k (Either Int Bool)
:k (Either Int Bool)
(Either Int Bool) :: *
*Main> :q
:q
Leaving GHCi.
stefan@stefans-MacBook-Pro curs5 %