Question

Is there a way to return an object used in a lambda expression, but with a different value? I’ve been using the “kind of linq-select” way, but I’d like to do something like this:

let bob= tab 
|> Seq.map (fun x -> ignore (x.Value=x.Value+1); x)
|> Seq.iter (fun x -> x.Dump())

making all the x‘s in my sequence to have their value +1’ed.

instead of doing this:

let bob= tab 
|> Seq.map (fun x -> Ville(IdVille= 9, NoVille=x.Value+1, Nom=x.Nom, __RowVersion = x.__RowVersion))
|> Seq.iter (fun x -> x.Dump())

edit:

What I expect to get : from this, a dump of the sequence, hence the Iter and Dump…
What I want the sequence to be? Here is an example, well the original sequence, but after applying a function to each element and get a copy of the result… (No side effect on the original sequence).

For example, I have a sequence of names, I’d like to have a copy of the original sequence, but with upper-cased names. Now imagine the same, but with a sequence of objects got from a database.

Edit2:

I made a test with LinqPad and AdventureWorks database, and I did this:

let dc = new TypedDataContext()

let tab = dc.GetTable<Address>()

let bob = tab 
        |> Seq.map (fun x -> ignore (x.AddressLine1 <- "Bob"); x) 

tab.Dump()
bob.Dump()

The 2 Dump() results are differents. If I invert the 2 Dump() calls, both results are the same. You were right!

Answer 1

It’s hard to tell what you’re trying to do, but mutating a value suggests an imperative approach, so why not a for loop?

for x in tab do
  x.Value <- x.Value + 1
  x.Dump()

What value do you expect for bob? Seq.iter returns unit. If you mutate tab within Seq.map it will have the same value as bob.

EDIT

If you modify elements of a sequence within map the result and the original sequence will be one and the same. map is not intended to be used with side effects. An example:

type T(value) =
  member val Value = value with get, set

let tab = [T(0); T(1); T(3)]
let bob = tab |> Seq.map (fun x -> x.Value <- x.Value + 1; x)
tab = (Seq.toList bob) //true