Personal tools

Constructor

From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
(start)
Current revision (06:10, 20 December 2006) (edit) (undo)
(added notes)
 
(2 intermediate revisions not shown.)
Line 1: Line 1:
 +
[[Category:Language]]
'''Constructor''' can mean:
'''Constructor''' can mean:
* Type constructor
* Type constructor
Line 4: Line 5:
== Type constructor ==
== Type constructor ==
-
A type constructor is used to construct new types from given ones.
+
A [[type]] constructor is used to construct new types from given ones.
<haskell>
<haskell>
data Tree a = Tip | Node a (Tree a) (Tree a)
data Tree a = Tip | Node a (Tree a) (Tree a)
Line 11: Line 12:
== Data constructor ==
== Data constructor ==
-
A data constructor groups values together and tags alternatives in an algebraic data type,
+
A data constructor groups values together and tags alternatives in an [[algebraic data type]],
<haskell>
<haskell>
data Tree a = Tip | Node a (Tree a) (Tree a)
data Tree a = Tip | Node a (Tree a) (Tree a)
Line 22: Line 23:
On the other hand, <hask>Node</hask> contains other data. The types of those data are its parameters. The first one has type <hask>a</hask>, so it's just a value of the parameter type <hask>a</hask>. This one is the value the tree node holds in it. The remaining two are the branches. Each of them have type <hask>Tree a</hask>, naturally.
On the other hand, <hask>Node</hask> contains other data. The types of those data are its parameters. The first one has type <hask>a</hask>, so it's just a value of the parameter type <hask>a</hask>. This one is the value the tree node holds in it. The remaining two are the branches. Each of them have type <hask>Tree a</hask>, naturally.
-
=== Note ===
+
===Data constructors as first class values===
-
Data constructors are not types! They denote values. It would be illegal to write <hask>Node a (Node a) (Node a)</hask> there, because the type is <hask>Tree</hask>, not <hask>Node</hask>.
+
Data constructors are first class values in Haskell and actually have a [[type]]. For instance, the type of the <hask>Left</hask> constructor of the <hask>Either</hask> data type is:
 +
<haskell>
 +
Left :: forall b a. a -> Either a b
 +
</haskell>
 +
 
 +
As first class values, they may be passed to functions, held in a list, be data elements of other algebraic data types and so forth.
 +
 
 +
 
 +
=== Data constructors are not types===
 +
As discussed above, they denote values. It is illegal to write <hask>Node a (Node a) (Node a)</hask> there, because the type is <hask>Tree</hask>, not <hask>Node</hask>.
== Deconstructing data constructors ==
== Deconstructing data constructors ==
Line 33: Line 43:
So, the depth of a tip is zero. The depth of a node depends on its branches, but not it's content. See how the constructor in the left hand side names its parts? we don't need the content so we don't name it (using <hask>_</hask>). The left branch is named <hask>l</hask>, the right <hask>r</hask>, allowing us to use these values in the right hand side.
So, the depth of a tip is zero. The depth of a node depends on its branches, but not it's content. See how the constructor in the left hand side names its parts? we don't need the content so we don't name it (using <hask>_</hask>). The left branch is named <hask>l</hask>, the right <hask>r</hask>, allowing us to use these values in the right hand side.
-
== Notes ==
+
== Notes and tips==
-
* You can declare a constructor (for both type and data) to be infix, and this can make your code a lot more readable.
+
* You can declare a constructor (for both type and data) to be an infix operator, and this can make your code a lot more readable. However, for alphanumeric names, the names of both the type constructor and the data constructor(s) must start with an uppercase letter.
-
* Tuples are a built in feature of the syntax but are plain old algebraic data types! They have only one constructor though. Having the same name as their types (don't freak out, it's just a matter of convenience, as the type constructors and the data constructors have separate namespaces). So, <hask>(4, True)</hask> is really a value of the form <hask>(,) 4 True</hask> having the type <hask>(,) Int Bool</hask>, which, too, is written conveniently as <hask>(Int, Bool)</hask> to make it more readable. Incidentally, the empty tuple type <hask>()</hask> with its only value <hask>()</hask> is used throughout, and is called ''unit''.
+
* [[Tuples]] are a built in feature of the syntax but are plain old algebraic data types! They have only one constructor though. Having the same name as their types (don't freak out, it's just a matter of convenience, as the type constructors and the data constructors have separate namespaces). So, <hask>(4, True)</hask> is really a value of the form <hask>(,) 4 True</hask> having the type <hask>(,) Int Bool</hask>, which, too, is written conveniently as <hask>(Int, Bool)</hask> to make it more readable. Incidentally, the empty tuple type <hask>()</hask> with its only value <hask>()</hask> is used throughout, and is called ''unit''.
-
* You can, in fact, name the values grouped together, using the record syntax, <haskell>
+
* You can, in fact, name the values grouped together, using the [[record]] syntax, <haskell>
data Person = Person { name :: String, age :: Int, address :: String }
data Person = Person { name :: String, age :: Int, address :: String }
-
</haskell>
+
</haskell> so that for a person <hask>p</hask>, you can say <hask>age p</hask> to select his/her age, without resorting to pattern matching.
-
so that for a person <hask>p</hask>, you can say <hask>age p</hask> to select his/her age, without resorting to pattern matching.
+
* Sometimes you need a little editting or checking when constructing your data. If you do, check [[smart constructors]]
 +
