• previous -- Making types: data and type
• table of contents
• next -- The "State" monad

Haskell for Hobos -- Creating types: newtype

Some sources tell you the purpose of newtype is to make new types from existing types. This is only partially true. Often newtype is used in lieu of "data" to create entirely new types.

• More types
• Haskell Report, section 4.2.3 (newtype)
• Haskell Wiki -- newtype

Basic use of newtype

newtype Critter = Fish | Bird

newtype Dingus = Dingus {
    number :: Int
    id :: String
}

One reason is that newtype has less overhead (which makes some sense given all of the restrictions). Newtype can be used to create a new type based on an existing datatype, while changing the typeclass participation.

I'm going to leave the basics here, but just mention that there are also some distinctions involving laziness versus strictness. Newtype value constructors are strict, while "data" value constructors are lazy.

Surprises from Real World Haskell

We run into the following on page 240 of Real World Haskell

newtype Parse a = Parse {
	runParse :: ParseState -> Either String (a, ParseState)
}

newtype State s a = State { runState :: s -> (s, a) }

In many ways, there are no real surprises here. We have one type constructor with one field. The only unusual thing might be that the field holds a function.

Notice that both of these stand on their own. They are not wrapping or redefining some other type as is so often claimed for newtype.

Don't go running around (like I did) looking for a function elsewhere defining runParse or runState. A sneaky game with Haskell record syntax is going on here.

The newtype State monad

• State: a tutorial for the confused
• Reddit: get into State Monad
• Demystifying the Haskell State monad
• Control.Monad.State.Lazy

-- Applies a function to the internal value without
--   altering the state modification logic.
instance Functor (State s) where
    fmap f (State g) = State $ \s ->
        let (x, s') = g s
        in (f x, s')

-- Allows for independent stateful computations to be sequenced.
instance Applicative (State s) where
    pure x = State $ \s -> (x, s)

    State f_g <*> State g = State $ \s ->
        let (f, s')   = f_g s
            (x, s'')  = g s'
        in (f x, s'')

-- Sequentially pipes the resulting value and final state
--     of one action into the next.
instance Monad (State s) where
    return = pure

    (State g) >>= f = State $ \s ->
        let (x, s') = g s    -- Run the first stateful computation
            State h = f x
        in h s'              -- Run the second stateful computation

Closing thoughts

There is deep magic involved with Haskell "newtype". Haskell "data" is simple and easy and the usual way to create a new type. Haskell "type" exists just to make simple synonyms, and has no surprises.

The very existence of "newtype" in the face of these is your first hint that something unexpected is going on. Newtype has special rules.

• previous -- Making types: data and type
• table of contents
• next -- The "State" monad