model and array.filter

[pblackburn68]

Hi
This could me not understanding the way scriban or Textrude is working but a bit confused around using array.filter with a textrude model.
Scenario: I am using array.filter to retrieve an object from the model, changing a value on the returned object appears to change the value in the underlying model.
I assumed array.filter would return a copy not a pointer?
I have tried using functions rtahr than an inline function and pipes over passing the array in to the arry methods but all get the same result.

I have a simple Textrude project to demonstrate
using a csv model as below

Name
One
Two
Three
and this simple template

{{
func filtermodel()
    new = array.filter model @(do(p); ret p.Name == "Two"; end)
    ret array.first new
end

func altfilter()
    new = []
    for r in model
        if r.Name == "Two"
            new = array.add new r
        end
    end
    ret new
end
}}
{{~for a in model~}}
{{a.Name}}
{{end

f = filtermodel()
f.Name = "Five"

}}
{{~for a in model~}}
{{a.Name}} {{f}} {{f?.Name}}
{{end}}

Produces the output
One
Two
Three

One {Name: "Five"} Five
Five {Name: "Five"} Five
Three {Name: "Five"} Five

Changing to use the altfilter() as so
f = altfilter()
appears to resolve it but find some of the output below confusing
One
Two
Three

One [{Name: "Two"}] Five
Two [{Name: "Two"}] Five
Three [{Name: "Two"}] Five
ie why is dumping f out showing the Name value of Two??

Anyway thank you for a wonderful tool and introducing me to scriban.
Cheers

[NeilMacMullen]

Glad you're finding it useful :-) I think the mistake you are making is that you are forgetting that the model is an array of objects This is a bit obscured in your example because you only have a single column in your csv but if you consider you could have multiple columns then you can see why your filterModel must be iterating over objects rather than string values.

So you've used array.filter to pull out the one object in the array where the Name is "two" then returned that object. The filter operation certainly has created a new array (with one element) but it's a new array that contains the original object from the model. When you set the Name field of that object you're effectively writing back into the model.

You can create a new object based on the old one like this (and using piping to better indicate flow)

func filtermodel()
    two = model 
    |> array.filter  @(do(p); ret p.Name == "Two"; end) 
    |> array.first  
    ret { Name :two.Name} # create a new object
end

[NeilMacMullen]

You may also find the debug.dump method useful for tracing changes to objects - see https://github.com/NeilMacMullen/Textrude/blob/main/doc/builtIns.md

Also the in-built format conversion libraries can give you a bit more insight into object structure..

https://github.com/NeilMacMullen/Textrude/blob/main/doc/format_conversion.md

[pblackburn68]

OK understood around the filter, assumed it was more similar to the javascript filter so this makes sense.
Also thanks for the handy tips, especially the debug.dump.
Assume I'm safe in assuming that array.add clones the object from the model when appending to a new array, as it appears to work in the altfilter test, as my real wolrd example is a much more complex object.

Investigating migrating some t4 scripts across and must admit finding it a joy to use and excited by the potential.

Thanks for the quick response and have a great Christmas.

[NeilMacMullen]

Your altfilter function is returning an array instead of an object which is why the output shows square brackets which is why you're seeing those results.

Assume I'm safe in assuming that array.add clones the object from the model when appending to a new array

No - this is not the case. Scriban, in common with most languages (including Javascript) has a strong distinction between primitive types (int, string, bool) and "objects" and "arrays" which are collections/containers of primitives. Objects are passed around by reference so changing the value of one of the primitives inside an object changes that value for everyone else who is using the object reference.. To put this in concrete terms, if you set model[0].Name to "foo", that change affects everyone "globally".

It's tricky to do a "deep clone" of a structured object (this is true in all referenced based languages) but you can try to make your own copy in textrude by serialising to JSON/YAML then deserializing back again. Unfortunately this may throw away some type information since you are limited by the type representation available in the serialisation format.

Anyway, the key takeaway is that if you are trying to start with the model and build "intermediate" calculated values you need to be careful not to overwrite any of the original model values - the good news is that you can just add a new property on an object just by assigning it...

{{
func filtermodel()
    two = model 
    |> array.filter  @(do(p); ret p.Name == "Two"; end) 
    |> array.first  
    two.IsTwo=true;
end
filtermodel
model | textrude.to_json
}}

[
  {
    "Name": "One"
  },
  {
    "Name": "Two",
    "IsTwo": true
  },
  {
    "Name": "Three"
  }
]

[pblackburn68]

Many thanks again for the fast response and code debugging too :) yes spotted the flaw in my alternative solution and returning array.first gives the same problem. WIll digest the suggestions and look at alternatives. Cheers.

[NeilMacMullen]

Good to hear - have a good holiday :-)