juan_gandhi: (Default)
scala> implicit def const[T](x: => T): Any => T = _ => x
const: [T](x: => T)Any => T

scala> def dome(y: Int => String) = y(42)
dome: (y: Int => String)String

scala> dome(_ + "xxx")
res1: String = 42xxx

scala> dome("do me")
res2: String = do me
juan_gandhi: (Default)

Actually, Runar is not always exactly right, but he's close. But Tim, his former coworker... do you think it makes sense? To me it's some kind of alchemy. Almost there, but not there.
juan_gandhi: (Default)
"total functional programming is not Turing-complete."

Kind of almost obvious. But you can tell all those haskellers that your Turing machine (unversal, of course) is a better busy beaver than their unreadable code. 
juan_gandhi: (Default)
Turned out all the delays were caused by two things:
- reading the files in parallel, as opposed to sequential (don't ask, will investigate)
- parallel output to stdout, instead of linearising the output. That was obviously my mistake, have to group the data, not mix them.

Now it's still 3 times faster than FP version. Got a suspicion that in JVM method dispatch is much heavier than plain if/else. It should be. But it's the staple of FP, never use booleans or ifs, but dispatch by the type. So, well... have to investigate.
juan_gandhi: (Default)

More Haskell bashing.

"Haskell is so good that if a functor does not have a free monad, it cannot be written in Haskell". Which is funny. Something like Haskell version of Church thesis.
juan_gandhi: (Default)
As promised (to myself), started writing the "three myphs of FP".

 - part 1, "not every monad is strong" 
juan_gandhi: (VP)

Domain-Specific Languages of Mathematics: Presenting
Mathematical Analysis Using Functional Programming
juan_gandhi: (VP)
 * A marker interface for classes that have no data inside
 * Meaning, two instances are equal if they have the same class
public interface JustCode extends Serializable {
public interface Function<X, Y> extends JustCode {
  Y apply(X x);
public interface Function2<X, Y, Z> extends JustCode {
  Z apply(X x, Y y);
  public int hashCode(JustCode x) {
    return x == null ? 0 : x.getClass().hashCode();

  public boolean equal(JustCode x, JustCode y) {
    return x == null ? y == null : y != null && x.getClass() == y.getClass();

No shit, just discovered this kind of data.
You've probably noticed that I kind of prefer S to OOP. :)
juan_gandhi: (VP)
  // test how file can be unfolded into multiple columns
  public void testUnfoldingColumn() throws IOException {
    // Here's the file
    File file = getFile("smalldata/chicago/chicagoAllWeather.csv");

    // Get all its lines
    final List<String> lines = Files.readLines(file, Charset.defaultCharset());

    // Store it in H2O, with typed column as a wrapper (core H2O storage is a type-unaware Vec class)
    Column<String> source = willDrop(Strings.newColumn(lines));

    // Produce another (virtual) column that stores a list of strings as a row value
    Column<List<String>> split = new UnfoldingColumn<>(Functions.splitBy(","), source, 10);

    // now check that we have the right data
    for (int i = 0; i < lines.size(); i++) {
      // Since we specified width (10), the rest of the list is filled with nulls; have to ignore them.
      // It's important to have the same width for the whole frame..
      String actual = StringUtils.join(" ", Predicate.NOT_NULL.filter(split.apply(i)));
      // So, have we lost any data?
      assertEquals(lines.get(i).replaceAll("\\,", " ").trim(), actual);
juan_gandhi: (VP)
Вот какую хуйню приходится пока писать на работе:

  public static  Iterable<Y> map(Iterable<X> xs, Function<X,Y> f) {
    List<Y> ys = new LinkedList<Y>();
    for (X x : xs) ys.add(f.apply(x));
    return ys;
  interface Option<T> extends Iterable<T> {
    T get();
// etc


Oct. 4th, 2016 08:17 am
juan_gandhi: (VP)
For endomorphisms, eval: X × XX → X can be rewritten as X(1+X) → X, or, in code, as (Option[X] → X) → X - almost like Y in ML.

Just can't figure out the consequences out of this simple representation.
juan_gandhi: (VP)
  def ×[A,B,C,D](f:A=>C)(g:B=>D): (A,B) => (C,D) = (a,b) => (f(a), g(b))

Big deal, right?

got it

May. 4th, 2016 04:54 am
juan_gandhi: (VP)
Stroustrup said he does not know how come functional programming failed.

I don't know if it failed, but I see now how come it's so hard for the people.

Programming people, en masse, are clueless regarding what a function is. Seriously.
juan_gandhi: (VP)
Every time you write
val myName = props.get("Name") orElse ""
you are introducing an algebra over Option monad.
Even if you have no clue what an algebra or a monad is.

Same goes for catching exceptions and returning a "default value". Now you have a category of algebras over the exception monad.

This category is called Eilenberg-Moore category for the monad. There's a couple of adjunctions of course.

Kleisli also provides a couple of adjunctions.

All possible adjunctions make a category, where Kleisli is an initial object and Eilenberg-Moore is a terminal object.

Nlab says that Kleisli can actually be embedded into Eilenberg-Moore.

Meaning, guys, you don't need to invent "default values"; just use Option[T]. Whatever. Probably hard to explain to people that are thinking in terms of saving computer memory on string instantiation.


juan_gandhi: (Default)

October 2017

1 2 3 45 6 7
8 910 11 12 13 14
15 16 17 18 19 20 21


RSS Atom

Most Popular Tags

Style Credit

Expand Cut Tags

No cut tags
Page generated Oct. 22nd, 2017 06:19 am
Powered by Dreamwidth Studios