Hi Sandy,

Just passing by to let you know there is a problem with the way your sample chapter is set on leanpub. People downloading the free sample will get the whole book. You should fix it so people will only download a single chapter — unless this is done this way by design, in which case, ignore me :)

“include(`.latex-live-snippets/Kinds.list.tex')”

As suggested in the JFP review, my ContT presented here is actually Codensity. I seem to recall being unable to implement callCC, and that's probably why.

This example causes an error: Multiple declarations of 'User'

data UserType = User | Admin
data User = User {...}

Since DataKinds is turned on, the first declaration is creating a type User in addition to the usual type in the second declaration.

Using the table on page 18, and translating (a^b)^c into types, I get (from the outside in):

= (a^b)^c
= c -> (a^b)
= c -> (b -> a)
= c -> b -> a

Whereas it seems the translation you have provided gives (b -> c -> a).

Presumably you were aiming to ensure the types matched curry/uncurry? This may mean your example needs to change a little, because commutivity etc.

Your reply to my email was:

You're right that the naive transformation doesn't produce exactly the same types. It's trivial to give an isomorphism between the two, and I thought I had that as an earlier example, though upon re-reading, it does not appear to be there.

And yes, it's true that the isomorphism is easy for someone who knows how, but it doesn't immediately fall out of the presentation given in the question.

Need to add {-# LANGUAGE TypeOperators #-} to the necessary extensions at the beginning of 10.2 on pg. 126.

Everything works fine except for MapList pg. 129 and Foldr pg. 130 which depend on a promoted cons operator ': for example:

data FoldR :: (a -> b -> Exp b) -> b -> [a] -> Exp b
type instance Eval' (FoldR _ z '[]) = z
type instance Eval' (FoldR f z (x ': xs)) =
  Eval' (f x (Eval' (FoldR f z xs)))

I would create a PR myself, but I can't figure out how your TeX preamble is pulling code from your Haskell files

Would it be possible to have EPub and PDF releases instead of the source code?

Love the book. Thanks a lot for writing it!

Hi,
I tried the code for makePropertyObj at 13.3. USING GENERIC METADATA, page 183
it gives type error. Also checked the code on github it is left as undefined

the original code is (shown as on the book)

makePropertyObj :: forall name . (KnownSymbol name) => Value -> Value
makePropertyObj v = object [pack (symbolVal $ Proxy @name) .= v ]

I noticed the error was due to Haskell could not infer the type as Key from the code pack (symbolVal $ Proxy @name) and was giving below error (which worked for makeTypeObj function)

• Couldn't match expected type ‘Key’ with actual type ‘Text’
• In the first argument of ‘(.=)’, namely
    ‘pack (symbolVal $ Proxy @name)’
  In the expression: pack (symbolVal $ Proxy @name) .= v
  In the first argument of ‘object’, namely
    ‘[pack (symbolVal $ Proxy @name) .= v]’typecheck(-Wdeferred-type-errors)

I made some small changes and Key to import list from aeson package also used fromText and imported Data.Aeson.Key (fromText) and used fromText to convert Text to key and it works i believe if it is the intent;

here is the slightly modified code;

makePropertObj :: forall name . KnownSymbol name => Value -> Value
makePropertObj v = object [fromText (pack (symbolVal $ Proxy @name)) .= v ]

and just did a quick check on it if it works as it is

-- >>>makePropertObj @"age" (makeTypeObject @Int)
-- Object (fromList [("age",Object (fromList [("type",String "integer")]))])

also the changes on the import list I made ;

import Data.Aeson (Value (..), (.=), object, Key)
import Data.Aeson.Key (fromText)

This seems like the perfect book I would like to read. Except the print version on Lulu is listed as "Interior Ink Black & white". Is there no color for code highlighting in the print version?

In section 7.1.2 it is mentioned that we can generalize the pattern of creating existential constraint kinds by implementing Has and creating type aliases for HasShow and Dynamic in terms of it.

However no further mention is given to how the code from the prior example should be updated since removing the data constructors breaks liftD2 and the prior elimHasShow and elimDynamic functions. It would be cool to show how to update the prior code so that it compiles again or, if appropriate skills have been learned, to make it an exercise to fix it.

Hi there, I downloaded the samples today and have started reading it - it's interesting so far!

However I was confused when I went from Chapter 1 to Chapter 3. I checked the ToC and sure enough it also goes from 1 to 3. I was wondering if Chapter 2 is elided from the samples on purpose, or if it's a bug, or an easter egg, or...?

Also, I couldn't find a ToC on the website or LuLu to try to work out which of the above was the issue.

Thanks again, hope it goes well!

Can you have a look at the formatting of the epub on leanpub? The math images (Latex, I guess) are completely out of proportion. The 1234 blobs that enumerate code lines are a good idea, but they don't work at all in the epub because of their large size.
IMHO the epub is unreadable. Pleeeez fix!

I wasn't able to get the demo code on p 66 and 67 to compile without FlexibleInstances turned on, (not listed in the extensions list)

Page 29 defines a data type to be used as a data kind:

data UserType
  = User
  | Admin

Then suggests to refine some User data type:

data User = User { ... }

Unfortunately, the two cannot coexist as is, since they use the same data constructor name User. Seasoned Haskellers will not be too bothered by this, but someone a little new can be surprised by the duplicate identifier error.

(Mediocre) suggestions for fixes:

• renaming User into something else in UserType... nothing great comes to mind, the somewhat verbose NormalUser? :\
• explicitly mentioning that UserType should live in its own module and used qualified as UserType.User?

Not sure, it's a very minor issue! :-)

Relevent pages 138-141

import Fcf is not found, and if you get rid of that you are hit with other errors when you implement

type FindElem (key :: k) (ts :: [k])
   = FromMaybe Stuck =<< FindIndex (TyEq key) ts

there are three errors:

 error:
    Not in scope: type constructor or class ‘Stuck’
   |
33 |    = FromMaybe Stuck =<< FindIndex (TyEq key) ts
   |                ^^^^^
/Users/jonathan.l/Documents/thinking-with-types/src/CH11.hs:33:22-24: error:
    Not in scope: type constructor or class ‘=<<’
   |
33 |    = FromMaybe Stuck =<< FindIndex (TyEq key) ts
   |                      ^^^
/Users/jonathan.l/Documents/thinking-with-types/src/CH11.hs:33:26-34: error:
    Not in scope: type constructor or class ‘FindIndex’
   |
33 |    = FromMaybe Stuck =<< FindIndex (TyEq key) ts
   |                          ^^^^^^^^^

Additional typeErrors indicated the need for

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE EmptyCase #-}
{-# LANGUAGE StandaloneDeriving #-}

to be enabled before the singletons definition quasiquoter would compile.

just a heads up

Require proper Eq instance for Ord instance to work

For exercise 5.3-iii you need to have the Eq instance for HList defined in terms of All. This is because the tail of HList needs an Eq instance as well as the whole thing when defining the Ord instance:

this will work

instance All Eq ts => Eq (HList ts) where
  HNil == HNil = True
  (a :# as) == (b :# bs) = a == b && as == bs

instance (All Eq ts, All Ord ts) => Ord (HList ts) where
  compare HNil HNil = EQ
  compare (a :# as) (b :# bs) = compare a b <> compare as bs

this will not work

instance Eq (HList '[]) where
  HNil == HNil = True

instance (Eq t, Eq (HList ts)) => Eq (HList (t ': ts)) where
  (a :# as) == (b :# bs) = a == b && as == bs

instance (All Eq ts, All Ord ts) => Ord (HList ts) where
  compare HNil HNil = EQ
  compare (a :# as) (b :# bs) = compare a b <> compare as bs

Typo in solutions

Solution for exercise 5.3-ii on pg 249:

currently is

instance (Show t, Show (HList ts)) => Show (HList (t ': ts)) where
  show (x :# xs) = show x <> ":#" show xs

should be

instance (Show t, Show (HList ts)) => Show (HList (t ': ts)) where
  show (x :# xs) = show x <> ":#" <> show xs