module type MONAD =
  sig
    type 'a t
    val bind : 'a t -> ('a -> 'b t) -> 'b t
    val return : 'a -> 'a t
  end

You will notice here that I am declaring a module type and not a module. Basically, I want to build monads out of things. Thus, Monad in OO terms is an abstract base class. So, if we want to have a “kind of” Monad, we have to build it. In any case, the type 'a t is the type system wrapper around a polymorphic value. Basically, the type system wraps the value in a type so that it can be manipulated at the type level rather than at the value level. return is kind of an odd way to put it but it “return”s a Monad out of a value of some kind (as has been pointed out by pozorvlak, mote is a better term for values of that type and is a common mistake in Monad tutorials); we don’t care what kind (or type) the value is. bind is a way for the user to bind a function to a Monad. What you will get is the Monad feeding the value into the function and expecting a new Monad from the function then it will automatically return that Monad.

So, you can create different kinds of Monads to do different things and one of the side-effects is that side-effects are encapsulated within the Monad itself. This means that you can do things which are not “pure” functional programming within a purely functional system (this isn’t strictly true either). As you can see with bind, you will always return a Monad. However, I can hear you saying, “but how do I get values out of a Monad?” Don’t worry you can do that by having a function like this:

val access : 'a t -> 'a

This function is some times called “run” as well. What it does is it asks the Monad for its computation (aka “a thunk”) as the Monad writer can put off actually doing the computation until this stage in the processing. So, with that knowledge, let’s attempt the next stage:

module type STATE =
  sig
     type t
     val empty : t
  end

Again, this is an abstract base class for “State” and it allows you to define your own state using a functor (I should write another thing on functors). Basically, I don’t want to constrain the kinds of StateMonads and just let my users define what kind of state they need. So, bringing this together with the MONAD declaration above:

module type STATE_MONAD = 
   functor(State : STATE) ->
     sig
       include MONAD
       val access : 'a t -> 'a
       val put : State.t -> unit t
       val get : State.t t
     end

Ok, again another declaration with no real code, please be patient all will be revealed. This has access and put and get functions. The access function, actually does the computation of functions that are bound within the Monad. The put and get is something I am still trying to get my head around but it basically allows you to use the StateMonad as a variable store. You can store things in it like a variable and retrieve the information and return it.

So, now on to some Real Code:

module StateMonad : STATE_MONAD =
   functor(State : STATE) ->
     struct
       type state = State.t
       type 'a t = state -> ('a * state)
       let bind m f =
         fun s ->
           match m s with 
              | (x, s') -> f x s'
       let return a = fun s -> (a, s)
       let access m =
           match m State.empty with
             | (x, s) -> x
       let put s =
           fun _ -> ((), s)
       let get =
           fun s -> (s, s)
     end

So, lets break this down. The functor allows the user to set what kind of state they want. I will demonstrate this below. The next bit is type 'a t = state -> ('a * state). This defines the actual type that is wrapped inside the StateMonad. Basicaly it said “This Monad is a function which takes one state and translates that state into a value and the next state”. Thus, when you put a state in the StateMonad via return, it returns just what it says on the tin a function which takes a state and return a tuple of a value and the state. The next function bind binds a function to the Monad and the monad calls the last function it created (in this case the “m” in the code) and matches the output of “m” with the expected tuple which is then passed to the next function in the chain. The access function takes an empty state and that fires the function chain to come to a final state and value then the final value is returned.

Now, the put and get functions. I am not sure I actually understand these as well as I should so I will tell you now that if what I say is wrong, please let me know. So basically put creates a degenerate return function which puts the value in the same kind of wrapper as a function. The get passes back a function which fires immediately and gives you back it’s value. I am completely unsure of how exactly this works but it seems to work in practice. If someone could enlighten me, that would be wonderful.

So, now I will present a trivial example: IntStateMonad.

   module IntStateMonad = StateMonad(
     struct
       type t = int
       let empty = 0
     end
    )

