merged current state

package concurrency

// Sequence is a channel for int streams.

type Sequence chan int

// SequenceOf returns a stream of numbers of the supplied value.

func SequenceOf(v int) Sequence {

	s := make(Sequence)

	go func(x int) {

		defer close(s)

		for {

			s <- x

		}

	}(v)

	return s

}

// Take a limited number of items from a producer.

func (s Sequence) Take(c int) []int {

	r := []int{}

	i := 0

	for x := range s {

		if !(i < c) {

			break

		}

		r = append(r, x)

		i++

	}

	return r

}

// Equal checks two int-slices for equality.

func Equal(a, b []int) bool {

	if len(a) != len(b) {

		return false

	}

	for i, v := range a {

		if v != b[i] {

			return false

		}

	}

	return true

}

package concurrency

import (

	"sync"

	"testing"

)

func TestAnything(t *testing.T) {

func TestBasic(t *testing.T) {

	done := make(chan bool)

	go func(done chan bool) {

		t.Log("Hello from goroutine.")

		done <- true

	}(done)

	<-done

	t.Log("goroutine is done.")

}

func TestSequenceVeryPrimitive(t *testing.T) {

	var wg sync.WaitGroup

	wg.Add(1)

	go func() {

		defer wg.Done()

		t.Log("Hello from goroutine.")

	}()

	wg.Wait()

	t.Log("goroutine is done.")

}

func TestSequencePrimitive(t *testing.T) {

	t.Log("TestSequencePrimitive() started.")

	defer t.Log("TestSequencePrimitive() done.")

	seq := make(chan int)

	t.Log("chan int created")

	go func(n int, c chan int) {

		t.Log("TestSequencePrimitive(): anon goroutine started")

		defer t.Log("TestSequencePrimitive(): anon goroutine finished")

		for i := 0; i < n; i++ {

			c <- i

			t.Logf("Pushed: %d", i)

		}

		close(c)

	}(5, seq)

	for s := range seq {

		t.Logf("Sequence: %d", s)

	}

}

func TestSliceEquality(t *testing.T) {

	for _, d := range []struct {

		a, b []int

		r    bool

	}{

		{a: []int{}, b: []int{}, r: true},

		{a: []int{}, b: []int{1}, r: false},

		{a: []int{1}, b: []int{}, r: false},

		{a: []int{1}, b: []int{1}, r: true},

		{a: []int{1, 2}, b: []int{1, 2}, r: true},

		{a: []int{1, 2, 3}, b: []int{1, 2, 3}, r: true},

		{a: []int{1, 2, 3}, b: []int{1, 2}, r: false},

		{a: []int{1, 2}, b: []int{1, 2, 3}, r: false},

		{a: []int{1, 2, 3}, b: []int{1, 2, 4}, r: false},

		{a: []int{1, 2, 4}, b: []int{1, 2, 3}, r: false},

	} {

		if r := Equal(d.a, d.b); r != d.r {

			t.Errorf("Equal(%#v, %#v) is %t, expected %t", d.a, d.b, r, d.r)

		}

	}

}

func TestSequenceFunctions(t *testing.T) {

	l := []int{1, 1, 1, 1, 1}

	if r := SequenceOf(1).Take(5); !Equal(r, l) {

		t.Errorf("SequenceOf(1).Take(5) is %#v, expected %#v", r, l)

	}

}

package currying

import "fmt"

const (

	formatGreeter  = "Hello, %s!"

	defaultGreeter = "World"

)

func greeter(text ...string) func() string {

	var name string

	switch len(text) {

	case 1:

		name = text[0]

	default:

		name = defaultGreeter

	}

	f := func() string {

		return fmt.Sprintf(formatGreeter, name)

	}

	return f

}

package currying

import (

	"strings"

	"testing"

)

func TestCurrying0(t *testing.T) {

	world := greeter()

	boris := greeter("Boris")

	t.Logf("world(): %s", world())

	t.Logf("boris(): %s", boris())

}

func TestCurrying1(t *testing.T) {

	f1 := func(x int) func(int) int {

		c := func(y int) int {

			return x * y

		}

		return c

	}(5)

	t.Logf("f1(3) is %d", f1(3))

}

func TestArguemnts1(t *testing.T) {

	f1 := func(args ...string) func(...string) string {

		var sb strings.Builder

		for i, a := range args {

			if i > 0 {

				sb.WriteString(" ")

			}

			sb.WriteString(a)

		}

		x := sb.String()

		s := func(vals ...string) string {

			var tb strings.Builder

			tb.WriteString(x)

			tb.WriteString(" : ")

			for j, b := range vals {

				if j > 0 {

					tb.WriteString(" ")

				}

				tb.WriteString(b)

			}

			return tb.String()

		}

		return s

	}("A", "B", "C")

	t.Logf("f1() is \"%s\"", f1("X", "Y", "Z"))

}

module repositories.muehmer.net/bsmrgo/playground

go 1.13

go 1.14

require golang.org/x/crypto v0.0.0-20200117160349-530e935923ad

require golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073