What are the differences between ’newtype’ and ’data’ in Haskell?

In Haskell, both ‘newtype‘ and ‘data‘ are used to define new types, but they have some differences in their usage, semantics, and performance implications. Let’s discuss these differences in detail.

1. **Usage and Syntax:**

‘data‘ is used to define an algebraic data type, which can have multiple constructors and fields.

data TypeName = Constructor1 FieldType1 FieldType2
              | Constructor2 FieldType1 FieldType3

‘newtype‘ is used when you want to create a new type that is isomorphic to an existing type but with a different name. It can only have one constructor and one field.

newtype TypeName = Constructor ExistingType

2. **Semantics:**

‘data‘ creates a new type that is distinct from the original type. While ‘newtype‘ creates a new type, it is only a "wrapper" around the original type, and the underlying representation remains the same.

For example:

data    AgeD = AgeD Int deriving Show
newtype AgeN = AgeN Int deriving Show

Even though ‘AgeD‘ and ‘AgeN‘ seem similar, they have different semantics. When you pattern match on ‘AgeD‘, the constructor has to be evaluated, while for ‘newtype‘, since it wraps around the existing type, no additional evaluation is needed.

3. **Performance and Space Considerations:**

As mentioned before, ‘newtype‘ has no additional runtime overhead, as it shares the same representation as the wrapped type. On the other hand, ‘data‘ introduces an extra level of indirection, which can have performance and space implications.

For example, in the following code snippet:

data    ListD a = NilD | ConsD a (ListD a)
newtype ListN a = ListN [a]

‘ListD‘ has more overhead than ‘ListN‘ because it introduces a new constructor for each variant, whereas ‘ListN‘ just wraps around the existing list data type.

4. **Typeclass Instances:**

The primary motivation for using ‘newtype‘ is often to provide different typeclass instances for existing types. Since the newtype is isomorphic to the original type, you can’t define different instances for them using ‘data‘.

For example, imagine you want to define two ‘Monoid‘ instances for ‘Int‘ – one for addition and one for multiplication. It’s not possible to do this directly, but you can create newtypes to wrap ‘Int‘ and define separate instances:

newtype Sum = Sum Int deriving Show
newtype Product = Product Int deriving Show

instance Semigroup Sum where
  Sum a <> Sum b = Sum (a + b)

instance Monoid Sum where
  mempty = Sum 0

instance Semigroup Product where
  Product a <> Product b = Product (a * b)

instance Monoid Product where
  mempty = Product 1

In conclusion, the main differences between ‘newtype‘ and ‘data‘ are in their usage, semantics, and performance characteristics. Use ‘newtype‘ when creating a new type isomorphically equivalent to an existing type with different typeclass instances, and when you want to eliminate runtime overhead. Use ‘data‘ to create new algebraic data types that have multiple constructors and/or fields with different semantics than existing types.