Tag Archives: monoids

Typeclasses in Java 8

2014/11/14 domfox

Java 8 doesn’t have implicits (for which much thanks will be given in some quarters), which makes it difficult to create typeclasses in a Scala(z)ish fashion. This is one possible compromise.

public class MonoidTest {

    public interface Monoid<T> {
        public static <T> Function<Monoid<T>, Optional<T>> sum(Collection<T> items) {
            return monoid -> {
                Iterator<T> iter = items.iterator();
                if (!iter.hasNext()) {
                    return Optional.empty();
                }
                T accumulator = iter.next();
                while (iter.hasNext()) {
                    accumulator = monoid.append(accumulator, iter.next());
                }
                return Optional.of(accumulator);
            };
        }

        T append(T first, T second);
    }

    public interface IntegerMonoid {
        static <R> R run(Function<Monoid<Integer>, R> f) {
            return f.apply((a, b) -> a + b);
        }
    }

    public interface StringMonoid {
        static <R> R run(Function<Monoid<String>, R> f) {
            return f.apply((a, b) -> a + b);
        }
    }

    @Test public void sums() {
        Optional<Integer> sumOfInts = IntegerMonoid.run(Monoid.sum(Arrays.asList(1, 2, 3)));
        Optional<String> sumOfStrings = StringMonoid.run(Monoid.sum(Arrays.asList("a", "b", "c")));

        assertThat(sumOfInts.get(), equalTo(6));
        assertThat(sumOfStrings.get(), equalTo("abc"));
    }
}

public class MonoidTest {

public interface Monoid<T> {

public static <T> Function<Monoid<T>, Optional<T>> sum(Collection<T> items) {

return monoid -> {

Iterator<T> iter = items.iterator();

if (!iter.hasNext()) {

return Optional.empty();

}

T accumulator = iter.next();

while (iter.hasNext()) {

accumulator = monoid.append(accumulator, iter.next());

}

return Optional.of(accumulator);

};

}

T append(T first, T second);

}

public interface IntegerMonoid {

static <R> R run(Function<Monoid<Integer>, R> f) {

return f.apply((a, b) -> a + b);

}

public interface StringMonoid {

static <R> R run(Function<Monoid<String>, R> f) {

return f.apply((a, b) -> a + b);

}

@Test public void sums() {

Optional<Integer> sumOfInts = IntegerMonoid.run(Monoid.sum(Arrays.asList(1, 2, 3)));

Optional<String> sumOfStrings = StringMonoid.run(Monoid.sum(Arrays.asList("a", "b", "c")));

assertThat(sumOfInts.get(), equalTo(6));

assertThat(sumOfStrings.get(), equalTo("abc"));

}

scala, Uncategorized

Monoidal FizzBuzz In Scala

2014/05/25 domfox

I am truly sorry…

import scalaz._

object Main {

  case class FizzBuzz(elems: String*)

  implicit object FizzBuzzMonoid extends Monoid[FizzBuzz] {
    override def zero = FizzBuzz()
    override def append(f1: FizzBuzz, f2: => FizzBuzz): FizzBuzz = FizzBuzz(f1.elems ++ f2.elems :_*)
  }

  implicit object FuzzBuzzShow extends Show[FizzBuzz] {
    override def shows(f1: FizzBuzz): String = f1.elems.mkString("")
  }

  def interpreter(name: String, cond: Int => Boolean): Int => FizzBuzz = i =>
    if (cond(i)) FizzBuzz(name) else FizzBuzzMonoid.zero

  val fizz = interpreter("fizz", (i: Int) => (i % 3) == 0)
  val buzz = interpreter("buzz", (i: Int) => (i % 5) == 0)

  def fizzBuzzer[T](interpreters: (Int => T)*)(implicit m: Monoid[T], s: Show[T]): Int => String = i => {
    val interpreted: T = interpreters.map(_.apply(i)).fold(m.zero)(m.append(_, _))
    if (interpreted == m.zero) i.toString else s.shows(interpreted)
  }

