Haskell record pattern matching

Question

You can use record patterns like this:

data X = A | B {name :: String} | C {x::Int, y::Int, name::String}

myfn :: X -> Int
myfn A = 50
myfn B{} = 200
myfn C{} = 500

Record patterns allow you to give names to the fields of the constructors.
you can also do things like:

myfn C{name=n} = length n

so you can see that you can pattern match only on the specific field you need.

Note: you can use the empty record pattern even with data types that do not use record syntax:

data A = A Int | B Int Int

myfn A{} = 1
myfn B{} = 2

This is fine.
There a number of other extensions related to record patterns:

RecordWildCards allows you to write things like C{..} which is equivalent to the pattern: C{x=x, y=y, name=name}, i.e. it matches all fields and you now have in scope x with the value matched for the x field etc.
NamedFieldPuns allows you to write C{name} to be equivalent to C{name=name}, so that name is now in scope and contains the value matched for the name field.

Keep in mind that using record patterns doesn’t prevent you from using your constructors in a positional way, so you can still write:

myfn (B _) = 200

It only adds functionality.