xtract

README

xtract

Extract from collection and build iterator.

Quick Start

Install

go get github.com/miyamo2/xtract

Setup GOEXPERIMENT

[!IMPORTANT]

If your Go project is Go 1.23 or higher, this section is not necessary.

Also, if Go 1.21 or lower, you will need to update to Go 1.22.

go env -w GOEXPERIMENT=rangefunc

Usage

s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 100, 101}
xt := xtract.FromSlice(s)
even := xt.ByValue(func(i int) bool { return i%2 == 0 })
odd := xt.ByValue(func(i int) bool { return i%2 != 0 })

fmt.Println("---even---")
for v := range even.Values() {
    fmt.Println(v)
}

fmt.Println("---odd---")
for v := range odd.Values() {
    fmt.Println(v)
}

evenAndTwoDigits := even.ByValue(func(i int) bool { return i > 9 && i < 100 })
fmt.Println("---even and two digits---")
for v := range evenAndTwoDigits.Values() {
    fmt.Println(v)
}

oddAndTwoDigits := odd.ByValue(func(i int) bool { return i > 9 && i < 100 })
fmt.Println("---odd and two digits---")
for v := range oddAndTwoDigits.Values() {
    fmt.Println(v)
}
// Output: ---even---
//0
//2
//4
//6
//8
//10
//100
//---odd---
//1
//3
//5
//7
//9
//11
//101
//---even and two digits---
//10
//---odd and two digits---
//11

With SliceExtractor.ByValue

s := []string{"go", "iterator", "range over func"}
xt := xtract.FromSlice(s).ByValue(func(v string) bool { return len(v) < 9 })
for v := range xt.Values() {
    fmt.Println(v)
}
// Output: go
//iterator

With SliceExtractor.ByKey

s := []string{"go", "iterator", "range over func"}
xt := xtract.FromSlice(s).ByKey(func(i int) bool { return i > 0 })
for v := range xt.Values() {
    fmt.Println(v)
}
// Output: go
//iterator

With SliceExtractor.ByKeyAndValue

s := []string{"go", "iterator", "range over func"}
xt := xtract.FromSlice(s).ByKeyAndValue(func(i int, v string) bool { return i > 1 && len(v) > 6 })
for v := range xt.Values()
    fmt.Println(v)
}
// Output: range over func

With SliceExtractor.Limit

s := []string{"go", "iterator", "range over func"}
xt := xtract.FromSlice(s).Limit(1)
for v := range xt.Values() {
    fmt.Println(v)
}
// Output: go

With SliceExtractor.Offset

s := []string{"go", "iterator", "range over func"}
xt := xtract.FromSlice(s).Offset(1)
for v := range xt.Values() {
    fmt.Println(v)
}
// Output: iterator
//range over func

With MapExtractor.ByValue

m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
xt := xtract.FromMap(m).ByValue(func(v string) bool { return len(v) < 8 })
for v := range xt.Values() {
    fmt.Println(v)
}
// Output: go

With MapExtractor.ByKey

m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
xt := xtract.FromMap(m).ByKey(func(k string) bool { return strings.Contains(k, " ") })
for v := range xt.Values() {
    fmt.Println(v)
}
// Output: iterator

With MapExtractor.ByKeyAndValue

m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
xt := xtract.FromMap(m).ByKeyAndValue(func(k, v string) bool { return strings.Contains(k, "e") && len(v) < 8 })
for v := range xt.Values() {
    fmt.Println(v)
}
// Output: go

With MapExtractor.Limit

m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
xt := xtract.FromMap(m).Limit(1)

values := make([]string, 0, 1)
for v := range xt.Values() {
    values = append(values, v)
}
fmt.Println(len(values))
// Output: 1

With MapExtractor.Offset

m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
xt := xtract.FromMap(m).Offset(1)

values := make([]string, 0, 1)
for v := range xt.Values() {
    values = append(values, v)
}
fmt.Println(len(values))
// Output: 2

Contributing

Feel free to open a PR or an Issue.

License

xtract released under the MIT License

Documentation

Overview

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
)

func main() {
	s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 100, 101}
	xt := xtract.FromSlice(s)
	even := xt.ByValue(func(i int) bool { return i%2 == 0 })
	odd := xt.ByValue(func(i int) bool { return i%2 != 0 })

	fmt.Println("---even---")
	for v := range even.Values() {
		fmt.Println(v)
	}

	fmt.Println("---odd---")
	for v := range odd.Values() {
		fmt.Println(v)
	}

	evenAndTwoDigits := even.ByValue(func(i int) bool { return i > 9 && i < 100 })
	fmt.Println("---even and two digits---")
	for v := range evenAndTwoDigits.Values() {
		fmt.Println(v)
	}

	oddAndTwoDigits := odd.ByValue(func(i int) bool { return i > 9 && i < 100 })
	fmt.Println("---odd and two digits---")
	for v := range oddAndTwoDigits.Values() {
		fmt.Println(v)
	}
}