This tells the StateMonad what kind of state the user wants. This basically fills in the functor State from above. I am still slightly unsure if the empty value is really necessary or if there is some other way I can get the underlying function to fire without it. So here is an example:

let _ =
   let blah = IntStateMonad.return 1 in 
   let blah2 = IntStateMonad.bind blah (fun i -> IntStateMonad.return (succ i)) in 
      print_endline (string_of_int (IntStateMonad.access blah2))

So, can we do something more Haskell like in this instance? Yes, with the “perform” notation that is provided by pamonadcustom, which uses camp4 to parse ocaml and do syntax transformations. So we can do this like so:

let return = IntStateMonad.return

let _ =
   let blah = 
        perform with IntStateMonad.bind in 
           a <-- return 1;
           b <-- return (succ a);
           return b
 in 
    print_endline (string_of_int (IntStateMonad.access blah))

So you have to bind the return and bind functions to something that is accessible by the pa_monad syntax. Otherwise, it takes care of interleaving the binds then it returns the resulting Monad which you can run (or access…whatever you prefer to call it).

As for get and put, you can use it in this way:

let _ =
   let blah = 
      perform with IntStateMonad.bind in 
        a <-- return 1;
        b <-- IntStateMonad.put 5;
        c <-- return (succ a);      
        d <-- IntStateMonad.get;
        return (c + d)
 in
    print_endline (string_of_int (IntStateMonad.access blah))

So, there you have it. This is a Monad which keeps track of the state for you and will return the evaluated functions in a type wrapper. This will also get and store state like a variable wrapped inside the bound function calls. All side-effects are explicitly handled inside the Monad and Leibniz gets to smile. Who said philosophy was useless?

UPDATE Added information on motes and clarified some stuff on side-effects in a purely functional programming language.

As Camomile uses functors extensively, you need to know how they work so you can follow the code example below. However, it is fairly straight forward once you get your head around it (it took me a while to figure this out which is why I am putting this here).

open CamomileLibraryDefault
open Camomile

module UTF8Decode = Camomile.CharEncoding.Make(UTF8)

let _ =
  try
    let changed = UTF8Decode.decode Camomile.CharEncoding.utf8 "神奈川大学" in 
      UTF8.validate changed;
      print_endline "yes!";
      exit 0
  with 
      | UTF8.Malformed_code ->
          print_endline "no!";
          exit 1

In the project that I have been working on, I had to read in a Unicode file into Ocaml and create a “seen” hash. Just as you would do in perl normally. However, because Ocaml doesn’t support Unicode natively, you cannot use the generic Hashtable type “(‘a, ‘b) t”, which stands for an arbitrary type for a key (the first ‘a) and an arbitrary type for the value (the second ‘b). The key value types will be filled in by type inference as you use the Hashtable based on what you do with it. This won’t work because the generic Hashtable depends on an equal function that will not conform to the Unicode standard compare.

All is not lost, however! This is where one of the most powerful features of Ocaml comes into its own: the functor. Modules in Ocaml can be parametrized in such a way as the user can redefine a module to meet his/her needs. For Hashtables one can parametrize the Hash on the key value. For instance:

module UTF8Hash = Hashtbl.Make(
  struct
    type t = Camomile.UTF8.t
    let equal a b =
      if (Camomile.UTF8.compare a b) = 0 then
        true
      else
        false
     let hash = Hashtbl.hash
 end
)

Using the Hashtable Make functor, I set the key type to UTF8 then set the equal function to something that makes sense for UTF8 strings. In the end, I left the hash function itself alone as I thought it would probably do the right thing and I didn’t want to get into it so I just defined it as itself.

Doing this creates a Hashtable type of ‘a UTF8Hash.t. The ‘a is now the type of the value as you already know the type of the key for the hash. In addition, doing this, you can create a hashtable that has an arbitrarily complex key type. As long as you can write an equals function, you should be fine.

