Data Processing between typescript and go

Data Processing

Map - data projection from a list or array like data structure
Reduce - reduction of a list or array like data structure into a new aggregate object
Deferred Execution -
Deferred Execution with AST -

TypeScript Language

Go Language Map/Reduce

Map

const numbers = [1, 2, 3, 4, 5];
const squares = numbers.map((n) => n * n);

console.log(squares); // [1, 4, 9, 16, 25]

const evens = numbers.filter((n) => n % 2 === 0);

console.log(evens); // [2, 4]

Map

In Go, mapping a function over a slice requires iteration using for loops or the range keyword.

Example: Mapping a function to square numbers

package main

import (
    "fmt"
)

func square(n int) int {
    return n * n
}

func mapSlice(nums []int, fn func(int) int) []int {
    result := make([]int, len(nums))
    for i, num := range nums {
        result[i] = fn(num)
    }
    return result
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    squares := mapSlice(numbers, square)
    fmt.Println(squares) // [1, 4, 9, 16, 25]
}

Example: Filtering Even Numbers

package main

import "fmt"

func filterSlice(nums []int, predicate func(int) bool) []int {
    result := []int{}
    for _, num := range nums {
        if predicate(num) {
            result = append(result, num)
        }
    }
    return result
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    evens := filterSlice(numbers, func(n int) bool { return n%2 == 0 })
    fmt.Println(evens) // [2, 4]
}

Reduce

const sum = numbers.reduce((acc, n) => acc + n, 0);

console.log(sum); // 15

Reduce

Go does not have a built-in reduce function like Python, but you can implement one using iteration.

Example: Reducing a Slice to Sum All Elements

package main

import "fmt"

func reduce(nums []int, fn func(int, int) int, initial int) int {
    result := initial
    for _, num := range nums {
        result = fn(result, num)
    }
    return result
}

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    sumNumbers := reduce(numbers, func(acc, n int) int { return acc + n }, 0)
    fmt.Println(sumNumbers) // 15
}

Better Alternative using a Simple Loop

package main

import "fmt"

func main() {
    numbers := []int{1, 2, 3, 4, 5}
    sum := 0
    for _, num := range numbers {
        sum += num
    }
    fmt.Println(sum) // 15
}

Deferred Execution

Support via libraries for deferred execution. RxJs and lodash/fp support pipelines, but these don't allow expression analysis for deferred execution.

import { of } from "rxjs";
import { map, filter } from "rxjs/operators";

const numbers$ = of(1, 2, 3, 4, 5).pipe(
    filter((n) => n % 2 === 0), // Deferred filter
    map((n) => n * n), // Deferred map
);

// Execution only happens when subscribed
numbers$.subscribe((result) => console.log(result));
// Output: 4, 16

import fp from "lodash/fp";

const numbers = [1, 2, 3, 4, 5];

const processNumbers = fp.pipe(
    fp.filter((n) => n % 2 === 0), // Deferred filter
    fp.map((n) => n * n), // Deferred map
);

console.log(processNumbers(numbers)); // [4, 16]

Deferred Execution

Go provides deferred execution using the defer keyword. This is typically used for resource cleanup, ensuring that certain actions (such as closing files or unlocking mutexes) occur before the function exits.

Example: Deferring Execution

package main

import "fmt"

func main() {
    fmt.Println("Start")
    defer fmt.Println("This will be printed last")
    fmt.Println("Middle")
}

Output:

Start
Middle
This will be printed last

Deferred Execution With AST

JavaScript proxy support does allow for some analysis:

const handler = {
    get: (target, prop) => {
        return (...args) => {
            target.operations.push({ prop, args });
            return target;
        };
    },
};

function createExpression() {
    return new Proxy({ operations: [] }, handler);
}

const expr = createExpression();
expr.filter((x) => x > 2).map((x) => x * 2);

console.log(expr.operations);
// Output: [{ prop: 'filter', args: [Function] }, { prop: 'map', args: [Function] }]

Deferred Execution with AST

Go does not have an equivalent to Python’s AST manipulation for execution deferral, but it does provide reflection and closures that allow dynamic execution.

Example: Using Closures for Deferred Execution

package main

import (
    "fmt"
)

func deferredExecution(fn func()) {
    defer fn()
}

func main() {
    deferredExecution(func() {
        fmt.Println("Deferred function executed")
    })
    fmt.Println("Main function finished")
}

Output:

Main function finished
Deferred function executed