iox

func NewReaderFromBytes ¶

func NewReaderFromBytes[T any](r io.Reader) func(f decoderFn) Reader[T]

NewReaderFromBytes creates a new T reader from an io.Reader and Decoder. It simply reads bytes from 'r', decodes them, and passes them along to the caller. As such, the decoder must match the encoder used to create the bytes. If 'r' is nil, an empty Reader is returned; if 'f' is nil, the decoder is set to gob.NewDecoder. Example:

// Used as io.Reader
b := bytes.NewBuffer(nil)

// Using json encoder, so the decoder has to be json in NewReaderFromBytes
json.NewEncoder(b).Encode("test1")
json.NewEncoder(b).Encode("test2")

r := NewReaderFromBytes[string](b)(
	func(r io.Reader) Decoder {
		return json.NewDecoder(r)
	},
)

t.Log(r.Read(context.Background())) // "test1" <nil>
t.Log(r.Read(context.Background())) // "test2" <nil>
t.Log(r.Read(context.Background())) // "", io.EOF

func NewReaderWithFilterFn ¶

func NewReaderWithFilterFn[T any](r Reader[T]) func(f func(v T) bool) Reader[T]

NewReaderWithFilterFn returns a reader where filter 'f' is applied on values coming from reader 'r', removing/skipping values when f(v) == false.

func NewReaderWithMapperFn ¶

func NewReaderWithMapperFn[T, U any](r Reader[T]) func(f func(T) U) Reader[U]

NewReaderWithMapperFn returns a reader where mapper 'f' is applied on values coming from reader 'r'.

func NewWriterFromBytes ¶

func NewWriterFromBytes[T any](w Writer[T]) func(f decoderFn) io.Writer

NewWriterFromBytes returns an io.Writer which accepts bytes, decodes them using the given decoder, and then writes them to 'w'. If 'w' is nil, an emtpy io.Writer is returned; if 'f' is nil, the decoder is set to gob.NewDecoder. Example:

// Writes simply logs values.
vw := WriterImpl[int]{
	Impl: func(ctx context.Context, v int) error {
		t.Log(v)
		return nil
	},
}

// io.Writer
bw := NewWriterFromBytes(vw)(
	func(r io.Reader) Decoder {
		return json.NewDecoder(r)
	},
)

// Logs "9"
json.NewEncoder(bw).Encode(9)

func NewWriterFromValues ¶

func NewWriterFromValues[T any](w io.Writer) func(f encoderFn) Writer[T]

NewWriterFromValues returns a Writer which accepts values, encodes them using the given encoder, and then writes them to 'w'. If 'w' is nil, an empty Writer is returned; if 'f' is nil, the encoder is set to gob.NewEncoder. Example:

// Defining our io.Writer to rcv the data + encoding method.
b := bytes.NewBuffer(nil)
f := func(w io.Writer) Encoder { return json.NewEncoder(w) }
w := NewWriterFromValues[int](b)(f)

// Write values, they are encoded and passed to 'b'. Err handling ignored.
w.Write(nil, 2)
w.Write(nil, 3)

// We'll use these to read what's in 'b'.
dec := json.NewDecoder(b)
val := 0

t.Log(dec.Decode(&val), val) // <nil> 2
t.Log(dec.Decode(&val), val) // <nil> 3
t.Log(dec.Decode(&val), val) // EOF 3

func NewWriterWithFilterFn ¶

func NewWriterWithFilterFn[T any](w Writer[T]) func(f func(T) bool) Writer[T]

NewWriterWithFilterFn returns a writer which writes to 'w' if incoming values are not filtered out with 'f'. If 'w' is nil, an empty WriterImpl[T]{} is returned; if 'f' is nil, 'w' is returned. Example:

// Writes which logs values through 't.Log'.
logWriter := WriterImpl[int]{}
logWriter.Impl = func(_ context.Context, v int) error { t.Log(v); return nil }

// Writer with filter which filters out anything below 2.
w := NewWriterWithFilterFn(logWriter)(func(v int) bool { return v >= 2 })
w.Write(nil, 1) // logWriter logs: <nothing>
w.Write(nil, 2) // logWriter logs: 2
w.Write(nil, 3) // logWriter logs: 3

func NewWriterWithMapperFn ¶

func NewWriterWithMapperFn[T, U any](w Writer[U]) func(f func(T) U) Writer[T]

