pzol

Monadic vs Imperative

Here is a comparison of two pieces of code that do basically the same thing.

So what we have here is a chain of functions depending on each other, each consecutive takes the result of the previous one for further processing. If either of them fails, the rest shall not be executed.

1. validate parameters received from the outside world in a Hash
2. convert one of the parameters into an object
3. do a search in the database

pzol

#!/usr/bin/env bash
apt-get -y update
apt-get -y upgrade
apt-get -y install build-essential zlib1g-dev libssl-dev libreadline-gplv2-dev libyaml-dev 
apt-get -y install autoconf curl git-core bzip2
apt-get -y autoremove
apt-get -y clean
cd /usr/local/src
wget ftp://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.3-p362.tar.gz
tar -xvzf ruby-1.9.3-p362.tar.gz

pzol

module Bmsapp
  module Booking
    class ActionController
      def initialize(ui, deps=Dependencies.new(:current_user => ui.current_user))
        @ui, @deps, @bms, @logger = ui, deps, deps.bms, deps.logger
      end

      def action(action_name, id, params)
        @booking     = @bms.booking_by_id(id)
        @params      = params

pzol

Create a mongo replicaset

tutorial

rsconf = {
           _id: "rs0",
           members: [
                      {
                       _id: 0,
                       host: "localhost:27017"

}

pzol

cd ~
sudo apt-get update
sudo apt-get install openjdk-7-jre -y

wget https://download.elasticsearch.org/elasticsearch/elasticsearch/elasticsearch-0.90.3.tar.gz -O elasticsearch.tar.gz
tar -xf elasticsearch.tar.gz
rm elasticsearch.tar.gz
sudo mv elasticsearch-* elasticsearch
sudo mv elasticsearch /opt/

pzol

enum List<T> {
    Cons(T, ~List<T>),
    Empty
}

fn length<T>(xs: &List<T>) -> uint {
  match *xs {
    Empty => 0,
    Cons(_, ref rest) => 1 + length(*rest)
  }

pzol

#[allow(dead_code, dead_assignment, unused_variable)];

// recursive types
enum List<T> {
    Cons(T, ~List<T>),
    Empty
}

fn length<T>(xs: &List<T>) -> uint {
  match *xs {

pzol

#[allow(dead_code, dead_assignment, unused_variable)];

// recursive types
enum List<T> {
    Cons(T, ~List<T>),
    Empty
}

fn length<T>(xs: &List<T>) -> uint {
  match *xs {

pzol

#[feature(struct_variant)];

struct  Bar { num: int}

#[test]
fn test_bar() {
  let bar = Bar { num: 1 };
  let Bar { num } = bar;
  assert!(num == 1);
}

pzol

enum TileSet {
  Empty,
  Dirt 
}

type XYZ   = (uint, uint, uint);

static MAXX: uint = 10;
static MAXY: uint = 10;
static MAXZ: uint = 1;