How to update nested record structure with lists

Question

Can someone tell me how I can update a subitem in a nested record? I want to set isSelected to true for the Item with value = "B"

type MyItem = {isSelected:bool; value:string}
type MyModel = {list:MyItem list}

let a = {isSelected = false; value = "A"}
let b = {isSelected = false; value = "B"} 
let c = {isSelected = false; value = "C"}
let m = {list = [a;b;c]}

let m2 = { m with list = { m.list with ???  = { ??? }}} 

I will not use mutable data structures.

Answer 1

Immutability is great but when dealing with nested immutable structures it can get a bit hairy. Especially if it's deeply nested.

One way to deal with this is so called Lenses.

So I increased the nesting level of the example a bit so that the value of lenses are more visible.

module Lenses =
  // This lens is a pair of function, a getter that get's inner value of an object
  //  and a setter that sets the inner value of an object
  //  The cool thing is that a lens is composable meaning we can create a lens
  //  that allows us to get and set a deeply nested property succinctly
  type Lens<'O, 'I> = L of ('O -> 'I)*('I -> 'O -> 'O)

  let lens (g : 'O -> 'I) (s : 'I -> 'O -> 'O) = L (g, s)

  // Gets an inner value
  let get     (L (g, _)) o    = g o
  // Sets an inner value
  let set     (L (_, s)) i o  = s i o
  // Updates an inner value given an updater function that sees the
  //  inner value and returns a new value
  let over    (L (g, s)) u o  = s (u (g o)) o

  // Compose two lenses into one, allows for navigation into deeply nested structures
  let compose (L (og, os)) (L (ig, is)) =
    let g o   = ig (og o)
    let s i o = os (is i (og o)) o
    L (g, s)

  type Lens<'O, 'I> with
    static member (-->) (o, i) = compose o i

open Lenses

// I made the model a bit more complex to show benefit of lenses

type MySelection =
  {
    isSelected: bool
  }

  // Define a lens that updates the property, this code can potentially be generated
  //  Scala does this with macros, in F# there are other possibilities
  static member isSelectedL : Lens<MySelection, bool> = lens (fun o -> o.isSelected) (fun i o -> { o with isSelected = i })

type MyValue =
  {
    value: string
  }

  static member valueL : Lens<MyValue, string> = lens (fun o -> o.value) (fun i o -> { o with value = i })

type MyItem   = 
  {
    selection : MySelection
    value     : MyValue
  }

  static member selectionL  : Lens<MyItem, MySelection> = lens (fun o -> o.selection) (fun i o -> { o with selection  = i })
  static member valueL      : Lens<MyItem, MyValue>     = lens (fun o -> o.value    ) (fun i o -> { o with value      = i })

type MyModel  = 
  {
    list: MyItem list
  }

  static member listL : Lens<MyModel, MyItem list> = lens (fun o -> o.list) (fun i o -> { o with list = i })

[<EntryPoint>]
let main argv =
  // Define example model
  let a = {selection = {isSelected = false}; value = {value = "A"}}
  let b = {selection = {isSelected = false}; value = {value = "B"}}
  let c = {selection = {isSelected = false}; value = {value = "C"}}
  let m = {list = [a;b;c]}

  // Print it
  printfn "%A" m

  // Update the model
  let m2 = 
    let mapper (v : MyItem) = 
      // Grabs the nest value using lens composition
      let nestedValue = v |> get (MyItem.valueL --> MyValue.valueL)
      let isSelected = nestedValue = "B"
      // Set the nested isSelected using lens composition
      v |> set (MyItem.selectionL --> MySelection.isSelectedL) isSelected
    // Maps nested list property
    m |> over MyModel.listL (List.map mapper)
  printfn "%A" m2

  0

Answer 2

Use List.map:

let m2 = 
  { m with list = 
    List.map (fun item -> 
      if item.value = "B" then 
        { item with isSelected = true }
      else
        item)
      m.list
  }

This will create a new list where every item is the same as before, except the one we want to "update" because we replace that with a new item where isSelected is true.