let keys htbl =
  Hashtbl.fold (fun k _ accum -> k::accum) htbl []

As you can see above the fold function gets three params, the first two are the key and value. The third is the “accumulator” or in this case just a list where you will append the k variable. The underscore means “anything” and tells the compiler that you don’t really care about the binding and it is not then necessary.

The values function works similarly.

let values htbl = 
  Hashtbl.fold (fun _ v accum -> v::accum) htbl []

The each function will be slightly different in that we need both k and v and the accum parameters.

let each htbl =
  Hashtbl.fold (fun k v accum -> (k, v)::accum) []

This creates a list of tuples of the key and value. You can then match against it and get the key and value out.

git status | grep "modified: " | awk '{print $3}' | xargs git add

type t = { blah : int }

The record field blah is now a module wide name so I cannot reuse it. Thus, field names that happen to be useful in two contexts are not allowed. Although, to be honest, having two record names the same is probably a sign of a refactor point.

These instructions should work on Evince 3.2 in Xubuntu 11.10.

• Open your desired PDF in Evince.
• In the upper left, you should see the word “Thumbnails” and a down arrow.
• Press the down arrow and choose “Annoations”. This will show you the list of annotations in the current PDF.
• You should see an “add” tab. Click on the add tab. There should be a small pencil icon.
• Click on the pencil icon. Your cursor should turn into a plus sign.
• Click where you want to put your annotation. A yellow icon should appear and a small yellow window with your name in the title bar should appear.
• Type your annotation. I had a small bit of trouble getting it to recognize my typing but resizing the yellow window did the trick.
• When you are done, you will need to save the PDF as a different file. I am not sure why this is but if I saved it on top of the old file, it didn’t take the annotations.

Yay!! You can now annotate PDFs in Linux. My life has gotten so much easier now.

The difference will be reflected in the price. My GF’s ebook is priced at just over £1 while her physical book is priced at £10. The difference is ownership. In the case of an ebook you will never own the book itself, see Amazon’s revocation of 1984 as an example. The difference between the price of the ebook and the price of the physical book is the convenience of the digital form and the lack of true ownership of the ebook.

There is also a difference in risk. The risk of an ebook is that the proprietor of the site whence you purchased the book could at any time disappear and take your ebook with them. This means that the risk needs to be adjusted in the renter’s favor. To entice people to rent an ebook means that it will need to be priced such that if the website shuts down, the renter is not out of pocket too much and thus will take the risk of renting the ebook.

So, while ebooks will probably be the larger market, I do not expect books to disappear any time soon due to the difference in legal positions and the risk involved. As a scholar, this means that while it would be nice to have digital editions of the books that I need, I will more than likely continue to purchase books as I cannot afford to have a book vanish. Also, some people like to collect things so while the market in plain books will diminish, the market in autographed copies will probably take up some of the slack.

1. Goolge Buzz: does not appear in your “Status” list. This is mildly frustrating. You must go all the way to your profile page to see this. They should just appear in your status list as per facebook.

2. Google Reader Sharing: If you share something via Reader, it does not appear as a link in your Status list. Again, this means that if you want to share something cool in your RSS feed, you would have to do it twice.

3. Google Reader Like: What is the difference between Google Reader Like and Google +1? Don’t know? Me either. Again integration and semantic fail.

4. Lack of People: It seems like they are dibbling this out (a la gmail) which means that there is currently only one friend currently on there even if I have a huge “Circle” of friends. This is boring.

5. Do I really need another one: This is just getting ridiculous. I don’t want to waste any more time. I tried it because it was Google but I don’t want to sign up for another damn one of these.

Anyway, these are my first impressions. Maybe it will get better but it is leaving me a bit flat.

type A = { foo : B }

type B = Bar of A

To get around this limitation, Ocaml has “mutually recursive types” with the keyword “and”. Now, “and” is overloaded to work with mutually recursive functions as well. So, if you want to do this you can use “and” thusly:

