haskell assignment let

Home » Language Basics » Haskell where vs let

Haskell where vs let

Introduction.

Haskell is a functional programming language that provides two ways to define variables: using the where keyword and using the let keyword. Both of these constructs serve a similar purpose, but there are some differences between them. In this article, we will explore the differences between where and let in Haskell and provide examples to illustrate their usage.

The where keyword

The where keyword in Haskell is used to define local variables that are scoped to a specific function. It is typically placed at the end of a function definition and allows you to define helper functions or intermediate values that are only relevant to that function.

Here is an example of using the where keyword:

In this example, the calculateSquare function takes an integer x and calculates its square. The local variable square is defined using the where keyword and is assigned the value x * x . This local variable is only accessible within the calculateSquare function.

The let keyword

The let keyword in Haskell is used to define local variables that are scoped to a specific expression. It can be used anywhere within an expression and allows you to define temporary variables or perform calculations within that expression.

Here is an example of using the let keyword:

In this example, the calculateSquare function takes an integer x and calculates its square. The local variable square is defined using the let keyword and is assigned the value x * x . The let expression is then followed by the in keyword, which specifies the expression in which the local variable is used. In this case, the local variable square is the result of the expression.

Differences between where and let

While both where and let serve a similar purpose of defining local variables, there are some differences between them:

• Scope: The variables defined using where are scoped to the entire function, while the variables defined using let are scoped to the specific expression in which they are defined.
• Order of definition: The variables defined using where can be used anywhere within the function, even before their definition. On the other hand, the variables defined using let can only be used after their definition within the expression.
• Visibility: The variables defined using where are not visible outside the function, while the variables defined using let can be visible outside the expression in which they are defined.

In conclusion, both the where and let keywords in Haskell provide a way to define local variables. The choice between them depends on the scope, order of definition, and visibility requirements of the variables. Understanding the differences between where and let can help you write more concise and readable Haskell code.

• No Comments
• haskell , where

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Save my name, email, and website in this browser for the next time I comment.

Table of Contents

Not stay with the doubts.

• Privacy Overview
• Strictly Necessary Cookies

This website uses cookies so that we can provide you with the best user experience possible. Cookie information is stored in your browser and performs functions such as recognising you when you return to our website and helping our team to understand which sections of the website you find most interesting and useful.

Strictly Necessary Cookie should be enabled at all times so that we can save your preferences for cookie settings.

If you disable this cookie, we will not be able to save your preferences. This means that every time you visit this website you will need to enable or disable cookies again.

Difference between let and <-

While learning Haskell, I came across these kinds of lines

From my observation both assign value to these two variables, so what’s the difference and what’s the use case?

<- is valid in do -notation and it doesn’t just assign a value but also “unwraps” or “extracts” it from a monad.

Let us look at a Maybe Int example. We will take Just 1 and increment it by 1 .

Here is the first attempt with let :

This code won’t compile obviously, because let valueInMaybe = Just 1 is just a binding; valueInMaybe is Just 1 and I can’t add one to it, Just 1 isn’t of the same type as 1 , it isn’t an Int .

But consider:

This code compiles and returns Just 2 . valueInMaybe <- Just 1 extracts 1 from Just 1 and binds it to valueInMaybe . In the next line, we sum 2 integers, valueInMaybe and 1 . Finally we wrap the result 2 back into a Maybe . And we have to, because do -notation is a jail, we can’t escape from; if we’re working with a specific monad, we have to give this monad back at the end.

So what happens if valueInMaybe <- Nothing ? The next line won’t be executed and the function will return Nothing . This is the reason why we have to return Maybe Int at the end and not just Int , because the result can be Nothing .

To bring this back to the example in the question:

If you look at the type newManager :: ManagerSettings -> IO Manager you see that newManager applied to tlsManagerSettings will produce a value of type IO Manager . Haskell cannot automatically ‘cast’ this type to Manager , so you have to manually indicate that you want this value to be unwrapped by using the <- symbol in do notation.

The type setRequestManager :: Manager -> Request -> Request for setRequestManager on the second line indicates that this is a pure function. Applying setRequestManager to manager and "http://httpbin.org/get" produces a value of type Request which does not need unwrapping.

This was very helpful. So <- only works with types that take a single argument? How does one work with other types in do ?

As an experiment, I tried this in ghci:

(I included List 42 Nil at the end just to return (not return !) something that I know works without the previous <- assignment (or binding or unwrapping or whatever it’s called–not sure.))

This was very helpful. So <- only works with types that take a single argument? How does one work with other types in do?

It is important here to make a clear distinction between terms and types. In your example:

data IntList = Nil | List {val :: Int, next :: IntList} deriving Show

The type is IntList and it has terms Nil :: IntList and List :: Int -> IntList -> IntList . You see that IntList is a type without any arguments, Nil is a term without arguments and List is a term with two arguments.

The main requirement to using a type with <- is that it needs to be a Monad *:

This means that you must be able to define two functions: return and (>>=) with those types. For a concrete type like IntList you can just fill in IntList at every place where there is a m variable in the type signatures of those two functions. That yields: return :: a -> IntList a and (>>=) :: IntList a -> (a -> IntList b) -> IntList b . Here you can see the problem. IntList is a type without any arguments, so writing IntList a does not make any sense. To be able to use a type in do notation it needs to have at least one argument.

You can make your list a bit more general like this:

Now we can write an instance of Monad for this list*:

And now we can use it in do notation:

Internally, Haskell will rewrite this to:

Can you use the definition of (>>=) to calculate the result of this expression with pen and paper?

* Monad actually also requires that the type is an instance of Applicative , but I have chosen to leave that out for this explanation.

Wow–that’s extremely clear and helpful, @jaror .

You already got some nice answers, but I’ll add my two cents. let is a binder keyword, that will associate a name to a value in the rest of your term. <- is not a real keyword but only syntactic sugar.

will be translated by a preprocessor to

Understanding the underlying syntax helps think about the do notation. This syntactic sugar really makes us humans think there is some state involved, or imperative style evaluation order, and this might seem confusing sometimes. I hope I did not make any mistakes explaining this.

c >>= \_ ->

is the same as