Output:

---even---
0
2
4
6
8
10
100
---odd---
1
3
5
7
9
11
101
---even and two digits---
10
---odd and two digits---
11

Index

• type Extractor
  • func FromMap[K comparable, V any](m map[K]V) Extractor[K, V]
  • func FromSlice[V any](s []V) Extractor[int, V]
• type MapExtractor
  • func (x MapExtractor[K, V]) ByKey(condition func(K) bool) Extractor[K, V]
  • func (x MapExtractor[K, V]) ByKeyAndValue(condition func(K, V) bool) Extractor[K, V]
  • func (x MapExtractor[K, V]) ByValue(condition func(V) bool) Extractor[K, V]
  • func (x MapExtractor[K, V]) KeyAndValues() iter.Seq2[K, V]
  • func (x MapExtractor[K, V]) Limit(n int) Extractor[K, V]
  • func (x MapExtractor[K, V]) Offset(n int) Extractor[K, V]
  • func (x MapExtractor[K, V]) Values() iter.Seq[V]
• type SliceExtractor
  • func (x *SliceExtractor[V]) ByKey(condition func(int) bool) Extractor[int, V]
  • func (x *SliceExtractor[V]) ByKeyAndValue(condition func(int, V) bool) Extractor[int, V]
  • func (x *SliceExtractor[V]) ByValue(condition func(V) bool) Extractor[int, V]
  • func (x *SliceExtractor[V]) KeyAndValues() iter.Seq2[int, V]
  • func (x *SliceExtractor[V]) Limit(n int) Extractor[int, V]
  • func (x *SliceExtractor[V]) Offset(n int) Extractor[int, V]
  • func (x *SliceExtractor[V]) Values() iter.Seq[V]

Examples

• Package
• MapExtractor.ByKey
• MapExtractor.ByKeyAndValue
• MapExtractor.ByValue
• MapExtractor.KeyAndValues
• MapExtractor.Limit
• MapExtractor.Offset
• SliceExtractor.ByKey
• SliceExtractor.ByKeyAndValue
• SliceExtractor.ByValue
• SliceExtractor.KeyAndValues
• SliceExtractor.Limit
• SliceExtractor.Offset

Types

type Extractor

type Extractor[K comparable, V any] interface {
	// ByValue filters the values of the collection by their values.
	ByValue(condition func(V) bool) Extractor[K, V]
	// ByKey filters the values of the collection by their keys.
	ByKey(condition func(K) bool) Extractor[K, V]
	// ByKeyAndValue filters the values of the collection by their keys and values.
	ByKeyAndValue(condition func(K, V) bool) Extractor[K, V]
	// Limit limits the number of values to the specified number.
	Limit(n int) Extractor[K, V]
	// Offset skips the specified number of values.
	Offset(n int) Extractor[K, V]
	// Values returns a sequence of values.
	Values() iter.Seq[V]
	// KeyAndValues returns a sequence of key-value pairs.
	KeyAndValues() iter.Seq2[K, V]
}

Extractor provides features to extract values from a collection.

func FromMap

func FromMap[K comparable, V any](m map[K]V) Extractor[K, V]

FromMap returns Extractor for a map.

func FromSlice

func FromSlice[V any](s []V) Extractor[int, V]

FromSlice returns Extractor for a slice.

type MapExtractor

type MapExtractor[K comparable, V any] struct {
	// contains filtered or unexported fields
}

MapExtractor is implementation of Extractor for map.

func (MapExtractor[K, V]) ByKey

func (x MapExtractor[K, V]) ByKey(condition func(K) bool) Extractor[K, V]

ByKey See: Extractor.ByKey

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
	"strings"
)

func main() {
	m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
	xt := xtract.FromMap(m).ByKey(func(k string) bool { return strings.Contains(k, " ") })
	for v := range xt.Values() {
		fmt.Println(v)
	}
}

Output:

iterator

func (MapExtractor[K, V]) ByKeyAndValue

func (x MapExtractor[K, V]) ByKeyAndValue(condition func(K, V) bool) Extractor[K, V]

ByKeyAndValue See: Extractor.ByKeyAndValue

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
	"strings"
)

func main() {
	m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
	xt := xtract.FromMap(m).ByKeyAndValue(func(k, v string) bool { return strings.Contains(k, "e") && len(v) < 8 })
	for v := range xt.Values() {
		fmt.Println(v)
	}
}

Output:

go

func (MapExtractor[K, V]) ByValue

func (x MapExtractor[K, V]) ByValue(condition func(V) bool) Extractor[K, V]

ByValue See: Extractor.ByValue

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
)

func main() {
	m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
	xt := xtract.FromMap(m).ByValue(func(v string) bool { return len(v) < 8 })
	for v := range xt.Values() {
		fmt.Println(v)
	}
}