type A = { foo : B }
and
B = Bar of A

There is one thing to notice here: B does not have a “type” keyword in front of it. This isn’t necessary because the idea of “type” crosses the “and” boundary. Sometimes, you get long chains of this which can look slightly odd but isn’t too much of a problem most times.

So, please read the wikipedia article above for a quick intro to bitcoin before you read any further.

I am interested in bitcoin because I like the anonymous and p2p nature of the service. While I would describe myself as a “socialist”, I still believe that there are some things that are not the government’s business and sometimes I just want to be left alone to do what I want without interference in the form of government. Another incentive for me is the cryptographic nerd in me loves the idea that you can have a completely anonymous currency using computers to do it.

For my analysis below please understand that I will be using “normal” logic rather than “economic” logic (also known as “voodo logic”). I am not an economist and I do not trust them very much given their past track record in the prediction business.

So, what gives a bitcoin value? This is a rather fraught question to start with and really should be the heart of economic philosophy. In Neo-classical economics, something has value because someone will put a price on a good or service. This neatly dodges the question. Marx goes into the question in the first chapter of Capital. His theory is that value is created when a raw material is turned into something useful by labour. This makes sense even if Marx’s prose style is as dense as lead. In terms of bitcoins, because they are generated by CPU/GPU mining, a bitcoin has value in the electricity spent in generating the bitcoin. In other words, it is based on carbon emissions (unless your computer is run using renewable or non-carbon electricity generation).

Now, I just want to inject here another idea. All currencies are valueless. To mangle Nietzsche, “if you stare into money (the abyss), money (the abyss) will stare back into you”. Currencies only have value because you are required to pay your taxes in them. Otherwise, they are nice colorful bits of paper with dead white guys on them. They don’t mean anything and will never have extrinsic meaning. Bitcoin is the same.

With the theory of a bitcoin’s value out of the way very neatly using Marx (thanks dude). We can now turn to the criticisms of bitcoin. The first of which is bitcoin’s deflationary nature. There are only 26 million bitcoins that can be found. This gives an upper boundary on the size of the market. However, since you can divide a bitcoin up to eight decimal points, the correct upper boundary is 26,000,000 x 10^8 number of units. This is still a hard limit.

Now, why would this be a problem? First, we must think about inflation. Inflation is where a nominal currency becomes less valuable over time due to the entrance into the market of more of that currency. Most central banks try to keep inflation at about 2%. Why is inflation useful? What happens when you know that your £1 will be worth slightly less tomorrow than it is worth today? You will be encouraged to either invest that to beat inflation (and if you don’t beat inflation, you will be losing money in the long run) or spend that money. This keeps the economy going because then you will have what economists call the “velocity of money” (Thanks again to Marx). If the “velocity of money” ever reaches 0, it is like hitting 0 kelvin, we don’t know what will happen but your economy will not work.

Now, deflation is the exact opposite of inflation. This means that my £1 will be worth more tomorrow than it is today. This will discourage you from investing or purchasing anything other than necessities. This also impacts debt but that is a thorny subject that I will avoid for this post. Therefore, that bitcoin is deflationary is a sight problem because the market will never expand enough to cover what a normal currency would as it has hard limits to the number of bitcoins in existence.

A way of thinking around the deflation of bitcoin is to understand that this is a niche currency thus the market will never reach a stage where the deflationary aspects of the currency overtake the inflationary needs of huge advanced economies.

I have a few minor suggestions that might make bitcoin scale indefinitely but they may have their own problems. First, build in a 2% inflation rate into the mining aspect of the currency. This means that people will be encouraged to spend/invest/lend bitcoins. 2% is a modest number for an advanced system. It means that hyperinflation will never happen but you can still do useful work and “get ahead” of inflation. Second, the anonymous nature of the currency causes many in power to fear it because they cannot control it. In the end, are we not free to do what we please with ourselves? I know it is a trite idea these days but the government needs to quit fearing and causing fear. We are adults, as long as we are not doing harm to others or ourselves, what is the problem? If bitcoin is to survive we need to have a reasoned debate about the usefulness of alternative currencies. I doubt that this will happen in the current political climate.

