Getting Started With Erlang 2장 Sequential Programming

-module(tut).
-export([double/1]).

double(X) ->
  2 * X.

1> c(tut).
{ok,tut}

2> tut:double(20).
40

-module(tut).

2> tut:double(20).

-export([double/1]).

-module(tut1).
-export([fac/1]).

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

2> c(tut1).
{ok,tut1}

3> tut1:fac(5).
120

fac(1)->
	1;

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

-module(tut1).
-export([fac/1, mult/2]).

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

mult(X, Y)->
        X * Y.

3> c(tut1).
{ok,tut1}

4> tut1:mult(21,31).
651

X = 1+2

X = 1+2
X = 5

1> X=1+2.
3
2> X=5.
** exception error: no match of right hand side value 5

-module(temp).
-export([convert/2]).
convert({fahrenheit, Temp}, celsius) ->
	{celsius, 5 * (Temp - 32) / 9};
convert({celsius, Temp}, fahrenheit) ->
	{farenheit, 32 + Temp * 9 / 5};
convert({reaumur, Temp}, celsius) ->
	{celsius, 10 * Temp / 8};
convert({celsius, Temp}, reaumur) ->
	{reaumur, 8 * Temp / 10};
convert({X, _}, Y) ->
	{cannot,convert,X,to,Y}.

2> temp:convert({fahrenheit, 98.6}, celsius).
{celsius,37.0}
3> temp:convert({reaumur, 80}, celsius).     
{celsius,100.0}
4> temp:convert({reaumur, 80}, fahrenheit).
{cannot,convert,reaumur,to,fahrenheit}

5> N = {12, banana}.
{12,banana}
6> {A, B} = N.
{12,banana}
7> A.
12
8> B.
banana
9> 

2> {A, B} = {[1,2,3], {x,y}}.
{[1,2,3],{x,y}}
3> A.
[1,2,3]
4> B.
{x,y}
5> {_,L,_}={fred,{likes, [wine, women, song]},
     {drinks, [whisky, beer]}}.
{fred,{likes,[wine,women,song]},{drinks,[whisky,beer]}}
6> L.
{likes,[wine,women,song]}
7> 

   123 -34567 12.345 -27.45e-05

-module(tut2).
-export([convert/2]).

convert(M,inch)->
	M / 2.54;
convert(N,centimeter)->
	N * 2.54.

1> c(tut2).
{ok,tut2}
2> tut2:convert(5,inch).
1.968503937007874
3> tut2:convert(5,centimeter).
12.7

#define inch 1
#define centimeter 2

float convert(int a, int type);
int main()
{
	printf("%lf\n", convert(5,inch));
	printf("%lfu\n", convert(5,centimeter));
}

float convert(int a, int type)
{
  if (type == inch)
  {
    return a / 2.54;
  }
  else if(type == centimeter)
  {
    return a * 2.54;
  }
}

{yundream, 1974, 'programmer'}
{1, 2, {3, 4}, {a, {b, c} } }
{}

tut2:convert(3,inch)

9> F=tut2:convert(3,inch).
1.1811023622047243
11> tut2:convert(F,centimeter).
3.0

-module(tut3).
-export([convert_length/1]).

convert_length({centimeter,X})->
	{inch, X/2.54};

convert_length({inch,Y})->
	{centimeter, Y * 2.54}.

2> c(tut3).
{ok,tut3}
3> tut3:convert_length({inch,5}).
{centimeter,12.7}
4> tut3:convert_length(tut3:convert_length({inch,5})).
{inch,5.0}

[{moscow, {c, -10}}, {cape_town, {f, 70}}, {stockholm, {c, -4}},
 {paris, {f, 28}}, {london, {f, 36}}]

1> [First|TheRest]=[1,2,3,4,5].
[1,2,3,4,5]
2> First.
1
3> TheRest.
[2,3,4,5]

6> [E1,E2 | R]=[1,2,3,4,5,6,7].
[1,2,3,4,5,6,7]
7> E1.
1
8> E2.
2
9> R.
[3,4,5,6,7]

-module(tut4).
-export([list_length/1]).

list_length([])->
  0;
list_length([First|Rest])->
  1 + list_length(Rest).

1> c(tut4).
{ok,tut4}
2> tut4:list_length([1,3,5,7,9,11,13,15]).
8

list_length([])->
  0;

list_length([First|Rest])->
  1 + list_length(Rest).

  1+1+1+1+1+1+1+1+list_length([]) = 8

2> [97,98,99].
"abc"

-module(facguard).
-export([factorial/1]).

factorial(N) when N == 0 ->
	1;
factorial(N) when N > 0 ->
	N * factorial(N-1).

foo(X, Y, Z) when integer(X), integer(Y), integer(Z), X == Y + Z ->
foo(X, Y, Z) when list(X), hd(X) == {Y, length(Z)} ->
foo(X, Y, Z) when {X, Y, size(Z)} == {a, 12, X} ->
foo(X) when list(X), hd(X) == c1, hd(tl(X)) == c2 ->

-module(foo).
-export([foo/3]).
foo(X,Y,Z) when integer(X), integer(Y), integer(Z), X==Y+Z ->
	Y+Z.

2> c(foo).
{ok,foo}
3> foo:foo(1,2,3).
** exception error: no function clause matching foo:foo(1,2,3)
4> foo:foo(3,2,1).
3
5> foo:foo(3.0,2,1).
** exception error: no function clause matching foo:foo(3.0,2,1)

factorial(N) when N > 0 ->
	N1 = N-1,              ----+
	F1 = factorial(N1),        |--> Body
	N * F1.                ----+

    case Expr of
        Pattern1 [when Guard1] -> Seq1;
        Pattern2 [when Guard2] -> Seq2;
        ...
        PatternN [when GuardN] -> SeqN
    end

if
	Guard1 ->
		Sequence1;
	Guard2 ->
		Sequence2;	
	...
end

-module(fac).
-export([factorial/1]).
factorial(0) -> 
	1;
factorial(N) ->
	N * factorial(N-1).

-module(facif).
-export([factorial/1]).
factorial(N) ->
	if
		N == 0 -> 1;
		N > 0 -> N * factorial(N-1)
	end.

-module(facguard).
-export([factorial]/1).
factorial(0) -> 
	1;
factorial(N) when N > 0 ->
	N * factorial(N-1).

-module(facif).
-export([factorial/1]).

factorial(N) ->
  if
    N == 0 -> 1;
    N > 0 -> N * factorial(N-1)
  end.

1> io:format("Hello world~n", []).
Hello world
ok
2> io:format("this outputs one Erlang term: ~w~n",[hello]).
this outputs one Erlang term: hello
ok
3> io:format("this outputs two Erang terms: ~w~w~n", [hello,world]).
this outputs two Erang terms: helloworld
ok
4> io:format("this outputs two Erang terms: ~w ~w~n", [hello,world]).
this outputs two Erang terms: hello world
ok