joost-de-vries

import scala.language.higherKinds
import play.api.libs.functional.InvariantFunctor
 
object JsonCombinatorUtil {
/** workaround voor issue dat json combinators niet kunnen omgaan met case classes met 1 veld
* zie http://stackoverflow.com/questions/15042205/how-to-serialize-deserialize-case-classes-to-from-json-in-play-2-1 */
implicit class FormatBuilder[M[_], A](o: M[A]) {
 def build[B](f1: A => B, f2: B => A)(implicit fu: InvariantFunctor[M]) =
  fu.inmap[A, B](o, f1, f2)
 }

joost-de-vries

a semigroup is addable

a monoid is foldRightable or aggregatable
(ie addable, zero)

a functor is mappable
 
a monad is chainable or flatmappable

strong suit of monads:

joost-de-vries

[error] /home/vagrant/wendwet/core/src/main/scala/annoteren/model/objectrollen.scala:78: overloaded method value format with alternatives:
[error]   [T(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)](w: play.api.libs.json.Writes[T(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)])(implicit r: play.api.libs.json.Reads[T(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)])play.api.libs.json.OFormat[T(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)] <and>
[error]   [T(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)(in method format)](r: play.api.libs.json.Reads[

joost-de-vries

#!/bin/bash
#
# =========================================================================
# Copyright 2014 Rado Buransky, Dominion Marine Media
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0

joost-de-vries

object foldfun {

  def foldr[A, B](f: A => B => B)(b: B)(s: Seq[A]): B = s match {
    case Nil => b
    case a :: as =>
      f(a)(foldr(f)(b)(as))
  }                                               //> foldr: [A, B](f: A => (B => B))(b: B)(s: Seq[A])B

  foldr { a: String => b: Int => a.toInt * b.toInt }(7)(Seq("1", "2", "3"))
                                                  //> res0: Int = 42

joost-de-vries

Java 8 definitely took some 'oomph' out of mainstream Scala adoption. I do see a lot of Scala adoption at the moment though. Currently it's mostly in ecommerce.

For me Java 8 is too little too late. The things I really miss in Java 8 are:

• pattern matching Not only handling the cases but more importantly deconstructing the object into variables.
• type inferencing To prevent Javas so called type stutter SessionFactory sessionFactory = createSessionFactory();. And also to not have to type tedious generic declarations like

Map<String, Observable<JsonNode>> observableMap = stream.collect(mapCollector);

joost-de-vries

A lot of explanations of monads start from a mathematical terminology. Which is unnecesarily obscure if you just want understand why they're handy in programming.

If you have a background in OO you can see Monad as an interface. Similarly Monoid can also be viewed as an interface. Gilad Bracha said that something that supports a function like mappend should really be called Addable (instead of Semi-group). Because that's what we can do with it. And if it also supports a function like mempty it should be called Foldable (instead of Monoid); because it provides the two arguments that a fold function requires.

Following the same naming convention the name Chainable would be more intuïtive than Monad. Because the reason that we value bind (or flatMap) so much is that we can chain (or 'compose) smaller parts into bigger parts and automatically handle alternate flows or side effects.

Because that's why Chainables (or Monads) are a big deal: we can build bigger things from flatmap invocations; you can cha

joost-de-vries

I've been thinking about the way Haskell picks out an implementation of a function that's defined on a type. F.i. the way the type of mappend is defined on the type Monoid. But the implementation is defined on an instance of Monoid. So when we use mappend the implementation is found by looking up the implementation of the runtime type of the Monoid.

glueTwice:: Monoid m => m -> m
glueTwice m = m `mappend` m

glueTwice "bla"  --  uses mappend implementation of List

This seems very much like the key point of OO: the Liskov substitution principle and like having an interface Monoid that's implemented by String.

So what's different between OO and these functions defined on types and implemented on instances?

joost-de-vries

git config --global credential.helper wincred

joost-de-vries

@echo off
set MY_JAVA_HOME=D:\devtools\jdk1.8.0_25
set SYMLINK_PATH=C:\ProgramData\Oracle\Java\javapath
set JAVA_VERSION=1.8

rem set environment variable for user
setx JAVA_HOME %MY_JAVA_HOME%

rem change default java version in registry
REG ADD "HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment" /v "CurrentVersion" /t REG_SZ /d %JAVA_VERSION% /f