lang

README

lang

Package lang provides some helpful language features excluded from the Go language.

Getting Started

The lang package can be added to a Go project with go get.

go get github.com/shoenig/lang@latest

import "github.com/shoenig/lang"

Examples

Map

Use lang.Map to apply a function across all elements of a slice.

conversion := lang.Map[int, string](originals, func(i int) string {
  return strconv.Itoa(i)
})

Filter / FilterFunc

Use lang.Filter or lang.FilterFunc to remove elements from a slice.

filtered := lang.Filter[string](items, unwanted...)

filtered := lang.FilterFunc[string](items, func(s string) bool {
  return someCondition(s)
})

Maybe

Use lang.Maybe as the ternary-operator for Go.

passing := lang.Maybe[string](check, "ok", "fail")

Head

Use lang.Head to get a sub-slice of the first N elements of another slice. lang.Head will return up to N elements, gracefully handling slices that may have fewer than N elements.

best := lang.Head[string](items, 3)

Tail

Use lang.Tail to get a sub-slice of the last N elements of another slice. lang.Tail will return up to N elements, gracefully handling slices that may have fewer than N elements.

worst := lang.Tail[string](items, 3)

Pairs

Use lang.Pair to conveniently associate two types together.

p := lang.Pair[string, int]{A: "bob", B: 42}

Contributing

Contributions are welcome! Feel free to help make lang better by filing an issue or opening a PR.

License

The github.com/shoenig/lang module is open source under the BSD-3-Clause license.

Documentation

Overview

Package lang provides some helpful or at least amusing language features not included in the standard Go language or libraries.

Index

• func Filter[A comparable](input []A, items ...A) []A
• func FilterFunc[A any](input []A, f func(A) bool) []A
• func Head[A any](input []A, count int) []A
• func Map[A, B any](input []A, f func(A) B) []B
• func Maybe[T any](b bool, value T, fallback T) T
• func Tail[A any](input []A, count int) []A
• type Pair

Functions

func Filter

func Filter[A comparable](input []A, items ...A) []A

Filter removes the list of items from input.

Note that Filter yields a deep copy.

func FilterFunc

func FilterFunc[A any](input []A, f func(A) bool) []A

FilterFunc uses f to remove elements from input. If f returns true for an element, that element is not included in the result.

Note that FilterFunc creates a deep copy.

func Head

func Head[A any](input []A, count int) []A

Head returns up to the first count elements in the given input slice.

Note that this is yields a shallow copy.

func Map

func Map[A, B any](input []A, f func(A) B) []B

Map applies function f to every A element in input to create a new slice of type B.

func Maybe

func Maybe[T any](b bool, value T, fallback T) T

Maybe returns value if b is true, or fallback otherwise.

func Tail

func Tail[A any](input []A, count int) []A

Tail returns up to the last count elements in the given input slice.

Note that this yields a shallow copy.

Types

type Pair

type Pair[T, U any] struct {
	A T
	B U
}

A Pair contains two elements of any type(s).