Keep calm and curry on

Funktionales Programmieren
mit Beispielen in Haskell und Java,
License: CC-BY-SA-4.0

Martin Heuschober

2017-06-28

Intro

Überblick

Timeline

Timeline - Haskell Timeline - Java

History of Programming languages

Syntax & Features

`main :: IO () main = putStrLn "Hello Haskell"`	`public class HelloWorld { public static void Main (String[] args) { System.out.printLn("Hello Java!"); } }`
Whitespace sensitive Funktionsaufrufe ohne () Typ-Signatur (optional) getrennt von Definition Funktionen sind “first level citizens” Starkes Typsystem + Typinferenz	Objektorientiert + Vererbung -`NullPointer` Riesiges Ökosystem/Libraries Entwickler IDEs bisschen Funktional (seit Java8)

Funktionales Programmieren

Was ist funktional?

module Card where (sortBy, on, module Card)
import Data.List
import Data.Function

data Suit = Heart | Clubs | Diamond | Spades
          deriving (Eq, Show, Ord, Enum)

data Rank = Ace   | King  | Queen | Jack | Ten | Nine
          | Eight | Seven | Six   | Five | Four| Three
          | Two deriving (Eq, Show, Ord, Enum)

data Card = Card {suit :: Suit, rank :: Rank}
          deriving (Show, Eq)

allCards :: [Card]
allCards = [Card s v | s <- [Heart..], v <- [Ace..]]

public enum Suit {
  Heart , Clubs , Diamond , Spades
}

public enum Rank {
  Ace , King , Queen , Jack , Ten , Nine , Eight,
  Seven , Six , Five , Four , Three , Two
}

public class Card {
  public Suit suit;
  public Rank rank;

  public class Card(Suit suit, Rank rank) {
     this.suit = suit;
     this.rank = rank;
  }
}

public List<Card> allCards() {
  List<Card> result = new LinkedList<>();
  for (Suit s : Suit.values()) {
    for (Rank r : Rank.values()) {
       result.append(Card(r,s));
    }
  }
  return result;
}

Funktional jetzt aber wirklich

Eine Programmiersprache darf sich (meiner Meinung nach) funktional nennen wenn:

Funktionen als Parameter bzw. Rückgabewerte von anderen Funktionen auftauchen können
Funktionen in “Variablen” gesteckt werden können
jede Funktion einen Rückgabewert hat.
Bonuspunkte gibt es für partielle Funktionsaufrufe, i.e. wenn eine Funktion mit mehreren Parametern mit nur einem Parameter aufrufbar ist, und eine Funktion mit um einen Parameter weniger zurückgibt.

Was ist eine Funktion

f :: a -> b
g :: a -> b -> c

Java8

λ> :set -XOverloadedStrings
λ> import qualified Data.Text as T
λ> uppercased = T.toUpper "lowercase"
λ> uppercaser = T.toUpper



☕> "lowercase".toUpperCase()
☕> String::toUpperCase()

Aufgabe: (Stackoverflow) Mache aus einer Liste: [5,4,2] => "+-----+----+--+"

String fence (List<Integer> lst){
    String result = "+";
    for( Integer i : lst) {
        for (int j = 0; j < i,j++){
          result += "-";
        }
        result += "+";
    }
    return result;
}

fence :: [Int] -> String
fence = between '+' . intercalate "+" . map (`replicate` '-')
  where between c str =  c:(str ++[c])

Mache aus einer Liste: [5,4,2] => "| + + |"

String fence (List<Integer> lst){
    String result = "+";
    for( Integer i : lst) {
        for (int j = 0; j < i,j++){
          result += "-";
        }
        result += "+";
    }
    return result;
}

String wall (List<Integer> lst){
    String result = "|";
    for( Integer i : lst) {
        for (int j = 0; j < i,j++){
          result += " ";
        }
        result += "+";
    }
    return result.subString(0,result.length()-1) + "|";
}

fence :: [Int] -> String
fence = between '|' . sepBy '+' . fillWith '-'

wall :: [Int] -> String
wall = between '|' . sepBy '+' . fillWith ' '

fillWith :: Char -> [Int] -> [String]
fillWith c ints = map (flip replicate c) ints

sepBy :: String -> [String] -> String
sepBy i str = intercalate i strs

between :: Char -> String -> String
between c str = c:(str++[c])

λ> sortBy (compare `on` rank) allCards
λ> :t sortBy
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
λ> :t on
on :: (b -> b -> c) -> (a -> b) -> a -> a -> c