  def main(args: Array[String]) {
    (1 to 100).map(fizzBuzzer(fizz, buzz)).foreach(println)
  }

}

import scalaz._

object Main {

case class FizzBuzz(elems: String*)

implicit object FizzBuzzMonoid extends Monoid[FizzBuzz] {

override def zero = FizzBuzz()

override def append(f1: FizzBuzz, f2: => FizzBuzz): FizzBuzz = FizzBuzz(f1.elems ++ f2.elems :_*)

}

implicit object FuzzBuzzShow extends Show[FizzBuzz] {

override def shows(f1: FizzBuzz): String = f1.elems.mkString("")

}

def interpreter(name: String, cond: Int => Boolean): Int => FizzBuzz = i =>

if (cond(i)) FizzBuzz(name) else FizzBuzzMonoid.zero

val fizz = interpreter("fizz", (i: Int) => (i % 3) == 0)

val buzz = interpreter("buzz", (i: Int) => (i % 5) == 0)

def fizzBuzzer[T](interpreters: (Int => T)*)(implicit m: Monoid[T], s: Show[T]): Int => String = i => {

val interpreted: T = interpreters.map(_.apply(i)).fold(m.zero)(m.append(_, _))

if (interpreted == m.zero) i.toString else s.shows(interpreted)

}

def main(args: Array[String]) {

(1 to 100).map(fizzBuzzer(fizz, buzz)).foreach(println)

}

Java 8

Monoidal FizzBuzz

2014/05/23 domfox

package com.codepoetics.fizzbuzz.monoidal;

import java.util.function.Function;

public class MonoidalFizzBuzz<T, I extends Interpreter<T>, M extends Monoid<T>, R extends Representation<T>> implements Function<Integer, String> {

    private final I interpreter;
    private final M monoid;
    private final R representable;

    public MonoidalFizzBuzz(I interpreter, M monoid, R representable) {
        this.interpreter = interpreter;
        this.monoid = monoid;
        this.representable = representable;
    }

    @Override
    public String apply(Integer integer) {
        T product = interpreter.interpret(integer)
                               .stream()
                               .reduce(monoid.zero(), monoid::product);
        return product.equals(monoid.zero()) ? integer.toString() : representable.represent(product);
    }

    public static void main(String[] argv) {
        Function<Integer, String> mfb = new MonoidalFizzBuzz<>(
                FizzBuzz.interpreter,
                FizzBuzz.monoid,
                FizzBuzz.representation);

        for (int i=1; i<=100; i++) {
            System.out.println(mfb.apply(i));
        }
    }
}

package com.codepoetics.fizzbuzz.monoidal;

import java.util.function.Function;

public class MonoidalFizzBuzz<T, I extends Interpreter<T>, M extends Monoid<T>, R extends Representation<T>> implements Function<Integer, String> {

private final I interpreter;

private final M monoid;

private final R representable;

public MonoidalFizzBuzz(I interpreter, M monoid, R representable) {

this.interpreter = interpreter;

this.monoid = monoid;

this.representable = representable;

}

@Override

public String apply(Integer integer) {

T product = interpreter.interpret(integer)

.stream()

.reduce(monoid.zero(), monoid::product);

return product.equals(monoid.zero()) ? integer.toString() : representable.represent(product);

}

public static void main(String[] argv) {

Function<Integer, String> mfb = new MonoidalFizzBuzz<>(

FizzBuzz.interpreter,

FizzBuzz.monoid,

FizzBuzz.representation);

for (int i=1; i<=100; i++) {

System.out.println(mfb.apply(i));

}

See the whole thing on github.

poetix

Tag Archives: monoids

Typeclasses in Java 8

Monoidal FizzBuzz In Scala

Monoidal FizzBuzz

opting out of the ordinary human real