I think bitcoin is cool and neat and a way of building up a store of value that has nothing to do government. It is also a neat implementation of cryptography.

Also, this is not investment advise. This is all at your own risk.

Peer Review is anonymous. This allows for people to be straight-forward in their assessment of a piece of writing. Errors both large and small can be brought to the author’s attention and fixed. How would one go about implementing a system to deal with this? First, Peer Review is usually done gratis so people could sign up to be in a pool of Peer Reviewers. On an Arxiv.org type site, this might show up in your “profile”. When an author submits a work, it is marked as “not peer reviewed” but it will show up in searches, etc. The author then submits the article for Peer Review. The system then randomly picks two Peer Reviewers to review the work. They then read and vote on the work. If they give “two thumbs up”, the article will be marked. If they give it “two thumbs up with changes”, the changes are given to the author who then makes (or not) the changes and it is resubmitted to the reviewers who give the final “up or down vote”. In the case of a tie in the voting, another Peer Reviewer is randomly selected and they look over the case for and against, the tie-breaker then does his job.

As you can see, this can all be automated. All you need is people willing to do the Peer Review thing. Also, who nominates people for Peer Review? That is a political question really but I would suggest that you use people who have credentials (PhD or above) from accredited universities. Yes, there will be some cranks but this will be evened out by the possibility of the third tie-break reviewers.

In the large, a user could watch the “un-peer reviewed” articles stream to look for new ideas and but only reference those which are peer reviewed or something like that. This would make scholarship so much easier to do rather than having to deal with publishers (who in the end only rent back to us work that was given mostly for free, which is a monumentally insane way of doing things) and Jstor.

Let us say that you have a function that takes an input and based on that input does some calculations. Now, this is normal in Perl. For instance,

sub foo {
    my ($choice) = @_;
    my @float_lst;
    my $total;

    if($choice eq "win") {
        @float_lst = map { run_prediction($_) } (1..10);
        $total += $_ for @float_lst;
    } elsif($choice eq "lose")
        @float_lst = map { run_prediction($_) } (-1..-10);
        $total += $_ for @float_lst;
    } elsif($choice eq "draw") {
        @float_lst = map { run_prediction($_) } (0);
        $total += $_ for @float_lst;
    }
    return $total;
}

You probably notice that you repeat a rather long line of statements. In Ocaml, you can use currying to cut down on those (I am sure there are ways of doing this in Perl as well).

 type outcome = Win | Lose | Draw

 let wins = [1;2;3;4;5;6;7;8;9;10]
 let draw = [0]
 let lose = [-1;-2;-3;-4;-5;-6;-7;-8;-9;-10]

 let calc_outcome outcome =
     let calc_outcome_aux = BatList.map run_prediction in
     let fold_float = List.fold_left (+.) 0. in
         match outcome with
             | Win ->
                 fold_float (calc_outcome_aux wins)
             | Lose ->
                 fold_float (calc_outcome_aux lose)
             | Draw ->
                 fold_float (calc_outcome_aux draw)

Notice how I have called BatList.map and List.fold_left without the required number of arguments. This is not an “off by one error”. What the compiler does is break down the function into a set of single argument functions that it then stores the next in the chain in the lexical bindings. Once you have fulfilled the required number of arguments, it will return its answer. Of course, you can imagine using map over a function that has more than one argument that returns a list of functions that have the other required arguments left to fulfill. In addition, you can call functions where you know one argument will take a long time to compute so you can do the quick arguments first then compute the heavy argument.

In this case, I was able to cut down the length of a line and repeated statements and reuse them based on user input.