☕> Collections.sort(allCards(),new Comparator(){..}
☕> typeOf(sortBy)
List<T> sortBy (BiFunction<T,T,int> cmp, List<T> in)
☕> typeOf(sortBy)
BiFunction<A,A,C> on (BiFunction<B,B,C> cmp, Function<A,B> f)

Partielle Funktionsaufrufe

Employee :: Company -> Name -> Employee
tSystems = Employee "T-Systems"
map tSystems ["Martin Heuschober" ..]
map (Employee "T-Systems") ["Martin Heuschober"..]

Employee (String company, String name) {..}
Employee tSystems(String name) = Employee("T-Systems", name)
List<String> employeeNames = new ArrayList<> (["Martin Heuschober"..])
employeeNames.map(tSystems)

Higher order functions

`map`

macht aus einer Liste eine neue Liste

Quasi eine eingeschränkte for-loop^†

`map :: (a -> b) -> [a] -> [b] map _ [] = [] map f (x:xs) = f x : map f xs`	`for (Elmtclass e : lst) { e' = f(e) }`
	`for( int i = 1, i < lst.length(), i++) { e' = f(lst[i]) + f(lst[i-1]) }`

^†: Ich glaube aber fast das gleiche wie eine foreach-loop

Aber was bringt uns das?

Parallelisation for “free”
equational reasoning
(stream) fusion

`fold`/`reduce`

fold :: (a -> b -> a) -> a -> [b] -> a
fold _ acc [] = acc
fold f acc (x:xs) = fold f (f acc x) xs

for (Elmtclass e : lst) {
  acc = f(acc, e);
}
return acc;

`filter`

filter :: (a -> Bool) -> [a] -> [a]
filter _ [] = []
filter p (x:xs) = let xs' = filter p xs
                   in if p x then x : xs' else xs'

for (Elmtclass e : lst) {
  if (p(e)) newlist.append(e);
}
return newlist;

filter p = foldr (\y acc -> if p y then y:acc else acc) []

`all`/`any`

`any :: (a -> Bool) -> [a] -> Bool any _ [] = False any p (x:xs) = if p x then True else any p xs`	`for (Elmtclass e : lst) { if (p(e)) return true; } return false;`
`all :: (a -> Bool) -> [a] -> Bool all _ [] = True all p (x:xs) = p x && all p xs`	`for (Elmtclass e : lst) { if (!p(e)) return false; } return true;`
`any p = foldr (\y acc -> p y \|\| acc ) False all p = foldr (\y acc -> p y && acc ) True`
`all p = not . all (not . p)`

Typsystem

Info

Hindley-Milner
stark, statisch

Mein Problem mit schwachen Typsystemen

Aus der Dokumentation von node.js (fast wortgetreu) fs.openSync(path, flags[, mode])

path <string> | <Buffer> | <URL>
flags <string> | <number>
mode <integer>

// get the file descriptor of the file to be truncated
const fd = fs.openSync('temp.txt', 'r+');

Synchronous version of fs.open(). Returns an integer representing the file descriptor.

Offene Fragen

Welche Flags gibt es?
Was ist das ‘+’?
Welche numerischen Flags gibt es?
Sind das jetzt auch <integer> oder auch Kommazahlen?

Aber ok das ist ja nur die Dokumentation - gute Programmierer kümmern sich ja gern darum, dass ihre Doku brandaktuell und vollständig ist

Typsysteme sind ja da den Programmierern helfen keine Fehler zu machen

fs.truncate(<integer>, <integer>, <Function>)

// truncate the file to first four bytes
fs.ftruncate(4, fd, (err) => {
  assert.ifError(err);
  console.log(fs.readFileSync('temp.txt', 'utf8'));
});

Ok das kann ja nicht passieren wenn man die Doku ordentlich liest

machen ja auch alle - und kopieren nicht einfach Code von Stackoverflow

fs.truncate(fd <integer>, len <integer>, callback <Function>)

fs.ftruncate(fd+1,4, (err) => {
  assert.ifError(err);
  console.log(fs.readFileSync('temp.txt', 'utf8'));
});

Wozu Typsysteme also?

Soll unterstützen.
Soll so viel Info wie möglich beinalten.
Soll so wenig einschränken wie möglich.
Soll weitgehend “automatisch” passieren.

Jeder Fehler der zur Compile-time erkannt wird, landet nie bei einem Kunden.

Dinge die das Haskell Typsystem gut macht

Und andere Systeme nicht können:

IO eingrenzen

readLn :: Read a => IO a
fmap readMay . getLine :: Read a => IO (Maybe a)
withSqliteConn :: ConnString -> Query a -> IO a

Sum types

data Either a b = Left a | Right b

data JSON = JsonString Text
          | JsonNumber Rational
          | JsonBool   Bool
          | JsonNull
          | JsonObject (Map Text JSON)
          | JsonArray [JSON]

Pattern matching

data IPv4 = IPv4 Word8 Word8 Word8 Word8
runParser :: Parser a -> String -> Either String a

case runParser ipv4 "127.-1.120.255"
  of Left msg -> do something with errormessage
     Right x -> do something with result

ipv4 :: Parser IPv4
ipv4 = do a <- check =<< decimal
          dot
          b <- check =<< decimal
          dot
          c <- check =<< decimal
          dot
          d <- check =<< decimal
          return IPv4 a b c d
  where dot :: Parser ()
        dot = void $ char '.'
        check :: Integral -> Parser Word8
        check x = do unless (0 <= x && x <= 256) $
                       fail "Failed parsing IPv4"
                     return $ fromIntegral x

Typinferez

map :: _
map f [] = []
map f (x:xx) = f x: map f xx

[] und (:) sind Listenkonstruktoren (leere Liste und cons-Operator) => 2tes Argument von map muss eine Liste sein.

    map :: _ -> [a] -> _

ebenso das Ergebnis

    map :: _ -> [a] -> [b]

f wird in Zeile 2 auf das erste Element der Argument-Liste angewandt => damit muss f eine Funktion sein

    map :: (x -> y) -> [a] -> [b]

f wird in Zeile 2 auf das erste Element der Argument-Liste angewandt => damit muss f der Wertebereich von f a sein und der Zielbereich b

    map :: (a -> b) -> [a] -> [b]

Und man sich klauen kann

Generics verwenden und Arrays vermeiden

public static void main(String[] args) {
    Circle[] circles = new Circle[2];
    Shape[] arr = circles;
    arr[0] = new Circle(1.0);
    arr[1] = new Square(1.0);
    for (Shape s : arr) {
       System.out.println(s);
    }
}

public static void main(String[] args) {
    List <Circle> lst = new ArrayList<>();
    lst.add(new Circle(1.0));
    lst.add(new Square(1.0));
    for (Shape s : lst) {
       System.out.println(s.area());
    }
}

Haskell ist pure

NonNullable/@Nullable verwenden
IO minimieren
mutable State minimieren - z.B. List.append(x) verändert eine Liste und ist daher eine schlechte Idee . . .
Abstraktionen wie Funktor, Applicative, Monad, Monoid etc.

Fundamental theorem of software engineering

“We can solve any problem by introducing an extra level of indirection.”

Butler Lampson

Functor

What?

Ziel: Einen Container-Datentyp elementweise verändern, aber die Struktur des Containers beibehalten. Warum: Fast jeder Container hat diese Eigenschaft.

Haskell

class Functor c where
    fmap :: (a -> b) -> c a -> c b

data [a] = ..
data Maybe a = Nothing | Just a
data Tree a = Empty
            | Tree { label :: a
                   , leftBranch  :: Tree a
                   , rightBranch :: Tree a }
data RoseTree a = RoseTree { label :: a
                           , children :: [RoseTree a]
                           }
data IntMap a = ..

instance Functor [] where
  fmap _ [] = []
  fmap f (x:xs) = f x : fmap f xs

instance Functor Maybe where
  fmap _ Nothing = Nothing
  fmap f (Just a) = Just (f a)

instance Functor Tree where
  fmap _ Empty = Empty
  fmap f (Tree x lB rB) = Tree (f x) (fmap f lB) (fmap f rB)

instance Functor Tree where
  fmap f (RoseTree x xs) = RoseTree (f x) (fmap (fmap f) xs)

Java

import java.util.function.Function;

interface Functor<T> {
    <R> Functor<R> fmap(Function<T, R> f);
}

interface Functor<T,F extends Functor<?,?>> {
    <R> F fmap(Function<T,R> f);
}

class Identity<T> implements Functor<T,Identity<?>> {
    private final T value;

    Identity(T value) { this.value = value; }

    public <R> Identity<R> fmap(Function<T,R> f) {
        final R result = f.apply(value);
        return new Identity<>(result);
    }
}

Keep calm and curry on

Intro

Überblick

Timeline

Syntax & Features

Funktionales Programmieren

Was ist funktional?

Funktional jetzt aber wirklich

Was ist eine Funktion

Partielle Funktionsaufrufe

Higher order functions

map

Aber was bringt uns das?

fold/reduce

filter

all/any

Typsystem

Info

Mein Problem mit schwachen Typsystemen

Offene Fragen

Typsysteme sind ja da den Programmierern helfen keine Fehler zu machen

Ok das kann ja nicht passieren wenn man die Doku ordentlich liest

Wozu Typsysteme also?

Dinge die das Haskell Typsystem gut macht

Und andere Systeme nicht können:

IO eingrenzen

Sum types

Pattern matching

Typinferez

Und man sich klauen kann

Generics verwenden und Arrays vermeiden

Haskell ist pure

Fundamental theorem of software engineering

Functor

What?

Haskell

Java

Links

Haskell

Java

`map`

`fold`/`reduce`

`filter`

`all`/`any`