• Search plugin
• haskell.org

• ghc-lib-parser
• haskell-src-exts
• haskell-src-exts-simple
• template-haskell

• Characters and Strings
• Type Signatures
• Nested Scopes
• Records (Structs)
• Type Aliases
• Our Own Type Classes
• Deriving Instances Automatically
• Type Families
• More Functions for Functors
• Interlude: Monoids
• Non-Foldable Containers
• Either: Exception Handling with Error Information
• Reader: Computing with Context
• Writer: Producing a Log
• State: Stateful Computations
• Reader-Writer-State
• The MonadTrans Class
• Conclusions

Here is the implementation of our veclen function in Haskell, first using let :

You can read this quite naturally in English: "Let x2 have the value x * x , and let y2 have the value y * y in the expression sqrt (x2 + y2) ". The entire function definition is a scope. Thus, all definitions inside the let block and the expression after in can refer to all variables defined in the let block, here x2 and y2 , and to all function arguments, here x and y . They can also refer to all values defined in surrounding scopes.

If you're used to programming in imperative languages, you may also be tempted to read this function definition as:

• Assign the result of x * x to x2 .
• Assign the result of y * y to y2 .
• Finally return the result of sqrt (x2 + y2) .

This sequential view of the execution of the veclen function is the wrong mental model! It may get you into trouble when reading other people's code, and will limit the code you are able to write yourself. Here's a definition of veclen that works great in Python (even though it's bad programming style):

If we try the same in Haskell, it doesn't work:

Let me explain the fundamental difference between Python (or any other imperative language) and Haskell (or any other purely functional language).

In an imperative language, variables are names for memory locations.

Variable assignment stores values in these memory locations. When using a variable in some expression, we read the variable and use the read value to calculate the value of the whole expression. This is what leads to the sequential execution model in imperative languages: If we want to use some variable's value in some expression, we better make sure that we store this value in the variable before evaluating the expression, using variable assignment.

The Python version of veclen thus makes perfect sense. We store the result of x * x in the variable x2 . We store the result of y * y in the variable y2 . Now we read both x2 and y2 and add their values together. We store the result in x2 , thereby overwriting the old value of x2 , and finally we read the new value of x2 and pass it as argument to sqrt . Since variables are names for memory locations, it is perfectly fine that they contain different values at different times during the execution of our program.

In purely functional languages, variables are names for expressions.

Note the difference: Even though the runtime system of a functional language also stores the values of these expressions in some memory locations, this concept of memory locations does not exist at all at the language level. Once again, functional languages are much closer to mathematics, where we also say things like "let \(x = \sqrt{2 + 7}\) ". We define \(x\) as a shorthand for the value of the expression \(\sqrt{2 + 7}\) . In particular, we generally do not define \(x\) to be one value, and then define \(x\) to be a different value at a later time, at least not within the same context. (This idea of contexts will become important in a minute. In programming languages, we call these contexts scopes .)

Now if we look at our problematic definition of veclen , translated into plain English, this definition says, "Let x2 = x * x , let y2 = y * y , and also let x2 = x2 + y2 in the expression sqrt x2 ." We now have two conflicting definitions of x2 within the same context, and GHCi rightly complains that it doesn't know how to interpret the expression sqrt x2 because it cannot decide for us which definition of x2 we are referring to.

So, in Haskell, "assignments" aren't really assignments as in imperative languages. Instead, they name values of expressions. Within a given scope,

• We cannot use the same name for different expressions, and
• We can refer to any name defined within the same or any surrounding scope.

This has an important consequence:

The ordering of the definitions in a let block or where block (next section) is irrelevant.

Therefore, both of the following are perfectly fine:

In both cases, the definition of sum refers to x2 and y2 , which are defined within the same let block.

To see that this really works, here's the demonstration in GHCi:

Haskell's evaluation model that allows this works roughly like this: The whole function invocation veclen (x, y) has the value sqrt sum . In order to calculate this, our program needs to figure out which value sum refers to. In this case, it finds a definition of sum right in the current scope, in the current let block. If this were not the case, it would look for an expression with the name sum in bigger and bigger surrounding scopes until it finds such an expression. Here, the definition sum = x2 + y2 tells us how to calculate sum if we know x2 and y2 , so we need to find out what expressions x2 and y2 refer to. Again, we start looking for definitions of these names within the current scope and, if we don't find such definitions in the current scope, in bigger and bigger surrounding scopes. Here, we find the definitions x2 = x * x and y2 = y * y in the current let block. To calculate these, we need to know what x and y are. These are the two components of the pair that was passed to veclen as its argument. We have now found all the pieces and retrace our steps to first calculate x2 from x , y2 from y , sum from x2 and y2 , and finally the return value of veclen (x, y) from sum .

I hope this is clear enough. If you think you get it but need some time to get comfortable with this departure from viewing variable definitions as a sequence of assignments, then you should probably skip the rest of this section and move on to the next section on where blocks. If you either need another way of looking at the way Haskell deals with variable definitions or you are ready for a bit of the underlying theory, then keep reading.

Computing with Functions Only

The ability to refer to variables in expressions that come before the definitions of these variables may seem strange if you're used to programming imperatively. However, there is a part of the semantics of imperative languages where the ordering of definitions doesn't matter either: function definitions.

In most imperative languages—with the notable exception of C, C++, and a few more dinosaurs in the family of programming languages—we can happily define two functions f and g , and each can call the other no matter which one is defined first. An example in Python:

Note that f calls g even though g is defined after f .

Now, \(\lambda\) -calculus , which provides the theoretical underpinnings for functional programming, tells us that we can in fact program entirely with functions: There are no values, only functions. It is also known that this model of computation has exactly the same expressive power as Turing machines , which provide the theoretical underpinnings for imperative programming and which you should have learned about in CSCI 2115.

In Haskell, we write a one-argument function as

How should we interpret the expression

One way to look at it is as defining the value x = 5 . The other way is as defining a function x with zero arguments that, when called, returns the value 5 .

In Python, we would write such a function as

We could now go back to our Haskell implementation of veclen and mimic it in Python:

Et voilá, we have an implementation of veclen where sum depends on x2 and y2 and, just as in Haskell, x2 and y2 are defined after sum . This may seem like a dirty little trick, but thinking about variables as functions that return their values is in fact the correct mental model to understand Haskell's evaluation model, especially once we talk about lazy evaluation , which enables some really elegant programming patterns.

Haskell for all

Sunday, july 16, 2017, demystifying haskell assignment.

This post clarifies the distinction between <- and = in Haskell, which sometimes mystifies newcomers to the language. For example, consider the following contrived code snippet:

The above program reads one line of input, and then prints that line twice with an exclamation mark at the end, like this:

Why does the first line use the <- symbol to assign a value to input while the second line uses the = symbol to define output ? Most languages use only one symbol to assign values (such as = or := ), so why does Haskell use two?

Haskell bucks the trend because the = symbol does not mean assignment and instead means something stronger than in most programming languages. Whenever you see an equality sign in a Haskell program that means that the two sides are truly equal. You can substitute either side of the equality for the other side and this substitution works in both directions.

For example, we define output to be equal (i.e. synonymous) with the expression input ++ "!" in our original program. This means that anywhere we see output in our program we can replace output with input ++ "!" instead, like this:

Vice versa, anywhere we see input ++ "!" in our program we can reverse the substitution and replace the expression with output instead, like this:

The language enforces that these sorts of substitutions do not change the behavior of our program (with caveats, but this is mostly true). All three of the above programs have the same behavior because we always replace one expression with another equal expression. In Haskell, the equality symbol denotes true mathematical equality.

Once we understand equality we can better understand why Haskell uses a separate symbol for assignment: <- . For example, lets revisit this assignment in our original program:

input and getLine are not equal in any sense of the word. They don't even have the same type!

The type of input is String :

... whereas the type of getLine is IO String :

... which you can think of as "a subroutine whose return value is a String ". We can't substitute either one for the other because we would get a type error. For example, if we substitute all occurrences of input with getLine we would get an invalid program which does not type check:

However, suppose we gloss over the type error and accept values of type IO String where the program expected just a String . Even then this substitution would still be wrong because our new program appears to request user input twice:

Contrast this with our original program, which only asks for a single line of input and reuses the line twice:

We cannot substitute the left-hand side of an assignment for the right-hand side of the assignment without changing the meaning of our program. This is why Haskell uses a separate symbol for assignment, because assignment does not denote equality.

Also, getLine and input are not even morally equal. getLine is a subroutine whose result may change every time, and to equate getLine with the result of any particular run doesn't make intuitive sense. That would be like calling the Unix ls command "a list of files".

Haskell has two separate symbols for <- and = because assignment and equality are not the same thing. Haskell just happens to be the first mainstream language that supports mathematical equality, which is why the language requires this symbolic distinction.

Language support for mathematical equality unlocks another useful language feature: equational reasoning . You can use more sophisticated equalities to formally reason about the behavior of larger programs, the same way you would reason about algebraic expressions in math.

Can we think of <- as andThen operator, applied in reverse?

Input: aaa 2 4

A brief introduction to Haskell

Haskell is:

• A language developed by the programming languages research community.
• Is a lazy, purely functional language (that also has imperative features such as side effects and mutable state, along with strict evaluation)
• Born as an open source vehicle for programming language research
• One of the youngest children of ML and Lisp
• Particularly useful for programs that manipulate data structures (such as compilers and interpreters ), and for concurrent/parallel programming

Inspired by the article Introduction to OCaml , and translated from the OCaml by Don Stewart.

• 1 Background
• 2 Haskell features
• 3.1 Interacting with the language
• 4.1 Libraries
• 4.2 Overloading
• 4.3 Expressions
• 4.4 Local bindings
• 4.5 Allocation
• 4.7 Pattern matching
• 5.1 Currying
• 5.2 Patterns
• 5.3 Immutable declarations
• 5.4 Higher order functions
• 5.5 Currying
• 5.6 A bigger example
• 5.7 Proving program properties by induction
• 5.8 Loading source from a file
• 6.1 Type Declarations
• 6.2 Type synonyms
• 6.3 Polymorphic Types and Type Inference
• 6.4 Parametric polymorphism
• 6.5 Algebraic Data Types
• 6.6 Record Declarations
• 7.2 do-Notation
• 7.3 Mutable variables
• 7.4 Exceptions
• 7.5 Concurrency
• 8.1 Mutable variables
• 8.3 Monad transformers
• 9 Compilation
• 1990 . Haskell 1.0
• 1991 . Haskell 1.1
• 1993 . Haskell 1.2
• 1996 . Haskell 1.3
• 1997 . Haskell 1.4
• 1998 . Haskell 98
• 2000-2006 . Period of rapid language and community growth
• ~2007 . Haskell Prime
• 2009 . Haskell 2010

Implementations :

Haskell features

Has some novel features relative to Java (and C++).

• Immutable variables by default (mutable state programmed via monads)
• Pure by default (side effects are programmed via monads)
• Lazy evaluation : results are only computed if they're required (strictness optional)
• Everything is an expression
• First-class functions: functions can be defined anywhere, passed as arguments, and returned as values.
• Both compiled and interpreted implementations available
• Full type inference -- type declarations optional
• Pattern matching on data structures -- data structures are first class!

Parametric polymorphism

• Bounded parametric polymorphism

These are all conceptually more advanced ideas .

Compared to similar functional languages, Haskell differs in that it has support for:

• Lazy evaluation
• Pure functions by default
• Monadic side effects
• Type classes
• Syntax based on layout

The GHC Haskell compiler, in particular, provides some interesting extensions:

• Generalised algebraic data types
• Impredicative types system
• Software transactional memory
• Parallel, SMP runtime system

Read the language definition to supplement these notes. For more depth and examples see the Haskell wiki .

Interacting with the language

Haskell is both compiled and interpreted. For exploration purposes, we'll consider interacting with Haskell via the GHCi interpreter:

• expressions are entered at the prompt
• newline signals end of input

Here is a GHCi session, starting from a UNIX prompt.

Here the incredibly simple Haskell program let x = 3 + 4 is compiled and loaded, and available via the variable x .

We can ask the system what type it automaticaly inferred for our variable. x :: Integer means that the variable x "has type" Integer , the type of unbounded integer values.

A variable evaluates to its value.

The variable x is in scope, so we can reuse it in later expressions.

Local variables may be bound using let , which declares a new binding for a variable with local scope.

Alternatively, declarations typed in at the top level are like an open-ended let:

Notice that type inference infers the correct type for all the expressions, without us having to ever specify the type explicitly.

Basic types

There is a range of basic types, defined in the language Prelude .

For example:

These types have all the usual operations on them, in the standard libraries .

• The Prelude contains the core operations on basic types. It is imported by default into every Haskell module. For example;

Learn the Prelude well. Less basic functions are found in the standard libraries . For data structures such as List , Array and finite maps .

To use functions from these modules you have to import them, or in GHCi, refer to the qualified name, for example to use the toUpper function on Chars:

In a source file, you have to import the module explicitly:

Overloading

Haskell uses typeclasses to methodically allow overloading. A typeclass describes a set of functions, and any type which provides those functions can be made an instance of that type. This avoids the syntactic redundancy of languages like OCaml.

For example, the function * is a method of the typeclass Num , as we can see from its type:

Which can be read as "* is a polymorphic function, taking two values of some type 'a', and returning a result of the same type, where the type 'a' is a member of the class Num".

This means that it will operate on any type in the Num class, of which the following types are members: Double , Float , Int , Integer . Thus:

or on integers:

The type of the arguments determines which instance of * is used. Haskell also never performs implicit coercions, all coercions must be explicit. For example, if we try to multiply two different types, then the type check against * :: Num a => a -> a -> a will fail.

To convert 5 to a Double we'd write:

Why bother -- why not allow the system to implicitly coerce types? Implicit type conversions by the system are the source of innumerable hard to find bugs in languages that support them, and makes reasoning about a program harder, since you must apply not just the language's semantics, but an extra set of coercion rules.

Note that If we leave off the type signatures however, Haskell will helpfully infer the most general type:

Expressions

In Haskell, expressions are everything. There are no pure "statements" like in Java/C++. For instance, in Haskell, if - then - else is a kind of expression, and results in a value based on the condition part.

Local bindings

In Haskell let allows local declarations to be made in the context of a single expression.

is analogous to:

in C, but the Haskell variable x is given a value that is immutable (can never change).

When you declare a new variable, Haskell automatically allocates that value for you -- no need to explicitly manage memory. The garbage collector will then collect any unreachable values once they go out of scope.

Advanced users can also manage memory by hand using the foreign function interface.

Lists are ... lists of Haskell values. Defining a new list is trivial, easier than in Java.

This automatically allocates space for the list and puts in the elements. Haskell is garbage-collected like Java so no explicit de-allocation is needed. The type of the list is inferred automatically. All elements of a list must be of the same type.

Notice how the function call concat [ "f" , "g" ] does not require parenthesis to delimit the function's arguments. Haskell uses whitespace, and not commas, and:

• You don't need parentheses for function application in Haskell: sin 0.3
• Multiple arguments can be passed in one at a time (curried) which means they can be separated by spaces: max 3 4 .

Lists must be uniform in their type ("homogeneous").

Here we tried to build a list containing a Char and a Boolean, but the list constructor , [] , has type:

meaning that all elements must be of the same type, a . (For those wondering how to build a list of heterogeneous values, you would use a sum type ):

List operations are numerous, as can be seen in the Data.List library .

Pattern matching

Haskell supports pattern matching on data structures. This is a powerful language feature, making code that manipulates data structures incredibly simple. The core language feature for pattern matching is the case expression:

The case forces x (the scrutinee) to match pattern h : t , a list with head and tail, and then we extract the head, h . Tail is similar, and we can use a wildcard pattern to ignore the part of the pattern we don't care about:

Tuples are fixed length structures, whose fields may be of differing types ("heterogeneous"). They are known as product types in programming language theory.

Unlike the ML family of languages, Haskell uses the same syntax for the value level as on the type level. So the type of the above tuple is:

All the data mentioned so far are immutable - it is impossible to change an entry in an existing list, tuple, or record without implicitly copying the data! Also, all variables are immutable. By default Haskell is a pure language. Side effects, such as mutation, are discussed later.

Here is a simple recursive factorial function definition.

The function name is fac , and the argument is n . This function is recursive (and there is no need to specially tag it as such, as you would in the ML family of languages).

When you apply (or invoke) the fac function, you don't need any special parenthesis around the code. Note that there is no return statement; instead, the value of the whole body-expression is implicitly what gets returned.

Functions of more than one argument may be defined:

Other important aspects of Haskell functions:

• Functions can be defined anywhere in the code via lambda abstractions :

Or, identical to let f x = x + 1 :

Anonymous functions like this can be very useful. Also, functions can be passed to and returned from functions. For example, the higher order function map , applies its function argument to each element of a list (like a for-loop):

In Haskell, we can use section syntax for more concise anonymous functions:

Here map takes two arguments, the function ( ^ 2 ) :: Integer -> Integer , and a list of numbers.

Currying is a method by which function arguments may be passed one at a time to a function, rather than passing all arguments in one go in a structure:

The type of comb, Num a => a -> a -> a , can be rewritten as Num a => a -> ( a -> a ) . That is, it takes a single argument of some numeric type a , and returns a function that takes another argument of that type!

Indeed, we can give comb only one argument, in which case it returns a function that we can later use:

Mutually recursive functions may be defined in the same way as normal functions:

This example also shows a pattern match with multiple cases, either empty list or nonempty list. More on patterns now.

Patterns make function definitions much more succinct, as we just saw.

In this function definition, [] and ( x : xs ) are patterns against which the value passed to the function is matched. The match occurs on the structure of the data -- that is, on its constructors .

Lists are defined as:

That is, a list of some type a has type [ a ] , and it can be built two ways:

• either the empty list, []
• or an element consed onto a list, such as 1 : [] or 1 : 2 : 3 : [] .
• For the special case of lists, Haskell provides the syntax sugar: [ 1 , 2 , 3 ] to build the same data.

Thus, [] matches against the empty list constructor, and ( x : xs ) , match against the cons constructor, binding variables x and xs to the head and tail components of the list.

Remember that case is the syntactic primitive for performing pattern matching (pattern matching in let bindings is sugar for case ). Also, the first successful match is taken if more than one pattern matches:

Warnings will be generated at compile time if patterns don't cover all possibilities, or contain redundant branches.

An exception will be thrown at runtime if a pattern match fails:

As we have seen, patterns may be used in function definitions. For example, this looks like a function of two arguments, but its a function of one argument which matches a pair pattern.

Immutable declarations

Immutable Declarations

• Important feature of let-defined variable values in Haskell (and some other functional languages): they cannot change their value later.
• Greatly helps in reasoning about programs---we know the variable's value is fixed.
• Smalltalk also forces method arguments to be immutable; C++'s const and Java's final on fields has a similar effect.

Here's the one that will mess with your mind: the same thing as above but with the declarations typed into GHCi. (The GHCi environment conceptually an open-ended series of lets which never close).

Higher order functions

Haskell, like ML, makes wide use of higher-order functions: functions that either take other functions as argument or return functions as results, or both. Higher-order functions are an important component of a programmer's toolkit.

• They allow "pluggable" programming by passing in and out chunks of code.
• Many new programming design patterns are possible.
• It greatly increases the reusability of code.
• Higher-order + Polymorphic = Reusable

The classic example of a function that takes another function as argument is the map function on lists. It takes a list and a function and applies the function to every element of the list.

The lower case variables in the type declaration of map are type variables , meaning that the function is polymorphic in that argument (can take any type).

Perhaps the simplest higher-order function is the composer, in mathematics expressed as g o f . it takes two functions and returns a new function which is their composition:

This function takes three arguments: two functions, f and g , and a value, x . It then applies g to x , before applying f to the result. For example:

As we have seen before, functions are just expressions so can also be immediately applied after being defined:

Note how Haskell allows the infix function . to be used in prefix form, when wrapped in parenthesis.

Currying is an important concept of functional programming; it is named after logician Haskell Curry , after which the languages Haskell and Curry are named! Multi-argument functions as defined thus far are curried, lets look at what is really happening.

Here is a two-argument function defined in our usual manner.

Here is another completely equivalent way to define the same function:

The main observation is myadd is a function returning a function, so the way we supply two arguments is

• Invoke the function, get a function back
• Then invoke the returned function passing the second argument.
• Our final value is returned, victory.
• ( myadd 3 ) 4 is an inlined version of this where the function returned by myadd 3 is not put in any variable

Here is a third equivalent way to define myadd, as an anonymous function returning another anonymous function.

With currying, all functions "really" take exactly one argument. Currying also naturally arises when functions return functions, as in the map application above showed. Multiple-argument functions should always be written in curried form; all the library functions are curried.

Note thus far we have curried only two-argument functions; in general, n-argument currying is possible. Functions can also take pairs as arguments to achieve the effect of a two-argument function:

So, either we can curry or we can pass a pair. We can also write higher-order functions to switch back and forth between the two forms.

Look at the types: these mappings in both directions in some sense "implement" the well-known isomorphism on sets: A * B -> C = A -> B -> C

A bigger example

Here is a more high-powered example of the use of currying.

Here is an analysis of this recursive function, for the arbitrary 2-element list [x1,x2], the call

reduces to (by inlining the body of fold):

which in turn reduces to:

From this we can assert that the general result returned from foldr f [ x1 , x2 , ... , xn ] y is f x1 ( f x2 f ... ( f xn y ) ... )))) . Currying allows us to specialize foldr to a particular function f, as with prod above.