* Sometimes you do not want the user of your library to group arbitrary values together. This is achieved by ''hiding'' your constructor (not mentioning it in the export list of the module), creating an [[abstract data type]] as a result. Along with smart constructors mentioned above, one can achieve encapsulation.

Current revision

Constructor can mean:

  • Type constructor
  • Data constructor

Contents

1 Type constructor

A type constructor is used to construct new types from given ones. 

data Tree a = Tip | Node a (Tree a) (Tree a)
illustrates how to define a data type with type constructors (and data constructors at the same time). The type constructor is named
Tree
, but a tree of what? Of any specific type
a
, be it
Integer
,
Maybe String
, or even
Tree b
, in which case it will be a tree of tree of
b
. The data type is polymorphic (and
a
is a type variable that is to be substituted by a specific type). So when used, the values will have types like
Tree Int
or
Tree (Tree Boolean)
.

2 Data constructor

A data constructor groups values together and tags alternatives in an algebraic data type, 

data Tree a = Tip | Node a (Tree a) (Tree a)
where there are two data constructors,
Tip
and
Node
. Any value that belongs to the type
Tree a
(I'm happy leaving the type parameter unspecified) will be a constructed by either
Tip
or
Node
.
Tip
is a constructor alright, but it groups no value whatsoever, that is, it's a nullary constructor. There can be only one value that will have this constructor, also conveniently denoted
Tip
. So nullary constructors contain no data apart from its name! For example, the
Bool
data type is defined to be 
data Bool = True | False

and for all practical purposes you can just think of them as constants belonging to a type.

On the other hand,
Node
contains other data. The types of those data are its parameters. The first one has type
a
, so it's just a value of the parameter type
a
. This one is the value the tree node holds in it. The remaining two are the branches. Each of them have type
Tree a
, naturally.

2.1 Data constructors as first class values

Data constructors are first class values in Haskell and actually have a type. For instance, the type of the
Left
constructor of the
Either
data type is: 
Left :: forall b a. a -> Either a b

As first class values, they may be passed to functions, held in a list, be data elements of other algebraic data types and so forth.


2.2 Data constructors are not types

As discussed above, they denote values. It is illegal to write
Node a (Node a) (Node a)
there, because the type is
Tree
, not
Node
.

3 Deconstructing data constructors

All a data constructor does is holding values together. But you want to separate them if you want to use them. This is done via pattern matching, 

depth Tip = 0
depth (Node _ l r) = 1 + max (depth l) (depth r)
So, the depth of a tip is zero. The depth of a node depends on its branches, but not it's content. See how the constructor in the left hand side names its parts? we don't need the content so we don't name it (using
_
). The left branch is named
l
, the right
r
, allowing us to use these values in the right hand side.

4 Notes and tips

  • You can declare a constructor (for both type and data) to be an infix operator, and this can make your code a lot more readable. However, for alphanumeric names, the names of both the type constructor and the data constructor(s) must start with an uppercase letter.
  • Tuples are a built in feature of the syntax but are plain old algebraic data types! They have only one constructor though. Having the same name as their types (don't freak out, it's just a matter of convenience, as the type constructors and the data constructors have separate namespaces). So,
    (4, True)
    is really a value of the form
    (,) 4 True
    having the type
    (,) Int Bool
    , which, too, is written conveniently as
    (Int, Bool)
    to make it more readable. Incidentally, the empty tuple type
    ()
    with its only value
    ()
    is used throughout, and is called unit.
  • You can, in fact, name the values grouped together, using the record syntax, 
    data Person = Person { name :: String, age :: Int, address :: String }
    so that for a person
    p
    , you can say
    age p
    to select his/her age, without resorting to pattern matching.
  • Sometimes you need a little editting or checking when constructing your data. If you do, check smart constructors
  • Sometimes you do not want the user of your library to group arbitrary values together. This is achieved by hiding your constructor (not mentioning it in the export list of the module), creating an abstract data type as a result. Along with smart constructors mentioned above, one can achieve encapsulation.
Retrieved from "http://www.haskell.org/haskellwiki/Constructor"

Category: Language