feat(array): add support to pipe into array.from

[nathanielc]

With this change you can now pipe the rows argument into the
array.from function.

Checklist

Dear Author 👋, the following checks should be completed (or explicitly dismissed) before merging.

• ✏️ Write a PR description, regardless of triviality, to include the value of this PR
• 🔗 Reference related issues
• 🏃 Test cases are included to exercise the new code
• 🧪 If new packages are being introduced to stdlib, link to Working Group discussion notes and ensure it lands under experimental/
• 📖 If language features are changing, ensure docs/Spec.md has been updated

Dear Reviewer(s) 👋, you are responsible (among others) for ensuring the completeness and quality of the above before approval.

[jsternberg]

I'm not sure I'm the biggest fan of this. I can't really think of another example where we do this kind of thing. I saw the PR and thought I'd like it, but the test cases are a bit hard for me to read.

Is there a specific request asking for this or is this just a quality of life change? I'd like to get some opinions from others on the team if they feel it looks right before clicking approve. If others like it, I've got no problem with hitting approve from a functional standpoint.

[sanderson]

@jsternberg This is coming from me as I prepare content for the rollout of dynamic types. It just removes the need to assign an array to a variable to render it as a table when parsing JSON using the dynamic package:

import "array"
import "experimental/dynamic"

jsonData = bytes(v: "
    {
    \"items\":  [
        {\"name\": \"a\", \"pos\": {\"x\": 10, \"y\": 10, \"z\": 20}},
        {\"name\": \"b\", \"pos\": {\"x\": 30, \"y\": 99}},
        {\"name\": \"c\", \"pos\": {}},
        {\"name\": \"d\"}
        ]
    }
")

parsed = dynamic.parseJSON(data: jsonData)

parsed.items
    |> dynamic.asArray()
    |> array.map(
        fn: (x) => (
            {
                name: string(v: x.name),
                posX: int(v: x.pos.x),
                posY: int(v: x.pos.y)
            }
        )
    )
    |> array.from()

[jsternberg]

Ok sure. I'll just say I discourage people from using it this way outside of this context.

[nathanielc]

Yes with the json use case its a bit awkward when every other function has a pipeforward argument.

For example:

dynamic.parseJSON(...)
    |> dynamic.asArray()
    |> array.filter(fn: (x) => x.bar == 42)
    |> array.map(fn: (x) => ({foo: x.foo}))
    |> array.from()
    |> to()
    

Without this change users must do:

rows = dynamic.parseJSON(...)
    |> dynamic.asArray()
    |> array.filter(fn: (x) => x.bar == 42)
    |> array.map(fn: (x) => ({foo: x.foo}))
    
array.from(rows: rows)
    |> to()

[nathanielc]

What @sanderson said. My github hadn't refreshed with the above comments before writing my reply.

[sanderson]

Just one additional update. Need to add this to the parameter description:

Default is the piped-forward array (`<-`).