Proving program properties by induction

We should in fact be able to prove this property by induction. Its easier if we reverse the numbering of the list.

Lemma . foldr f [ xn , ... , x1 ] y evaluates to f xn ( f xn - 1 f ... ( f x1 y ) ... ))) for n greater than 0.

Proof . Proceed by induction on the length of the list [ xn , .. , x1 ] .

Base Case n=1, i.e. the list is [x1]. The function reduces to f x1 ( foldr f [] y ) which reduces to f x1 y as hypothesized.

Induction Step . Assume

it matches the pattern with x being xn+1 and xs being [ xn , ... , x1 ] . Thus the recursive call is

which by our inductive assumption reduces to

And, given this result for the recursive call, the whole function then returns

which is what we needed to show. QED

The above implementation is inefficient in that f is explicitly passed to every recursive call. Here is a more efficient version with identical functionality.

This function also illustrates how functions may be defined in a local scope, using where . Observe 'go' is defined locally but then exported since it is the return value of f.

Question: How does the return value 'go' know where to look for k when its called??

summate is just go but somehow it "knows" that k is ( + ) , even though k is undefined at the top level:

go in fact knew the right k to call, so it must have been kept somewhere: in a closure . At function definition point, the current values of variables not local to the function definition are remembered in a structure called a closure. Function values in Haskell are thus really a pair consisting of the function (pointer) and the local environment, in a closure.

