1> i:im(). 

My Erlang Makefile:

EBIN_DIR := ebin
SRC_DIR := src
EXAMPLES_DIR := examples
INCLUDE_DIR := include
ERLC := erlc
ERLC_FLAGS := +debug_info +native -W -I $(INCLUDE_DIR) -o $(EBIN_DIR)

all:
	@mkdir -p $(EBIN_DIR)
	$(ERLC) $(ERLC_FLAGS) $(SRC_DIR)/*.erl

clean:
	@rm -rf $(EBIN_DIR)/*
	@rm -f erl_crash.dump

Read up on the Erlang docs.

The debugger can be a bit weird in that it doesn’t always find your ebin directory (if you’re compiling to a separate ebin dir)… it took me a bit to figure out. Also on the Mac it seems to either crash or not launch timetimes.

erl -run mymodule myfunc -run init stop -noshell

http://www.trapexit.org/Running_Erlang_Code_From_The_Command_Line

For some reason, figuring out how the gen_server behavior works in erlang was kind of a pain for me. I think it’s because I can’t just implement something, I need to know why it works. Well, now I know.

So, lets get started. Gen_server is built into erlang. It abstracts the message passing away. As far as I can tell, yes, you could write this functionality yourself. But why would you want to when it’s done for you?

For starters, there’s a few functions you need to implement. If you’re using Erlide, you can create a new module and choose gen_server as the behavior, and it’ll give you a skeleton. Nifty. I strongly recommend going this route, as it has a lot of helpful comments in the code.

Lets write an addition and subtraction server. It’s really not that useful, but it’s enough to get started and understand what’s happening.

Init

%% ——————————————————————–
%% Function: init/1
%% Description: Initiates the server
%% Returns: {ok, State} |
%% {ok, State, Timeout} |
%% ignore |
%% {stop, Reason}
%% ——————————————————————–
init([]) ->
{ok, 0}.

Here’s a very important thing to understand. A gen_server maintains a state. The State that’s returned above is the starting state of the server. In our case, the initial state will be zero.

handle_call
Now we want to add some functionality. Lets add addition and subtraction. We’ll need to export our new functions as well, so lets make sure we put this in with the exports:

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

And the actual code:

add(Num) -> gen_server:call( ?MODULE, {add, Num}).
subtract(Num) -> gen_server:call( ?MODULE, {subtract, Num}).

handle_call({add, Num}, _From, State) -> {reply, State + Num, State + Num};
handle_call({subtract, Num}, _From, State) -> {reply, State – Num, State – Num};

When you call counting:add, it will in turn call the gen_server:call function, which takes a module and a parameter. It will then call “handle_call” with this paramater, the Pid it came from, and the State of the server. The parameter can be anything, so if we use a tuple, we can take advantage of erlang’s pattern matching. handle_call will return what the gen_server should do next – reply (return a result), noreply, or stop. In this case, we’re replying.

The second parameter is the reply. We’re just going to return the current count here.

We also need to return the new server state in parameter 3. I chose to put the new state in param 2 because it’s useful, but we could just as easily put anything there – an atom, a random string, whatever.

There’s a lot of options within there, so you might want to check the docs.

I STRONGLY recommend using Erlide for your development. It auto compiles and gives you an interactive shell right in the editor. It made Erlang development so much easier. It’ll also create the stubs for the other functions you’ll need (terminate, code change, handle_info, handle_cast).

FYI, If you get an error like this:

** exception exit: {noproc,{gen_server,call,[calculator,{add,1}]}}
in function gen_server:call/2

It’s because your gen_server isn’t actually running. Make sure you start it before you test with

calculator:start().

Hopefully this is enough to get you started. Read up more in the official Erlang docs for gen_server. Scroll to the bottom to find the specifications on what functions you must implement, and what they need to return.

Enjoy!

opt_disc. Directory “c:/Documents and Settings/jhaddad/workspace/Mnesia.localhost@whatever” is NOT used.

Define a record:

-record( rule, {ruleid, site, rule, original} ).

You can define a record in the shell using rd:

99> rd(rule, {ruleid, site, rule, original} ).
rule

Create an instance of a record:

100> A = #rule{ ruleid=1, site=2, rule=2, original=3}.
#rule{ruleid = 1,site = 2,rule = 2,original = 3}

Access a single field in a record:

101> A#rule.original.
3

Extracting multiple fields:

102> #rule{ruleid=B, site=C, rule=D, original=E} = A.
#rule{ruleid = 1,site = 2,rule = 2,original = 3}
103> B.
1
104> C.
2
105> D.
2
106> E.
3

Recommended Reading
Introduction to Records

Leex is a tokenizer. It breaks the pieces of your file or text into tokens. You can then use a tool like yecc to take these tokens and generate useful parsers.

First, you’ll need the source. Leex source is available here. Go down to the last post in the forum, download the attached file.

1. Create a directory for your erlang packages. I chose ~/erlang.
2. Drop the leex directory in your new erlang package directory.
3. Edit your ~/.erlang file (it probably doesn’t exist yet) to include this line, making sure to use the path to your erlang package directory instead of mine:
   

   code:add_pathz(”/Users/jhaddad/erlang/leex/ebin”).

You should be able to use the leex libraries now.

However, what if you’re looking to select a count of the number of matches for a given pattern? Lets use select_count for that.

You can use the same pattern matching I covered in my previous post.

There’s some weird behavior though, with the last parameter of the Result part of the record. It seems that using ‘$$’ returns 0. Instead, it looks like you need to use true.

1> Tmp = ets:new(bob, []).
38
2> ets:insert(Tmp, {bob, 3}).
true
3> ets:select_count(Tmp, [{ {bob, '$1'}, [{ '>', '$1', 0}], [true]}]).
1
4> ets:select_count(Tmp, [{ {bob, '$1'}, [{ '>', '$1', 0}], ['$$']}]).
0

Here’s a basic setup.

Tmp = ets:new(tmp, []).
ets:insert(Tmp, {bob, 0}).
ets:insert(Tmp, {jim, 1}).
ets:insert(Tmp, {jon, 2}).

% Returns all results
ets:select(Tmp,[{{'$1','$2'},[],['$$']}]).

% Returns results where $2 > 0 (jim and jon)

ets:select(Tmp,[{ {'$1','$2'}, [ { '>', '$2', 0 } ],['$$'] }]).

What’s going on in the select? There’s a LOT of syntax for something that’s so simple, but once we break it up a bit it starts to be easier to look at.

First off, lets take a look at the original spec.

MatchSpec = [MatchFunction]
MatchFunction = {MatchHead, [Guard], [Result]}
MatchHead = “Pattern as in ets:match”
Guard = {”Guardtest name”, …}
Result = “Term construct”

Pretty important stuff in here. The basic building block of the MatchSpec is a list. Inside the list, is a “matchfunction”.

[MatchFunction]

Next, we break the MatchFunction up a little bit more. MatchHead = Pattern. We’ve seen this before.

MatchSpec = [ {Pattern, [Guard], [Result] } ]

Now, lets write our basic pattern. We want the rows where the 2nd item is > 0. So, since we can’t put that in the pattern yet, we’ll just give it a reference.

MatchSpec = [ { {$1, $2}, [Guard], [Result] } ]

OK, cool. That’s not so bad anymore! Next step – lets use our guard. There’s a funky syntax for guards in the matchspec, so here we go. You’re looking at a list, right? So it can have many items. Each item is a record. They can nest. We’ll ignore that for now. What we need to know here is that in a pattern matching guard, we put the operation first. It would normally read $2 > 0.

[ { '>', '$2', 0} ]

That’ll give us the pattern we want. What about the Result? Feel free to just use ‘$$’ in there. It’ll just kick back what you specified in your pattern. If you don’t believe me,

8> ets:select(Tmp,[{ {'_','$2'},[ { '>', '$2', 0 } ],['$$']}]).
[[1],[2]]

Put it all together!

ets:select(Tmp,[{ {'$1','$2'}, [ { '>', '$2', 0 } ], ['$$'] }]).

Not so bad anymore.

Match Spec docs for select/2

For testing purposes, you can use this bad boy.

test_ms(Tuple, MatchSpec)

You can also use this handy function to transform functions to selects:

fun2ms(LiteralFun) -> MatchSpec

Here’s some simple matching.

44> Tmp = ets:new(bacon, []).
26
45> ets:insert(Tmp, {joe, {fish, 1}}).
true
46> ets:match(Tmp, {’$1′, {fish, ‘$2′}}).
[[joe,1]]

What’s going on here? Each of your placeholders end up showing up in the result, in a tuple.

You didn’t need to know it was joe who had fish?

47> ets:match(Tmp, {’_', {fish, ‘$2′}}).
[[1]]

Lets add a few more guys. Same deal.

48> ets:insert(Tmp, {bob, {fish, 1}}).
true
52> ets:insert(Tmp, {steve, {bacon, 1}}).
true
53> ets:insert(Tmp, {rex, {bacon, 1}}).
true
54> ets:insert(Tmp, {alfonzo, {bacon, 1}}).
true

Who here’s got fish?

55> ets:match(Tmp, {’$1′, {fish, ‘$2′}}).
[[joe,1],[bob,1]]

Basically, you put the same pattern in the match, and the places that are wild cards that you want to save, you use a ‘$1′ type constant. The ones you don’t care about, use an underscore.

Of course, reading the original ETS specifications might be useful. They review the actual matching spec on the select/2 page.

For a more advanced tutorial covering matching using guards, check out this follow up post on select/2.

.