genkami / dogs Goto Github PK

// FizzBuzzFunctional
//
// https://web.archive.org/web/20130511210903/http://dave.fayr.am/posts/2012-10-4-finding-fizzbuzz.html
// https://medium.com/@iopguy/fizzbuzz-can-finally-be-implemented-in-stable-rust-87649a882f2d
// https://www.parsonsmatt.org/2016/02/27/an_elegant_fizzbuzz.html
func FizzBuzzFunctional(n int) string {
	m := monoid.ForString("").
		Append(monoid.ForString("Fizz").Filtered(func() bool {
			return n%3 == 0
		})).
		Append(monoid.ForString("Buzz").Filtered(func() bool {
			return n%5 == 0
		}))

	return m.UnwrapOr(strconv.Itoa(n))
}

package monoid

type OptionString struct {
	op option.String
}

// SomeString wraps the s into an optional string.
func SomeString(s string) OptionString {
	return OptionString{
		op: option.SomeString(s),
	}
}

// NoneString returns an empty optional string.
func NoneString() OptionString {
	return OptionString{
		op: option.NoneString(),
	}
}

func (m OptionString) Empty() OptionString {
	return NoneString()
}

func (m OptionString) Append(other OptionString) OptionString {
	switch {
	case m == NoneString():
		return other
	case other == NoneString():
		return m
	default:
		return SomeString(m.op.Append(other.op).UnwrapOrDefault())
	}
}

func (m OptionString) Filtered(fn func() bool) OptionString {
	if fn() {
		return m
	}

	return NoneString()
}

func (m OptionString) UnwrapOr(s string) string {
	return m.op.UnwrapOr(s)
}

func TestOptionString(t *testing.T) {
	t.Parallel()

	// A set S equipped with a binary operation S × S → S,
	// which we will denote •, is a monoid if it satisfies the following two axioms:

	t.Run("it has valid identity", func(t *testing.T) {
		t.Parallel()

		m := monoid.SomeString("test")

		// There exists an element e in S such that for every element a in S,
		// the equations e • a = a and a • e = a hold.
		AssertEqual(t, m, m.Append(m.Empty()))
		AssertEqual(t, m.Empty().Append(m), m.Append(m.Empty()))
	})

	t.Run("it has valid associativity", func(t *testing.T) {
		t.Parallel()

		a := monoid.SomeString("foo")
		b := monoid.SomeString("bar")
		c := monoid.NoneString()

		// For all a, b and c in S, the equation (a • b) • c = a • (b • c) holds.
		AssertEqual(t, a.Append(b).Append(c), a.Append(b.Append(c)))
	})
}

func FizzBuzzFunctional(n int) string {
	fizz := func(n int) bool {
		return n%3 == 0
	}

	buzz := func(n int) bool {
		return n%5 == 0
	}

	filters := foldable.RuleFoldable{
		monoid.ForFizzBuzzPredicate(fizz, "Fizz"),
		monoid.ForFizzBuzzPredicate(buzz, "Buzz"),
	}

	rules := fold(filters, monoid.NewEmptyFizzBuzzRuleset()) // a monoid which combines all the filters together

	return monoid.FromStringOption(strconv.Itoa(n), rules(n))
}

// fold :: (Foldable t, Monoid m) => t m -> m
func fold(filters foldable.RuleFoldable, m monoid.FizzBuzzRuleset) monoid.FizzBuzzRuleset {
	rules := filters.Foldl(filters.Init(), func(result foldable.T, next foldable.T) foldable.T {
		rule, ok := next.(func(int) monoid.OptionString)
		mustOk(ok, "cannot cast result foldable.T to func(int) monoid.OptionString")

		m = m.Append(rule)

		return m
	})

	ruleSet, ok := rules.(monoid.FizzBuzzRuleset)
	mustOk(ok, "cannot cast result foldable.T to monoid.FizzBuzzRuleset")

	return ruleSet
}

func mustOk(ok bool, msg string) {
	if !ok {
		panic(msg)
	}
}

func main() {
	monoid := option.DeriveMonoid[string](algebra.DeriveAdditiveSemigroup[string]())
	fizzBuzz := func(i int) string {
		fizz := option.Filter(option.Some[string]("Fizz"), func(_ string) bool { return i%3 == 0 })
		buzz := option.Filter(option.Some[string]("Buzz"), func(_ string) bool { return i%5 == 0 })
		return option.UnwrapOr(monoid.Combine(fizz, buzz), fmt.Sprint(i))
	}
	it := iterator.Map(iterator.Range[int](1, 15), fizzBuzz)
	iterator.ForEach(it, func(s string) { fmt.Println(s) })
}

type FizzBuzzPredicate func(num int) bool
type FizzBuzzRule func(n int) option.String

func Rule(p FizzBuzzPredicate, s string) FizzBuzzRule {
	return func(n int) option.String {
		if p(n) {
			return option.Some(s)
		}

		return option.NoneString()
	}
}

func FizzBuz(n int) string {
	fizz := func(n int) bool {
		return n%3 == 0
	}

	buzz := func(n int) bool {
		return n%5 == 0
	}

	// rules should be a foldable of monoids
	rules := []FizzBuzzRule{
		Rule(fizz, "Fizz"),
		Rule(buzz, "Buzz"),
	}

	// ruleSet is a monoid, which is a function by its nature: monoid[FizzBuzzRule]
	// Written in a move verbose way it is the same as: monoid[ func(n int) option.String].
        // see https://blog.ploeh.dk/2017/11/06/function-monoids/
	ruleSet := fold(rules)

	return ruleSet(n).UnwrapOr(strconv.ItoA(i))
}

// fold :: (Foldable t, Monoid m) => t m -> m
func Fold(filters Foldable) monoid[FizzBuzzFilter] {
  // fold over filters and turn them into a monoid
}