Without making a closure, higher-order functions will do awkward things (such as binding to whatever 'k' happens to be in scope). Java, C++, C can pass and return function (pointers), but all functions are defined at the top level so they have no closures.

Loading source from a file

You should never type large amounts of code directly into GHCi! Its impossible to fix errors. Instead, you should edit in a file. Usingg any editor, save each group of interlinked functions in a separate file, for example "A.hs". Then, from GHCi type:

This will compile everything in the file.

Haskell has the show function.

It simply returns a string representation for its arguments.

We have generally been ignoring the type system of Haskell up to now. Its time to focus on typing in more detail.

Type Declarations

Haskell infers types for you, but you can add explicit type declarations if you like.

You can in fact put type assertions on any variable in an expression to clarify what type the variable has:

Type synonyms

You can also make up your own name for any type. To do this, you must work in a separate file and load it into GHCi using the ":load A.hs" command.

Working from GHCi:

Polymorphic Types and Type Inference

Since id was not used as any type in particular, the type of the function is polymorphic ("many forms").

• t is a type variable, meaning it stands for some arbitrary type.
• Polymorphism is really needed with type inference -- inferring Int -> Int would not be completely general.

The form of polymorphism in Haskell is to be precise, parametric polymorphism. The type above is parametric in t : what comes out is the same type as what came in. Generics is another term for parametric polymorphism used in some communities.

