Einführung in ErlangFunktionale Programmierung

“Erlang is a declarative,dynamically-typed, functional, concurrent, distributed and fault-tolerant programming language with garbage collection and code hot-swapping built into its runtime.”

Warum finde ich Erlang attraktiv?

‘Learn a new programming language every year’

Warum finde ich Erlang attraktiv?

BOOKS BOOKS AND BOOKS

Warum finde ich Erlang attraktiv?

Erfahre, wie deine Probleme mit einem anderen Sprache gelöst wären, dann nutze diese Erfahrung bzw. Techniken in der aktuellen Sprache

Warum finde ich Erlang attraktiv?

Erfahre, wofür jede Sprache gut ist, dann wähle das richtige Werkzeug für den Job

Erlang ist nicht entwickelt um

• in einem Browser ausgeführt zu sein • einen Text effizient zu bearbeiten • einfach für Lehrlings zu sein• einfach in Lernen zu sein• dynamische Webseiten zu entwickeln• auf ein Handy ausgeführt zu sein • erlaubt Menschen, die nicht Entwicklers sind, Code zu schreiben• GUI zu entwickeln

Warum finde ich Erlang attraktiv?

• Erlang wurde entwickelt, um Systeme, die niemals aufhören, zu bauen• Erlang-Programmierer konzentrieren sich auf Umsetzung für den richtigen Fall. Alle andere

Situationen lösen einen Ausfall aus• Robustheit wird durch den Fokus der Programmierer auf Prozesse und die Interaktionen (oder

Nachrichten) zwischen ihnen erreicht• Frühe Fehlererkennung und Verwendung der nebenläufigen Programmiertechniken erlauben

fehlertolerante Systeme zu entwickeln

Erlang ist ‘ein bisschen’ merkwürdig...

-module(hello_server).

-export([hello/0]).

hello() ->

receive

{FromPID, Who} ->

case Who of

robert -> FromPID ! "Hello Robert.";

mike -> FromPID ! "Hello Mike.";

joe -> FromPID ! "Hello Joe.";

_ -> FromPID ! "I don't know you."

end,

hello()

end.

...aber manche gute Nachrichten

• Syntax basiert auf Prolog

Syntax basiert auf Prolog

-module(howdy).

-export([hi/1]).

hi(Name) ->

io:format('Hi there, ~p!~n', [Name]).

{person, First, Last} = {person, 'Paul', 'Barry'}.

howdy:hi(Last).

...aber manche gute Nachrichten

• Syntax basiert auf Prolog• Erlang ist nicht objektorientiert• In Erlang sind alle immutable • Der ‘=’ Operator dient zur Verbindung

− ist nicht ein Assignment Operator• No Side Effects• Erlang bietet keine Schleife (For, While)

Dann wie kann man eine Schleife schreiben

Erlang: Alist = [1, 2, 3, 4, 5].

Doubled = [X*2 || X <- Alist].

Python: alist = [1, 2, 3, 4, 5]

doubled = [x*2 for x in alist]

alist and doubled sind mutableAlist and Doubled sind nicht

...aber manche gute Nachrichten

• Syntax basiert auf Prolog• Erlang ist nicht objektorientiert• In Erlang sind alle immutable • Der ‘=’ Operator dient zur Verbindung

− ist nicht ein Assignment Operator• No Side Effects• Erlang bietet keine Schleife (For, While)• Schleife mit Hilfe von Rekursion• Strings sind als Zahlenliste repräsentiert• Erlang bietet “keine” IF...THEN...ELSE Anweisung

...aber manche gute Nachrichten

Erlang

• in Erlang sind Ideen eingeflossen aus der − funktionalen Programmierung und der − logischen Programmierung

• wurde auf Effizienz und Echtzeitfähigkeit Wert gelegt• Funktionen höherer Ordnung • Lambda-Ausdrücke und anonyme Funktionen • lazy evaluation• Listenkomprehensionen

-module(fac).

-export([fac/1]).

fac(1) -> 1;

fac(N) -> N * fac(N-1).

Beispiel

• Programme werden in sog. Modulen in Dateien gleichen Namens (hier: fac.erl) abgelegt • nach erfolgreicher Compilation (Aufruf: c(Datei) ) stehen die aus einem Modul exportierten

Funktionen zur Verfügung • zum Aufruf wird dem Funktionsnamen der Modulname vorangestellt

-module(helloworld).

-export([add/2,start/0]).

add(X,Y) ->

Z = X+Y,

io:fwrite("~w~n",[Z]).

start() ->

add(5,6).

% hello world program

-module(helloworld).

-import(io,[fwrite/1]).

-export([start/0]).

