Personal tools

Cookbook/Compilers and interpreters

From HaskellWiki

< Cookbook(Difference between revisions)
Jump to: navigation, search
(Change more Prelude links to HaskellWiki page)
(General: use a less intimidating example)
 
(29 intermediate revisions by one user not shown)
Line 1: Line 1:
= Prelude =
+
== GHC ==
   
A lot of functions are defined in the [[Prelude]]. The Prelude is a standard module imported by default into all Haskell module.
+
{| class="wikitable"
  +
|-
  +
! Problem
  +
! Solution
  +
! Examples
  +
|-
  +
| compiling and linking an executable
  +
| --make
  +
|<pre>ghc --make Main.hs --> Main</pre>
  +
|-
  +
| compiling without linking
  +
| -c
  +
|<pre>ghc -c Foo.hs --> Foo.hi, Foo.o</pre>
  +
|-
  +
| generating Assembler code
  +
| -S
  +
|<pre>ghc -S Foo.hs --> Foo.hi, Foo.s</pre>
  +
|-
  +
| generating C code
  +
| -C
  +
|<pre>ghc -C Foo.hs --> Foo.hc, Foo.hi</pre>
  +
|-
  +
| linking files into an executable
  +
| -o
  +
|<pre>ghc -o test Foo.o Bar.o Baz.p --> test</pre>
  +
|}
   
Also, if you ever want to search for a function, based on the name, type or module, take a look at the excellent [[Hoogle]]. This is for a lot of people a must-have while debugging and writing Haskell programs.
+
== GHCi ==
   
= GHCi/Hugs =
+
=== General ===
== GHCi interaction ==
 
To start GHCi from a command prompt, simply type `ghci'
 
   
$ ghci
+
{| class="wikitable"
___ ___ _
+
|-
/ _ \ /\ /\/ __(_)
+
! Problem
/ /_\// /_/ / / | | GHC Interactive, version 6.6, for Haskell 98.
+
! Solution
/ /_\\/ __ / /___| | http://www.haskell.org/ghc/
+
! Examples
\____/\/ /_/\____/|_| Type :? for help.
+
|-
+
| checking a definition
Loading package base ... linking ... done.
+
| :i
Prelude>
+
|<haskell>
+
Prelude> :i True
[[Prelude]] is the "base" library of Haskell.
+
data Bool = ... | True -- Defined in GHC.Bool
 
To create variables at the GHCi prompt, use `let'
 
<haskell>
 
Prelude> let x = 5
 
Prelude> x
 
5
 
Prelude> let y = 3
 
Prelude> y
 
3
 
Prelude> x + y
 
8
 
 
</haskell>
 
</haskell>
  +
|-
  +
| checking a type
  +
| :t
  +
|<haskell>
  +
Prelude> :t "Hello"
  +
"Hello" :: [Char]
   
`let' is also the way to create simple functions at the GHCi prompt
+
Prelude> :t length
<haskell>
+
length :: [a] -> Int
Prelude> let fact n = product [1..n]
 
Prelude> fact 5
 
120
 
 
</haskell>
 
</haskell>
  +
|-
  +
| loading a file
  +
| :l
  +
|<haskell>
  +
Prelude> :l Foo.hs
  +
[1 of 1] Compiling Foo ( Foo.hs, interpreted )
  +
Ok, modules loaded: Foo.
  +
</haskell>
  +
|-
  +
| reloading all loaded files
  +
| :r
  +
|<haskell>
  +
Prelude> :r
  +
</haskell>
  +
|}
   
  +
=== Debugging ===
   
== Checking Types ==
+
{| class="wikitable"
To check the type of an expression or function, use the command `:t'
+
|-
<haskell>
+
! Problem
Prelude> :t x
+
! Solution
x :: Integer
+
! Examples
Prelude> :t "Hello"
+
|-
"Hello" :: [Char]
+
| setting a break point
</haskell>
+
| :break
Haskell has the following types defined in the [[Prelude]].
+
|<haskell>
<haskell>
+
Prelude> :break 2 -- sets a break point in line 2
Int -- bounded, word-sized integers
 
Integer -- unbounded integers
 
Double -- floating point values
 
Char -- characters
 
String -- equivalent to [Char], strings are lists of characters
 
() -- the unit type
 
Bool -- booleans
 
[a] -- lists
 
(a,b) -- tuples / product types
 
Either a b -- sum types
 
Maybe a -- optional values
 
 
</haskell>
 
</haskell>
  +
|}
  +
  +
== Hugs ==
  +
  +
TODO

Latest revision as of 08:33, 25 January 2010

Contents

[edit] 1 GHC

Problem Solution Examples
compiling and linking an executable --make
ghc --make Main.hs               --> Main
compiling without linking -c
ghc -c Foo.hs                    --> Foo.hi, Foo.o
generating Assembler code -S
ghc -S Foo.hs                    --> Foo.hi, Foo.s
generating C code -C
ghc -C Foo.hs                    --> Foo.hc, Foo.hi
linking files into an executable -o
ghc -o test Foo.o Bar.o Baz.p    --> test

[edit] 2 GHCi

[edit] 2.1 General

Problem Solution Examples
checking a definition  :i
Prelude> :i True
data Bool = ... | True  -- Defined in GHC.Bool
checking a type  :t
Prelude> :t "Hello"
"Hello" :: [Char]
 
Prelude> :t length
length :: [a] -> Int
loading a file  :l
Prelude> :l Foo.hs
[1 of 1] Compiling Foo              ( Foo.hs, interpreted )
Ok, modules loaded: Foo.
reloading all loaded files  :r
Prelude> :r

[edit] 2.2 Debugging

Problem Solution Examples
setting a break point  :break
Prelude> :break 2    -- sets a break point in line 2

[edit] 3 Hugs

TODO