• Java has no parametric polymorphism, but does have object polymorphism (unfortunately this is often just called polymorphism by some writers) in that a subclass object can fit into a superclass-declared variable.
• When you want parametric polymorphism in Java you declare the variable to be of type Object, but you have to cast when you get it out which requires a run-time check.
• The Java JDK version 1.5 will have parametrically polymorphic types in it.

The general intuition to have about the type inference algorithm is everything starts out as having arbitrary types, t, u, etc, but then the use of functions on values generates constraints that "this thing has the same type as that thing".

Use of type-specific operators obviously restricts polymorphism:

When a function is defined via let to have polymorphic type, every use can be at a different type:

Algebraic Data Types

Algebraic data types in Haskell are the analogue of union/variant types in C/Pascal. Following in the Haskell tradition of lists and tuples, they are not mutable. Haskell data types must be declared. Here is a really simple algebraic data type declaration to get warmed up, remember to write this in a separate file, and load it in to HHCi:

Three constructors have been defined. These are now official constants. Constructors must be capitalized, and variables must be lower-case in Haskell.

So we can type check them, but can't show them yet. Let's derive the typeclass Show for our data type, which generates a 'show' function for our data type, which GHCi can then use to display the value.

The previous type is only an enumerated type. Much more interesting data types can be defined. Remember the (recursive) list type:

