Go to file
a 6f3654e147 add another test 2022-03-26 21:18:22 -05:00
examples add another test 2022-03-26 21:18:22 -05:00
parallel Example 2022-03-26 20:44:39 -05:00
filter.go wip 2022-03-26 14:16:31 -05:00
fold.go map test 2022-03-26 17:22:54 -05:00
go.mod Example 2022-03-26 20:44:39 -05:00
go.sum map test 2022-03-26 17:22:54 -05:00
map.go make allocs more obvious 2022-03-26 17:29:43 -05:00
map_test.go map test 2022-03-26 17:22:54 -05:00
math.go map test 2022-03-26 17:22:54 -05:00
readme.md add newline 2022-03-26 20:58:15 -05:00
transform.go map test 2022-03-26 17:22:54 -05:00
transform_test.go parallel 2022-03-26 17:01:10 -05:00

readme.md

lambda

package lambda provides tools for performing operations on generic array types

features:

features:

  • Map [T] -> [T]
  • MapV [T] -> [V]
  • MapError [T] -> ([T], [error]
  • MapErrorV [T] -> ([V], [error]
  • Foldr [T] -> T
  • Foldl [T] -> T
  • Entries map[K]V -> ([K], [V])
  • Flatten T -> [T]
  • Merge ([T], [T]) -> [T]
  • Split ([T], int) -> T

todo:

  • idk

example: adding some numbers

package main

import (
  "log"

  "git.tuxpa.in/a/lambda"
)

func main(){
	arr := []int{1, 2, 3, 4, 6, 5}
	ans := lambda.Map(arr, func(x int) int { return x + 4 })
	// ans = []int{5, 6, 7, 8, 10, 9}
  log.Println(ans)
}

parallel

subpackage parallel provides parallelized operations on generic array types

features:

  • Map [T] -> [T]
  • MapV [T] -> [V]
  • MapError [T] -> ([T], [error]
  • MapErrorV [T] -> ([V], [error]

todo:

  • idk

example usage:

making a request

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"

    "git.tuxpa.in/a/lambda/parallel"
)

type someResult struct {
    Title string `json:"title"`
    Id    int    `json:"id"`
}

func main() {
    var requests = make([]*http.Request, 20)

    for i := range requests {
        r, _ := http.NewRequest("GET", fmt.Sprintf("https://jsonplaceholder.typicode.com/todos/%d", i), nil)
        requests[i] = r
    }

    results, errs := parallel.MapErrorV(requests, func(r *http.Request) (*someResult, error) {
        out := &someResult{}
        res, err := http.DefaultClient.Do(r)
        if err != nil {
            return nil, err
        }
        defer res.Body.Close()
        err = json.NewDecoder(res.Body).Decode(out)
        return out, err
    }, 4)

    for i, v := range results {
        if errs[i] != nil {
            log.Printf("err: %s", errs[i])
        } else {
            log.Printf("result: %+v", v)
        }
    }
}