Question

I’m following this introduction to Haskell, and this particular place (user defined types 2.2) I’m finding particularly obscure. To the point, I don’t even understand what part of it is code, and what part is the thoughts of the author. (What is Pt – it is never defined anywhere?). Needless to say, I can’t execute / compile it.

As an example that would make it easier for me to understand, I wanted to define a type, which is a pair of an Integer and a String, or a String and an Integer, but nothing else.

The theoretical function that would use it would look like so:

combine :: StringIntPair -> String
combine a b = (show a) ++ b
combine a b = a ++ (show b)

If you need a working code, that does the same, here’s CL code for doing it:

(defgeneric combine (a b)
  (:documentation "Combines strings and integers"))

(defmethod combine ((a string) (b integer))
  (concatenate 'string a (write-to-string b)))

(defmethod combine ((a integer) (b string))
  (concatenate 'string (write-to-string a) b))

(combine 100 "500")

Answer 1

Here’s one way to define the datatype:

data StringIntPair = StringInt String Int | 
                     IntString Int String 
    deriving (Show, Eq, Ord)

Note that I’ve defined two constructors for type StringIntPair, and they are StringInt and IntString.

Now in the definition of combine:

combine :: StringIntPair -> String
combine (StringInt s i) = s ++ (show i)
combine (IntString i s) = (show i) ++ s

I’m using pattern matching to match the constructors and select the correct behavior.

Here are some examples of usage:

*Main> let y = StringInt "abc" 123
*Main> let z = IntString 789 "a string"
*Main> combine y
"abc123"
*Main> combine z
"789a string"
*Main> :t y
y :: StringIntPair
*Main> :t z
z :: StringIntPair

A few things to note about the examples:

• StringIntPair is a type; doing :t <expression> in the interpreter shows the type of an expression
• StringInt and IntString are constructors of the same type
• the vertical bar (|) separates constructors
• a well-written function should match each constructor of its argument’s types; that’s why I’ve written combine with two patterns, one for each constructor