This form of type has several new features:

• As in C/Pascal, the data types can have values and they can be recursively defined, plus,
• Polymorphic data types can be defined; a here is a type argument.
• Note how there is no need to use pointers in defining recursive variant types. The compiler does all that mucking around for you.
• Also note how ( : ) , the constructor, can be used as a function.

We can define trees rather simply:

Patterns automatically work for new data types.

Record Declarations

Records are data types with labels on fields. They are very similar to structs of C/C++. Their types are declared just like normal data types, and can be used in pattern matches.

Imperative Programming

Haskell and OCaml differ on imperative programming: OCaml mixes pure and impure code, while Haskell separates them statically.

The expressions and functions for I/O, mutable states, and other side effects have a special type. They enjoy a distinguished status: they are I/O instructions, and the entry point of each complete program must be one of them. The following honours this distinction by using the word command for them (another popular name is action ), though they are also expressions, values, functions.

Commands have types of the form IO a , which says it takes no parameter and it gives an answer of type a . (I will carefully avoid saying it “returns” type a , since “return” is too overloaded.) There are also functions of type b -> IO a , and I will abuse terminology and call this a command needing a parameter of type b , even though the correct description should be: a function from b to commands.

The command for writing a line to Standard Output is

It outputs the string parameter, plus linebreak. And since there is no answer to give, the answer type is the most boring () .

At first, using output commands at the prompt is as easy as using expressions.

You can also write a compound command with the >> operator.

The fun begins when you also take input. The command for reading one line from Standard Input is:

Note that the type is not String or () -> String . In a purely functional language, such types promise that all calls using the same parameter yield the exactly same string. This is of course what an input command cannot promise. If you read two lines, they are very likely to be different. The type IO String does not promise to give the same string all the time. (It only promises to be the same command all the time—a rather "duh" one.) But this poses a question: how do we get at the line it reads?

A non-solution is to expect an operation stripIO :: IO a -> a . What's wrong with this strip-that-IO mentality is that it asks to convert a command, which gives different answers at different calls, into a pure function, which gives the same answer at different calls. Contradiction!

But you can ask for a weaker operation: how to pass the answer on to subsequent commands (e.g., output commands) so they can use it. A moment of thought reveals that this is all you ever need. The operator sought is

It builds a compound command from two commands, the first one of which takes no parameter and gives an answer of type a , and the second of which needs a parameter of type a . You guessed it: this operator extracts the answer from the first command and passes it to the second. Now you have some way to use the answer!

Here is the first example. Why don't we read a line and immediately display it? getLine answers a string, and putStrLn wants a string. Perfect match!

But more often you want to output something derived from the input, rather than the input itself verbatim. To do this, you customize the second command to smuggle in the derivation. The trick of anonymous functions is very useful for this:

You will also want to give derived answers, especially if you write subroutines to be called from other code. This is facilitated by the command that takes a parameter and simply gives it as the answer (it is curiously named return ):

For example here is a routine that reads a line and answers a derived string, with a sample usage:

Some programmers never use Standard Input. Reading files is more common. One command for this is:

The parameter specifies the file path. Let us read a file and print out its first 10 characters (wherever available). Of course please change the filename to refer to some file you actually possess.

Do not worry about slurping up the whole file into memory; readFile performs a magic of pay-as-you-go reading.

A while ago I showed the >> operator for compound commands without elaboration. I can now elaborate it: it merely uses >>= in a way that throws away the first answer:

do-Notation

To bring imperative code closer to imperative look, Haskell provides the do-notation , which hides the >>= operator and the anonymous functions. An example illustrates this notation well, and it should be easy to generalize:

( cmd1 , cmd2 , and cmd3 may use x as a parameter; similarly, cmd3 may use z as a parameter. At the end, between cmd3 and } , you may choose to insert or omit semicolons; similarly right after { at the beginning.)

Below we re-express examples in the previous section in the do-notation.

At the prompt it is necessary to write one-liners. In a source code file it is more common to use multiple lines, one line for one command, as per tradition. In this case, layout rules allow omitting {;} in favour of indentation. Thus, here are two valid ways of writing the same do-block in a source code file, one with {;} and the other with layout.

Mutable variables

Data.IORef Data.Array.MArray Data.Array.IO

Control.Exception

Concurrency

Control.Concurrent Control.Concurrent.MVar

Data.STRef Data.Array.MArray Data.Array.ST

The State monad

Monad transformers

Compilation.

You can easily compile your Haskell modules to standalone executables. For example, write this in a file "A.hs":

In general, main is the entry point, and you must define it to be whatever you want run. (TODO: once the monad/IO section is done, this place should also say more about main and IO.)

The compiler, on unix systems, is ghc . For example "A.hs" can be compiled and run as:

