Haskell: let statement, copy data type to itself with/without modification not working

Question

I want to update a record syntax with a change in one field so i did something like:

let rec = rec{field = 1}

But I\'ve noticed that i can\

Answer 1

You never need to update a variable : you can always make another variable with the new value. In your case let rec' = rec{field = 1}.

Maybe you worry about performance and the value being unnecessarily copied. That's the compiler's job, not yours : even if you declare 2 variables in your code, the compiler should only make one in memory and update it in place.

Now there are times when the code is so complex that the compiler fails to optimize. You can tell by inspecting the intermediate core language, or even the final assembly. Profile first to know what functions are slow : if it's just an extra Int or Double, you don't care.

If you do find a function that the compiler failed to optimize and that takes too much time, then you can rewrite it to handle the memory yourself. You will then use things like unboxed vectors, IO and ST monad, or even language extensions to access the native machine-level types.

Answer 2

First of all, Haskell does not allow "copying" data to itself, which in the normal sense, means the data is mutable. In Haskell you don't have mutable "variable"s, so you will not be able to modify the value a given variable presents.

All you have did, is define a new variable which have the same name of its previous version. But, to do this properly, you have to refer to the old variable, not the newly defined one. So your original definition

let rec = rec { field=1 }

is a recursive definition, the name rec refer to itself. But what you intended to do, is to refer to the rec defined early on.

So this is a name conflict.

Haskell have some machenism to work around this. One is your "temporary renaming".

For the original example this looks like

let rec' = rec
let rec = rec' { field=1 }

This looks like your given solution. But remember this is only available in a command line environment. If you try to use this in a function, you may have to write

let rec' = rec in let rec = rec' { field=1 } in ...

Here is another workaround, which might be useful when rec is belong to another module (say "MyModule"):

let rec = MyModule.rec { field=1 }

Answer 3

The issue you're running into is that all let and where bindings in Haskell are recursive by default. So when you write

let rec = rec { ... }

it tries to define a circular data type that will loop forever when you try to evaluate it (just like let a = a).

There's no real way around this—it's a tradeoff in the language. It makes recursive functions (and even plain values) easier to write with less noise, but also means you can't easily redefine a a bunch of times in terms of itself.

The only thing you can really do is give your values different names—rec and rec' would be a common way to do this.

To be fair to Haskell, recursive functions and even recursive values come up quite often. Code like

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

can be really nice once you get the hang of it, and not having to explicitly mark this definition as recursive (like you'd have to do in, say, OCaml) is a definite upside.