Output:

go

func (MapExtractor[K, V]) KeyAndValues

func (x MapExtractor[K, V]) KeyAndValues() iter.Seq2[K, V]

KeyAndValues See: Extractor.KeyAndValues

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
	"strings"
)

func main() {
	m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
	xt := xtract.FromMap(m).ByKey(func(k string) bool { return strings.Contains(k, " ") })

	for k, v := range xt.KeyAndValues() {
		fmt.Printf("%s: %s\n", k, v)
	}
}

Output:

design pattern: iterator

func (MapExtractor[K, V]) Limit

func (x MapExtractor[K, V]) Limit(n int) Extractor[K, V]

Limit See: Extractor.Limit

NOTE: The order of the values is not guaranteed.

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
)

func main() {
	m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
	xt := xtract.FromMap(m).Limit(1)

	values := make([]string, 0, 1)
	for v := range xt.Values() {
		values = append(values, v)
	}
	fmt.Println(len(values))
}

Output:

1

func (MapExtractor[K, V]) Offset

func (x MapExtractor[K, V]) Offset(n int) Extractor[K, V]

Offset See: Extractor.Offset

NOTE: The order of the values is not guaranteed.

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
)

func main() {
	m := map[string]string{"language": "go", "design pattern": "iterator", "implementation": "range over func"}
	xt := xtract.FromMap(m).Offset(1)

	values := make([]string, 0, 1)
	for v := range xt.Values() {
		values = append(values, v)
	}
	fmt.Println(len(values))
}

Output:

2

func (MapExtractor[K, V]) Values

func (x MapExtractor[K, V]) Values() iter.Seq[V]

Values See: Extractor.Values

type SliceExtractor

type SliceExtractor[V any] struct {
	// contains filtered or unexported fields
}

SliceExtractor is implementation of Extractor for slice.

func (*SliceExtractor[V]) ByKey

func (x *SliceExtractor[V]) ByKey(condition func(int) bool) Extractor[int, V]

ByKey See: Extractor.ByKey

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
)

func main() {
	s := []string{"go", "iterator", "range over func"}
	xt := xtract.FromSlice(s).ByKey(func(i int) bool { return i > 0 })
	for v := range xt.Values() {
		fmt.Println(v)
	}
}

Output:

iterator
range over func

func (*SliceExtractor[V]) ByKeyAndValue

func (x *SliceExtractor[V]) ByKeyAndValue(condition func(int, V) bool) Extractor[int, V]

ByKeyAndValue See: Extractor.ByKeyAndValue

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
)

func main() {
	s := []string{"go", "iterator", "range over func"}
	xt := xtract.FromSlice(s).ByKeyAndValue(func(i int, v string) bool { return i > 1 && len(v) > 6 })
	for v := range xt.Values() {
		fmt.Println(v)
	}
}

Output:

range over func

func (*SliceExtractor[V]) ByValue

func (x *SliceExtractor[V]) ByValue(condition func(V) bool) Extractor[int, V]

ByValue See: Extractor.ByValue

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
)

func main() {
	s := []string{"go", "iterator", "range over func"}
	xt := xtract.FromSlice(s).ByValue(func(v string) bool { return len(v) < 9 })
	for v := range xt.Values() {
		fmt.Println(v)
	}
}

Output:

go
iterator

func (*SliceExtractor[V]) KeyAndValues

func (x *SliceExtractor[V]) KeyAndValues() iter.Seq2[int, V]

KeyAndValues See: Extractor.KeyAndValues

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
)

func main() {
	s := []string{"go", "iterator", "range over func"}
	xt := xtract.FromSlice(s)
	for k, v := range xt.KeyAndValues() {
		fmt.Printf("%d: %s\n", k, v)
	}
}

Output:

0: go
1: iterator
2: range over func

func (*SliceExtractor[V]) Limit

func (x *SliceExtractor[V]) Limit(n int) Extractor[int, V]

Limit See: Extractor.Limit

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
)

func main() {
	s := []string{"go", "iterator", "range over func"}
	xt := xtract.FromSlice(s).Limit(1)
	for v := range xt.Values() {
		fmt.Println(v)
	}
}

Output:

go

func (*SliceExtractor[V]) Offset

func (x *SliceExtractor[V]) Offset(n int) Extractor[int, V]

Offset See: Extractor.Offset

Example

package main

import (
	"fmt"
	"github.com/miyamo2/xtract"
)

func main() {
	s := []string{"go", "iterator", "range over func"}
	xt := xtract.FromSlice(s).Offset(1)
	for v := range xt.Values() {
		fmt.Println(v)
	}
}

Output:

iterator
range over func

func (*SliceExtractor[V]) Values

func (x *SliceExtractor[V]) Values() iter.Seq[V]

Values See: Extractor.Values