For multiple modules, use the --make flag to GHC. Example: write these two modules:

To compile and run (this will automatically look for M1.hs):

In general, one and only one file must define main . In general, for all other files, the filename must match the module name.

Navigation menu

Getting started with Haskell

Install the Haskell Platform or cabal + ghc.

• ghc is the official Haskell compiler.

Hello World

Put this in a file ( hello_world.hs ). Compile it with ghc hello_world.hs , and run the executable.

Interpreter for Haskell. Not quite a read-execute loop like other languages, but it's useful.

• The = sign declares bindings.
• Local bindings with let
• Haskell will auto-insert semicolons by a layout rule.
• You can bind functions.
• Tokens on the line are function arguments
• Associativity - use parentheses for compound expressions

Haskell is a pure functional language.

• No side effects
• Deterministic - same result every time it is run with an input
• x = 5; x = 6 is an error, since x cannot be changed.
• order-independent
• This means you can divide by 0, create infinite lists... etc. so long as you're careful that those don't get evaluated.
• recursive - bound symbol is in scope within its own definition.

This program will cause an infinite loop (the program "diverges"), because the variable x in main is defined in terms of itself, not in terms of the declaration x = 5 :

How can you program without mutable variables?

• In C, you use mutable variables to create loops (like a for loop).
• Problem : The example recursive factorial implementation in Haskell uses function calls to loop, but those function calls will create stack frames, which will cause Haskell to consume memory.
• Solution : Haskell supports optimized tail recursion . Use an accumulator argument to make the factorial call tail recursive.

Guards and where clauses

• Pipe (" | ") symbol introduces a guard. Guards are evaluated top to bottom
• the first True guard wins.
• otherwise in the Haskell system Prelude evaluates to true
• Where clauses can scope over multiple guards
• Convenient for binding variables to use in guards

Variable names

• It's conventional in Haskell to have versions of variables and functions denoted by apostrophes ('). But David Mazieres finds that this can cause difficult to find bugs, so he suggests that you use the longer symbol name for the larger scope .

Every expression and binding has a type (it is strongly typed )

• The :: operator has the lowest precedence, so you need to parenthesize.

Haskell uses function currying .

• Functions are called one argument at a time.
• This is equivalent to (add 2) 3
• (add 2) returns a function which takes one parameter - the second parameter in adding something.
• It's a good idea to declare types of top-level bindings.

Defining data types

Types start with capital letters.

• Give it a name
• Give it a set of constructors
• Tell what other types it derives from ( deriving Show allows it to print your type, for example) Example:
• But, you can have multiple constructors by declaring them with different names.
• Constructors additionally don't need to take arguments
• Constructors act like functions producing values of their types.
• Example in slides
• Some useful, parameterized types: Maybe and Either .
• You can deconstruct types and bind variables within guards. Example in slides.

So common that Haskell has Lists as a predefined type with syntactic sugar. Strings are just lists of Char s.

• Bullets from slides

Constructors

Two constructors: x:rest and [] .

• [] is the empty list
• x:rest is an infix constructor of a variable to be prepended to the head of the rest of the list.

Note on error code:

• error is a function of any type that throws an exception. It is intended for progamming errors that should never occur.

Other methods

• The ++ infix operator is used for concatenation of lists: list1 ++ list2

Parsing with deriving Read and reads

• Unfortunately, parsing is more complicated than printing, since the string for an object may not parse correctly or may even be ambiguous.
• reads parses and returns a parsed object, along with the rest of the string.

Useful tool: Hoogle

A search engine for Haskell and the Haskell libraries. David Mazieres recommends that you make this a keyword in your search bar! Haskell may have a steep learning curve, but it is relatively easy to understand what code is doing (with tools like this).

Example: counting letters

Due to thunks you don't actually have to keep an intermediate list in memory at any point in time (see example in slides)

Function composition

• The . infix operator provides function composition: (f . g) x = f (g x) .
• The new version doesn't name the argument, which is called point-free programming.
• This allows you to apply arguments kind of like right-to-left Unix piping.

Lambda Extraction

• Sometimes you want to name arguments but not the function, which you can through lambdas .
• Use backslash (" \\ ") to declare a lambda.

Infix vs Prefix notation

