Recursive objects amending with spread operator

[germanosin]

Hi, community!

I'm trying to merge multiple dynamic objects and faced an issue.

I expect that merged and mergedOther should be identical, but they differ.

class Config {
    spring: SpringConfig
}

class SpringConfig {
    world: WorldConfig?
    test: TestConfig?
}

class WorldConfig {
    name: String
}

class TestConfig {
    name: String
}

source : Dynamic = new {
    spring {
        world {
            name = "True"
        }
    }
    field = 1
}

another : Dynamic = new {
    spring {
        test {
            name = "True"
        }
    }
}

merged = (source) { ... another}

mergedOther = (source) {
     spring {
        test {
            name = "True"
        }
    }
}

Results:

source {
  spring {
    world {
      name = "True"
    }
  }
  field = 1
}
another {
  spring {
    test {
      name = "True"
    }
  }
}
merged {
  spring {
    test {
      name = "True"
    }
  }
  field = 1
}
mergedOther {
  spring {
    world {
      name = "True"
    }
    test {
      name = "True"
    }
  }
  field = 1
}

If it's expected behaviour, what is the right way to merge objects?

Thanks!

[HT154]

I ran across this myself a few weeks ago! Not only is this expected, but it's a gateway to one of the language's more advanced features: Mixins.

Using the spread operator like you have does not perform a "deep" amend, it only replaces the keys in source with the keys that exist in another, which explains why the output for merged looks the way it does.

A Mixin<Dynamic> is sugar for Function1<Dynamic, Dynamic>, or a function that accepts a Dynamic, transforms it, and returns the result. Creating a Mixin looks very similar to creating a regular value:

another: Mixin<Dynamic> = new {
    spring {
        test {
            name = "True"
        }
    }
}

Integrated into your example code, it looks like this:

class Config {
    spring: SpringConfig
}

class SpringConfig {
    world: WorldConfig?
    test: TestConfig?
}

class WorldConfig {
    name: String
}

class TestConfig {
    name: String
}

source: Dynamic = new {
    spring {
        world {
            name = "True"
        }
    }
    field = 1
}

hidden another: Mixin<Dynamic> = new {
    spring {
        test {
            name = "True"
        }
    }
}

merged = source |> another

mergedOther = (source) {
     spring {
        test {
            name = "True"
        }
    }
}

Which renders the way you were originally expecting:

source {
  spring {
    world {
      name = "True"
    }
  }
  field = 1
}
merged {
  spring {
    world {
      name = "True"
    }
    test {
      name = "True"
    }
  }
  field = 1
}
mergedOther {
  spring {
    world {
      name = "True"
    }
    test {
      name = "True"
    }
  }
  field = 1
}

---

The one major pain point I've found with Mixins is that they cannot be directly rendered (since they are "just" functions) and there's no direct or implicit way to mix them into an empty value. You can do this explicitly like this:

anotherRendered = new Dynamic {} |> another

Which (in the above example) renders to:

anotherRendered {
  spring {
    test {
      name = "True"
    }
  }
}

---

Another especially interesting thing about Mixins is that that they themselves can be amended! Adding some more:

hidden anotherAgain: Mixin<Dynamic> = (another) { // <- this amends the existing Mixin another!
    spring {
        test {
            variant = "Debug"
        }
    }
}

mergedAgain = source |> anotherAgain

This renders as you might hope:

mergedAgain {
  spring {
    world {
      name = "True"
    }
    test {
      name = "True"
      variant = "Debug"
    }
  }
  field = 1
}

[germanosin]

Wow! Awesome! Thanks for quick reply and detailed explanation!