github.com/kafkiansky/golist

Use go slice with generics.


License
MIT
Install
go get github.com/kafkiansky/golist

Documentation

Generic List for Go.

Software License

Contents

Installation

go get -u github.com/kafkiansky/golist

Usage

From

Create the List[V] from given slice:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.From([]int{1, 2, 3}))
}

FromString

Create the List[string] from given string, split it by separator and apply mapper:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.FromString[int]("1, 2, 3", ",", func(s string) (int, bool) {
        // do conversation logic here.
	}))
}

Range

Create the List[V] from the given range:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Range(0, 10).Values()) // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
}

L

Alias to From.

Var

Create the List[V] from variadic of type V:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(1, 2, 3).Values()) // [1, 2, 3]
}

Values

Get the values as builtin slice []V from the List[V].

First

Get the first element of List[V]:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(1, 2, 3).First()) // 1
}

Last

Get the last element of List[V]:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(1, 2, 3).Last()) // 3
}

Len

Get the actual len of List[V].

Add

Add the element to List[V]:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(1, 2, 3).Add(4).Values()) // [1, 2, 3, 4]
}

Delete

Delete the element from List[V] by index:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(1, 2, 3).Delete(0).Values()) // [2, 3]
}

Filter

Filter List[V] by the given filter function:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(1, 2, 3).Filter(func(v int) bool {
		// do your filter logic here
		return false
    }).Values())
}

Each

Iterate List[V] and apply a function:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(1, 2, 3).Each(func(v int) int {
		// do your logic here
		return v * 2
    }).Values()) // [2, 4, 6]
}

Or the Each function that take the List[V] and output new List[E]:

package main

import (
  "fmt"
  "github.com/kafkiansky/golist"
  "strconv"
)

func main() {
  fmt.Println(golist.Each(golist.Var(1, 2, 3), func(v int) string {
    return strconv.Itoa(v)
  }).Values()) // ["1", "2", "3"]
}

Chunk

Chunk List[V] to the slice of List[V] by the given size:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(1, 2, 3).Chunk(2)[0].Values()) // [1, 2]
}

Join

Chunk List[V] to the slice of List[V]:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(1, 2, 3).Join(golist.Var(4, 5)).Values()) // [1, 2, 3, 4, 5]
}

Nth

Get each nth element from the List[V]:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(0, 1, 2, 3, 4, 5, 6).Nth(2).Values()) // [0, 2, 4, 6]
}

Random

Get random value from the List[V]:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(0, 1, 2, 3, 4, 5, 6).Random()) // 2, in example
}

Contains

Check if element exists in the List[V]:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(0, 1, 2, 3, 4, 5, 6).Contains(2)) // true
	fmt.Println(golist.Var(0, 1, 2, 3, 4, 5, 6).Contains(11)) // false
}

Reverse

Generate the reverse list of List[V]:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(0, 1, 2, 3, 4, 5, 6).Reverse().Values()) // [6, 5, 4, 3, 2, 1, 0]
}

Shuffle

Shuffle the given List[V]:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(0, 1, 2, 3, 4, 5, 6).Shuffle().Values()) // [4, 1, 0, 6, 2, 5, 3], in example
}

Unique

Create the List[V] only from unique values of the target List[V]:

package main

import (
	"fmt"
	"github.com/kafkiansky/golist"
)

func main() {
	fmt.Println(golist.Var(0, 0, 1, 1, 2).Unique().Values()) // [0, 1, 2]
}

Zip

Zip target List[V] with the other:

package main

import (
  "fmt"
  "github.com/kafkiansky/golist"
  "log"
)

func main() {
  l, err := golist.Var(0, 1, 2).Zip(golist.Var(3, 5, 6))
  if err != nil {
    log.Fatalln(err) // occurred when lengths of the given list are different
  }

  fmt.Println(l[0].Values()) // [0, 3]
  fmt.Println(l[1].Values()) // [1, 5]
  fmt.Println(l[2].Values()) // [2, 6]
}

JoinToString

Joins the List[V] to string if V is type of string.

package main

import (
  "fmt"
  "github.com/kafkiansky/golist"
)

func main() {
  fmt.Println(golist.Var("first", "second").JoinToString(", ")) // "first, second"
}

Fill

Generate List[V] of the given V and provided count:

package main

import (
  "fmt"
  "github.com/kafkiansky/golist"
)

func main() {
  fmt.Println(golist.Fill("?", 3).Values()) // [?, ?, ?]
}

Sequence

Generate sequence. Useful for SQL query building:

package main

import (
  "fmt"
  "github.com/kafkiansky/golist"
)

func main() {
  fmt.Println(golist.Sequence("$", 3, 1).JoinToString(", ")) // "$1, $2, $3"
}

Interface

Converts the List[V] to []interface{}:

package main

import (
  "fmt"
  "github.com/kafkiansky/golist"
)

func main() {
  fmt.Println(golist.Var(0, 1, 2).Interface()) // []interface{}{0, 1, 2}
}

Empty

Return true if list len is zero:

package main

import (
  "fmt"
  "github.com/kafkiansky/golist"
)

func main() {
  fmt.Println(golist.L([]int{}).Empty()) // true
  fmt.Println(golist.L([]int{200}).Empty()) // false
}

Testing

$ make check

License

The MIT License (MIT). See License File for more information.