TS Algorithms

maptree.ts

interface Node_<T> {
    readonly value: T
    readonly childreen: ReadonlyArray<Node_<T>> | undefined
}


const state: Node_<string> = {
  value: "foo",
    childreen: [
        {
            value: "bar",
            childreen: [{
                value: "foo",
                childreen: undefined
            },
            {
                value: "bar",
                childreen: undefined
            }]
        }]
}

const mapNode = <T, U>(node: Node_<T>, mapperFn: (val:T) => U):Node_<U> =>
  ({
    value: mapperFn(node.value),
    childreen: (node.childreen === undefined) 
      ? undefined
      : node.childreen.map( nextNode => mapNode(nextNode, mapperFn))
  })

Uma versao mutavel (side-effect) fica assim

const mapBranch = <T>(branch: Branch<T>, mapperFn: (val: T) => T): void => {
    branch.value = mapperFn(branch.value)
    if (branch.branches === undefined)
        return
    else
        branch.branches.map(nextBranch => mapBranch(nextBranch, mapperFn))
}

Toda mutabilidade por definicao é um side-effect.