start() ->

fwrite("Hello, world!\n").

Syntax

• % für Kommentare• /x die Funktion bekommt x Parameter• - für export, import und module Anweisungen• . Jede Anweisung wird mit . terminiert

after and andalso band

begin bnot bor bsl

bsr bxor case catch

cond div end fun

if let not of

or orelse receive rem

try when xor

case Something of ok -> R = 1, %% comma, end of a line inside a case T = 2; %% semicolon, end of a case, but not the end of the last error -> P = 1, %% comma, end of a line inside a case M = 2 %% nothing, end of the last caseend.

Syntax

factorial(0) -> 1;

factorial(N) -> N * fac(N-1).

if X < 0 -> negative;

X > 0 -> positive;

X == 0 -> zero

end

hello(Greeting, Name) ->

FullGreeting = Greeting ++ ", " ++ Name,

FullGreeting.

Typen in Erlang

• Number− integer− float

• Strings• Atome

− Konstante mit Name• Boolean• Map• Tuple• List

-module(helloworld).

-export([start/0]).

start() ->

io:fwrite(atom1).

-module(helloworld).

-export([start/0]).

start() ->

io:fwrite(2 =< 3).

Atome

• Atome sind konstante Literale, die für sich selbst stehen• syntaktische Konventionen: Atome starten mit einem Kleinbuchstaben oder sind in einfache

Quotierungszeichen eingeschlossen • Beispiele:

− person, einAtom, . . . ’Atom mit Blanks’, ’daddy@sss..’, . . .• einzige Operation auf Atomen: Vergleiche

− alpha < omega. true− alpha =< omega. true− alpha >= omega. false

Strings

• Zeichen werden in ERLANG als Integer dargestellt, Strings als Listen von Zeichen• $ liefert ganzzahligen Wert zu einem Zeichen• list_to_integer• integet_to_list

− list_to_integer("123") == 123. TRUE

[65,66,67]. "ABC"

$A. 65

$a. 97

[49,50,51]. "123"

$1. 49

"123" == 123. false

Listen

• die Listendarstellung ist von Prolog übernommen • so stellt [H|T] eine beliebige Liste mit Kopf H und Restliste T dar • in Listendarstellungen können – wie auch an anderen Stellen – anonyme statt benannter Variable

verwendet werden [_,_|_]

• anders als in Prolog können in Listen nicht nur Konstante und Variable verwendet werden, sondern auch Funktionsaufrufe

-module(helloworld).

-export([start/0]).

start() ->

Lst1 = [1,2,3],

io:fwrite("~w~n",[Lst1]).

30> [[1,2]|[2,3]].[[1,2],2,3]35> [1,2] ++ [3,4].[1,2,3,4]36> [1,2,3,4] -- [2,4].[1,3]

Listenkomprehension

• Syntax:[Expr || Qualifier1,...,QualifierN]

• die Qualifier sind dabeientwederGeneratoren (in der Form: Pattern <- ListExpr )

• oderFilter(d.h. Ausdrücke, die zu true oder false evaluieren)

Quad = [ X*X || X<-[1,2,3,4] ].

[X || X <- [1,2,a,3,4,b,5,6], integer(X), X > 3].

Map

1> M1 = #{name=>adam,age=>24,date=>{july,29}}.

#{age => 24,date => {july,29},name => adam}

2> maps:get(name,M1).

adam

3> maps:get(date,M1).

{july,29}

4> M2 = maps:update(age,25,M1).

#{age => 25,date => {july,29},name => adam}

5> map_size(M).

3

6> map_size(#{}).

0

Pattern Matching

• Pattern matching in ERLANG ist von Prolog inspiriert • im Unterschied zu Haskell dürfen auch im Pattern Variable mehrfach vorkommen • daher muss in solchen Fällen die Gleichheit der Werte nicht durch zusätzliche ‘guards’ geprüft

werden

1> {person, Name, en} = {person, 'Thomas', de}.

** exception error: no match of right hand side value {person,'Thomas',de}

2> {person, Name, de} = {person, 'Thomas', de}.

{person,'Thomas',de}

3> Name.

'Thomas'

Erlang? Elixir?

• Syntax• weniger Boilerplate-Code• Lernkurve• der Pipe-Operator• mix• sigils und umgang mit der Textrepräsentierung

http://www.cse.chalmers.se/edu/year/2016/course/TDA383_LP1/erlang-exercises.html

Hausaufgabe

Schreiben Sie ein Programm, welches zwei Funktionen bietet:- eine Funktion, die das größte Element einer Liste zurückgibt- eine Funktion, die das kleinste Element einer Liste zurückgibt