A new paradigm

Express your ideas clearly and learn a new way of thinking about programming. Based on lambda calculus, Haskell is a purely functional programming language that features referential transparency, immutability and lazy evaluation. Concepts that will blow your mind — relearn programming while having an absolute blast.

Abstraction

Build powerful abstractions that are not possible in other languages. Only your imagination is the limit, due to polymorphism, type classes and more advanced typesystem features. Haskell has its roots in programming language research and will always be at the forefront of expressivity.

Type inference

You don't have to explicitly write out every type in a Haskell program. Types will be inferred by unifying every type bidirectionally. However, you can write out types if you choose, or ask the compiler to write them for you for handy documentation.

Click to expand

main :: IO ()
main = do line :: String <- getLine
          print (parseDigit line)
  where parseDigit :: String -> Maybe Int
        parseDigit ((c :: Char) : _) =
          if isDigit c
             then Just (ord c - ord '0')
             else Nothing

main = do line <- getLine
          print (parseDigit line)
  where parseDigit (c : _) =
          if isDigit c
             then Just (ord c - ord '0')
            else Nothing

Purely functional

Every function in Haskell is a function in the mathematical sense (i.e., "pure"). Even side-effecting IO operations are but a description of what to do, produced by pure code. There are no statements or instructions, only expressions which cannot mutate variables (local or global) nor access state like time or random numbers.

Click to expand

square :: Int -> Int
square x = x * x

"Hello: " ++ "World!"

"Name: " ++ getLine

Lazy

Functions don't evaluate their arguments. This means that programs can compose together very well, with the ability to write control constructs (such as if/else) just by writing normal functions. The purity of Haskell code makes it easy to fuse chains of functions together, allowing for performance benefits.

Click to expand

when p m = if p then m else return ()
main = do args <- getArgs
          when (null args)
               (putStrLn "No args specified!")

any :: (a -> Bool) -> [a] -> Bool
any p = or . map p

...

Packages

Open source contribution to Haskell is very active with a wide range of packages available on the public package servers.

Click to expand

A new paradigm

Express your ideas clearly and learn a new way of thinking about programming. Based on lambda calculus, Haskell is a purely functional programming language that features referential transparency, immutability and lazy evaluation. Concepts that will blow your mind — relearn programming while having an absolute blast.

Abstraction

Build powerful abstractions that are not possible in other languages. Only your imagination is the limit, due to polymorphism, type classes and more advanced typesystem features. Haskell has its roots in programming language research and will always be at the forefront of expressivity.

Declarative

Write your programs declaratively by utilizing the power of pure functions and algebraic data types. In Haskell we don't write how a program should be executed, we just describe its logic — never again be forced to think about evaluation order or execution details.

Click to expand

scoreboard = sortOn score
           . filter isAlive
           . loadPlayers

Type inference

You don't have to explicitly write out every type in a Haskell program. Types will be inferred by unifying every type bidirectionally. However, you can write out types if you choose, or ask the compiler to write them for you for handy documentation.

Click to expand

main :: IO ()
main = do line :: String <- getLine
          print (parseDigit line)
  where parseDigit :: String -> Maybe Int
        parseDigit ((c :: Char) : _) =
          if isDigit c
             then Just (ord c - ord '0')
             else Nothing

main = do line <- getLine
          print (parseDigit line)
  where parseDigit (c : _) =
          if isDigit c
             then Just (ord c - ord '0')
             else Nothing

Statically typed

Every expression in Haskell has a type which is determined at compile time. All the types composed together by function application have to match up. If they don't, the program will be rejected by the compiler. Types become not only a form of guarantee, but a language for expressing the construction of programs.

Click to expand

char = 'a'    :: Char
int = 123     :: Int
fun = isDigit :: Char -> Bool

isDigit 1

Packages

Open source contribution to Haskell is very active with a wide range of packages available on the public package servers.

Click to expand