• If it starts with a lowercase letter, it's a prefix invocation
• If it is surrounded by backticks ("```"), it's infix.
• Example: add 1 2 == 1 \ add` 2`.
• If you don't add an argument, you're creating a function that is missing an argument (which can be applied to a new "first argument"

In Haskell, when do we use in with let?

In the following code, the last phrase I can put an in in front. in 前面。--> Will it change anything?

Another question: If I decide to put in in front of the last phrase, do I need to indent it? in 在最后一句的前面，我需要缩进呢？-->

I tried without indenting and hugs complains

Last generator in do {...} must be an expression

Ok, so people don't seem to understand what I'm saying. Let me rephrase: are the following two the same, given the context above?

Another question concerning the scope of bindings declared in let : I read here that: let 声明的绑定范围的另一个问题：我 在这里 读到：-->

where Clauses. where 条款。-->

Sometimes it is convenient to scope bindings over several guarded equations, which requires a where clause:

Note that this cannot be done with a let expression, which only scopes over the expression which it encloses . 它所包含 的表达式。-->

My question: so, the variable digits shouldn't be visible to the last print phrase. Do I miss something here?

solution1  112 ACCPTED  2011-11-25 22:41:15

Short answer : Use let without in in the body of a do-block, and in the part after the | 简短的回答 ：使用 let 没有 in 在一个do块体，并在之后的部分 | --> in a list comprehension. Anywhere else, use let ... in ... . let ... in ... -->

The keyword let is used in three ways in Haskell. let 在Haskell中以三种方式使用。-->

The first form is a let-expression . let-expression 。-->

This can be used wherever an expression is allowed, eg

The second is a let-statement . let-statement 。--> This form is only used inside of do-notation, and does not use in . in 不使用。-->

The third is similar to number 2 and is used inside of list comprehensions. Again, no in . in 。-->

This form binds a variable which is in scope in subsequent generators and in the expression before the | | 之前的表达式中--> .

The reason for your confusion here is that expressions (of the correct type) can be used as statements within a do-block, and let .. in .. is just an expression. let .. in .. 只是一个表达式。-->

Because of the indentation rules of haskell, a line indented further than the previous one means it's a continuation of the previous line, so this

gets parsed as

Without indentation, you get a parse error:

In conclusion, never use in in a list comprehension or a do-block. in 列表理解或阻止中使用。--> It is unneccesary and confusing, as those constructs already have their own form of let . let 形式。-->

solution2  18  2011-11-25 23:00:03

First off, why hugs? The Haskell Platform is generally the recommended way to go for newbies, which comes with GHC. Haskell平台 通常是推荐GHC新手的方式。-->

Now then, on to the let keyword. let 关键字。--> The simplest form of this keyword is meant to always be used with in . 始终 与 in 一起使用。-->

For example,

The {assignments} are only in scope in the corresponding {expression} . {assignments} 仅 在相应 {expression} 范围内。 --> Regular layout rules apply, meaning that in must be indented at least as much as the let that it corresponds to, and any sub-expressions pertaining to the let expression must likewise be indented at least as much. in 必须缩进至少不亚于 let ，它对应，以及涉及到任何子表达式 let 表达同样必须缩进至少之多。--> This isn't actually 100% true, but is a good rule of thumb; Haskell layout rules are something you will just get used to over time as you read and write Haskell code. Just keep in mind that the amount of indentation is the main way to indicate which code pertains to what expression.

Haskell provides two convenience cases where you don't have to write in : do notation and list comprehensions (actually, monad comprehensions). 不必 写 in ：做标记和list解析（实际上，单子内涵）。--> The scope of the assignments for these convenience cases is predefined.

For do notation, the {assignments} are in scope for any statements that follow, in this case, bar and baz , but not foo . do 记号，在 {assignments} 在范围为遵循，在这种情况下，任何陈述 bar 和 baz ，而不是 foo 。--> It is as if we had written

List comprehensions (or really, any monad comprehension) desugar into do notation, so they provide a similar facility.

The {assignments} are in scope for the expressions bar and baz , but not for foo . {assignments} 在表达式 bar 和 baz 范围内，但不适用于 foo 。-->

where is somewhat different. where 有所不同。--> If I'm not mistaken, the scope of where lines up with a particular function definition. where 的范围与特定的函数定义一致。--> So

the {assignments} in this where clause have access to x and y . where 子句中的 {assignments} 可以访问 x 和 y 。--> guard1 , guard2 , blah1 , and blah2 all have access to the {assignments} of this where clause. guard1 ， guard2 ， blah1 和 blah2 都 可以访问此 where 子句的 {assignments} 。--> As is mentioned in the tutorial you linked, this can be helpful if multiple guards reuse the same expressions.

solution3  7  

In do notation, you can indeed use let with and without in . do 记号，你的确可以使用 let 有和没有 in 。--> For it to be equivalent (in your case, I'll later show an example where you need to add a second do and thus more indentation), you need to indent it as you discovered (if you're using layout - if you use explicit braces and semicolons, they're exactly equivalent). do 并因此更多缩进的示例），你需要在发现时缩进它（如果你使用布局 - 如果你使用显式括号和分号，它们完全相同）。-->

To understand why it's equivalent, you have to actually grok monads (at least to some degree) and look at the desugaring rules for do notation. 为什么 它是等价的，你必须真正神交单子（至少在一定程度上），并查看了脱糖的规则 do 记号。--> In particular, code like this:

is translated to let x = ... in do { stmts } . let x = ... in do { stmts } 。--> In your case, stmts = print (problem_8 digits) . stmts = print (problem_8 digits) 。--> Evaluating the whole desugared let binding results in an IO action (from print $ ... ). let 绑定会导致IO操作（来自 print $ ... ）。--> And here, you need understanding of monads to intuitively agree that there's no difference between do notations and "regular" language elements describing a computation resulting in monadic values. do notations和描述导致monadic值的计算的“常规”语言元素之间没有区别。-->

As for both why are possible: Well, let ... in ... has a broad range of applications (most of which have nothing to do with monads in particular), and a long history to boot. let ... in ... 有广泛的应用程序（其中大多数与monad无关），以及很长的启动历史。--> let without in for do notation, on the other hand, seems to be nothing but a small piece of syntactic sugar. let 没有 in 为 do 记号，在另一方面，似乎只是一小片的语法糖。--> The advantage is obvious: You can bind the results of pure (as in, not monadic) computations to a name without resorting to a pointless val <- return $ ... and without splitting up the do block in two: val <- return $ ... 并且不将 do 块拆分为两个：-->

The reason you don't need an extra do block for what follows the let is that you only got a single line. do 阻塞接下来的 let 是，你只得到了一个单行。--> Remember, do e is e . do e 是 e 。-->

Regarding your edit: digit being visible in the next line is the whole point. digit 是整点。--> And there's no exception for it or anything. do notation becomes one single expression, and let works just fine in a single expression. do 记号变成一个单一的表达，并 let 作品只是在一个单一的表达罚款。--> where is only needed for things which aren't expressions. where 只需要东西是没有表情。-->

For the sake of demonstration, I'll show the desugared version of your do block. do 块的desugared版本。--> If you aren't too familiar with monads yet (something you should change soon IMHO), ignore the >>= operator and focus on the let . >>= 运算符并专注于 let 。--> Also note that indentation doesn't matter any more.

solution4  1  2011-11-25 22:37:05

Some beginner notes about "are following two the same".

For example, add1 is a function, that add 1 to number: add1 是一个函数，它为数字加1：-->

So, it's like add1 x = x + inc with substitution inc by 1 from let keyword. add1 x = x + inc ， let 关键字的替换inc为1。-->

When you try to suppress in keyword in 关键字-->

you've got parse error.

From documentation : 文档 ：-->

Btw, there are nice explanation with many examples about what where and in keyword actually do. 很好的解释 有什么例子很多 where 并 in 关键字实际上做。-->

• Related Question
• Related Blog
• Related Tutorials

The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:[email protected].

• functional-programming
• haskell-platform
• haskell-stack
• if-statement
• function-composition
• guard-statement
• haskell-snap-framework