CODEWITHSUNDEEP
dictionaryf#sequencelinqpad
Pacane
Pacane

Reputation: 21481

Returning object with different value

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!

Upvotes: 1

Views: 152

Answers (2)

latkin
latkin

Reputation: 16792

You can try using map along with an object expression to update just one field:

let bob = tab 
|> Seq.map (fun x -> {x with Value = x.Value + 1})
|> Seq.iter (fun x -> x.Dump())

Though bob will not get the results of Dump() assigned to it if you are using iter. You'd need to use map again for that.

Edit

This only works with record types.

Upvotes: 1

Daniel
Daniel

Reputation: 47904

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

Upvotes: 3

Related Questions