NewWriterWithMapperFn returns a writer which passes values to 'f', of which the returned values are forwarded to 'w'. If either 'w' or 'f' is nil, an empty WriterImpl[T]{} is returned. Example:

// Writes which logs values through 't.Log'.
logWriter := WriterImpl[int]{}
logWriter.Impl = func(_ context.Context, v int) error { t.Log(v); return nil }

// Writer with adds +1 to each element.
w := NewWriterWithMapperFn[int](logWriter)(func(v int) int { return v + 1 })
w.Write(nil, 1) // logWriter logs: 2
w.Write(nil, 2) // logWriter logs: 3
w.Write(nil, 3) // logWriter logs: 4

func ReaderIntoBytes ¶

func ReaderIntoBytes[T any](r Reader[T]) func(f encoderFn) io.Reader

ReaderIntoBytes creates an io.Reader from a Reader and Encoder. It simply reads values from 'r', encodes them, and passes them along to the caller. As such, when decoding values from the returned io.Reader one should use a decoder which matches the encoder passed here. If 'r' is nil, an empty (not nil) io.Reader is returned; if 'f' is nil, the encoder is set to gob.NewEncoder. Example:

vr := NewReaderFrom("test1", "test2")
br := ReaderIntoBytes(vr)(func(w io.Writer) Encoder { return json.NewEncoder(w) })

// Instantly pass it to a decoder just so we may log out the values.
dec := json.NewDecoder(br)
val := ""

t.Log(dec.Decode(&val), val) // <nil>, "test1"
t.Log(dec.Decode(&val), val) // <nil>, "test2"
t.Log(dec.Decode(&val), val) // EOF, ""

func ReaderIntoChan ¶

func ReaderIntoChan[T any](r Reader[T]) <-chan ErrWrapped[T]

ReaderIntoChan returns a chan which is fed the contents of 'r' from a new goroutine. The error in the ErrWrapped[T] will not contain io.EOF. Example:

r := NewReaderFrom(1, 2, 3)
for ew := range ReaderIntoChan(r) {
	// Prints {<nil> 1} on 1st iteration.
	// Prints {<nil> 2} on 2nd iteration.
	// Prints {<nil> 3} on 3rd iteration.
	t.Log(ew)
}

func ReaderIntoGenerator ¶

func ReaderIntoGenerator[T any](r Reader[T]) func() (val ErrWrapped[T], cont bool)

ReaderIntoGenerator returns a generator which reads from 'r'. The generator will stop on the first error and the ErrWrapped[T] will not contain io.EOF. Example:

r := NewReaderFrom(1, 2, 3)
g := ReaderIntoGenerator(r)

for ev, ok := g(); ok; ev, ok = g() {
	// Prints {<nil> 1} on 1st iteration.
	// Prints {<nil> 2} on 2nd iteration.
	// Prints {<nil> 3} on 3rd iteration.
	t.Log(ev)
}

func ReaderIntoMapKFn ¶

func ReaderIntoMapKFn[K comparable, V any](r Reader[K]) func(f func(K) V) (map[K]V, error)

IntoMapKFn returns a func which creates a map[K]V using the given reader 'r'. It does so by reading all elements of 'r' and storing them as keys. Vals are defined with the given func 'f'. The error, if any, will not be io.EOF Example:

r := NewReaderFrom(1, 2, 3)
m, err := ReaderIntoMapKFn[int, int](r)(
	func(key int) (val int) {
		val = key + 1
		return
	},
)

t.Log(m, err)	// map[1:2 2:3 3:4] <nil>

func ReaderIntoMapVFn ¶

func ReaderIntoMapVFn[K comparable, V any](r Reader[V]) func(f func(V) K) (map[K]V, error)

IntoMapVFn returns a func which creates a map[K]V using the given reader 'r'. It does so by reading all elements of 'r' and storing them as values for keys that are defined using the given func 'f'. Example:

r := NewReaderFrom(1, 2, 3)
m, err := ReaderIntoMapVFn[int, int](r)(
	func(key int) (val int) {
		val = key - 1
		return
	},
)

t.Log(m, err) // map[0:1, 1:2, 2:3] <nil>

func ReaderIntoSlice ¶

func ReaderIntoSlice[T any](r Reader[T]) (s []T, err error)

ReaderIntoSlice reads all values from 'r' and returns them in a slice. Note that the error, if any, will not be io.EOF.