Merge branch 'master' into isabelle-grammar

Conflicts:
	grammars.yml

grammars.yml

@@ -63,6 +63,8 @@ https://github.com/Varriount/NimLime:
 - source.nimrodcfg
 https://github.com/angryant0007/VBDotNetSyntax:
 - source.vbnet
+https://github.com/anunayk/cool-tmbundle:
+- source.cool
 https://github.com/aroben/ada.tmbundle/raw/c45eed4d5f98fe3bcbbffbb9e436601ab5bbde4b/Syntaxes/Ada.plist:
 - source.ada
 https://github.com/aroben/ruby.tmbundle@4636a3023153c3034eb6ffc613899ba9cf33b41f:
@@ -137,6 +139,8 @@ https://github.com/fsharp/fsharpbinding:
 - source.fsharp
 https://github.com/gingerbeardman/monkey.tmbundle:
 - source.monkey
+https://github.com/alkemist/gradle.tmbundle:
+- source.groovy.gradle
 https://github.com/guillermooo/dart-sublime-bundle/raw/master/Dart.tmLanguage:
 - source.dart
 https://github.com/harrism/sublimetext-cuda-cpp/raw/master/cuda-c%2B%2B.tmLanguage:
@@ -410,3 +414,5 @@ https://github.com/whitequark/llvm.tmbundle:
 - source.llvm
 https://github.com/lsf37/Isabelle.tmbundle:
 - source.isabelle.theory
+https://github.com/eregon/oz-tmbundle:
+- source.oz

lib/linguist/heuristics.rb

@@ -94,9 +94,11 @@ module Linguist
       end
     end
 
-    disambiguate "Common Lisp", "OpenCL" do |data|
+    disambiguate "Common Lisp", "OpenCL", "Cool" do |data|
       if data.include?("(defun ")
         Language["Common Lisp"]
+      elsif /^class/x.match(data)
+        Language["Cool"]
       elsif /\/\* |\/\/ |^\}/.match(data)
         Language["OpenCL"]
       end
@@ -139,5 +141,9 @@ module Linguist
         Language["GLSL"]
       end
     end
+
+    disambiguate "Gosu", "JavaScript" do |data|
+      Language["Gosu"] if /^uses java\./.match(data)
+    end    
   end
 end

lib/linguist/languages.yml

@@ -527,6 +527,12 @@ Component Pascal:
   - delphi
   - objectpascal
 
+Cool:
+  type: programming
+  extensions:
+  - .cl
+  tm_scope: source.cool
+
 Coq:
   type: programming
   extensions:
@@ -968,6 +974,12 @@ Grace:
   - .grace
   tm_scope: none
 
+Gradle:
+  type: data
+  extensions:
+  - .gradle
+  tm_scope: source.groovy.gradle
+
 Grammatical Framework:
   type: programming
   aliases:
@@ -1297,6 +1309,7 @@ JavaScript:
   - .bones
   - .es6
   - .frag
+  - .gs
   - .jake
   - .jsb
   - .jsfl
@@ -1603,6 +1616,8 @@ Mercury:
   type: programming
   color: "#abcdef"
   ace_mode: prolog
+  interpreters:
+  - mmi
   extensions:
   - .m
   - .moo
@@ -1843,6 +1858,13 @@ Oxygene:
   - .oxygene
   tm_scope: none
   
+Oz:
+  type: programming
+  color: "#fcaf3e"
+  extensions:
+  - .oz
+  tm_scope: source.oz
+
 PAWN:
   type: programming
   color: "#dbb284"
@@ -2130,6 +2152,15 @@ R:
   interpreters:
   - Rscript
 
+RAML:
+  type: data
+  lexer: YAML
+  ace_mode: yaml
+  tm_scope: source.yaml
+  color: "#77d9fb"
+  extensions:
+    - .raml
+
 RDoc:
   type: prose
   ace_mode: rdoc

lib/linguist/vendor.yml

@@ -232,9 +232,6 @@
 # .DS_Store's
 - .[Dd][Ss]_[Ss]tore$
 
-# Mercury --use-subdirs
-- Mercury/
-
 # R packages
 - ^vignettes/
 - ^inst/extdata/

samples/Cool/list.cl

@@ -0,0 +1,26 @@
+(* This simple example of a list class is adapted from an example in the
+   Cool distribution. *)
+
+class List {
+   isNil() : Bool { true };
+   head()  : Int { { abort(); 0; } };
+   tail()  : List { { abort(); self; } };
+   cons(i : Int) : List {
+      (new Cons).init(i, self)
+   };
+};
+
+class Cons inherits List {
+   car : Int;	-- The element in this list cell
+   cdr : List;	-- The rest of the list
+   isNil() : Bool { false };
+   head()  : Int { car };
+   tail()  : List { cdr };
+   init(i : Int, rest : List) : List {
+      {
+	 car <- i;
+	 cdr <- rest;
+	 self;
+      }
+   };
+};

samples/Cool/sample.cl

@@ -0,0 +1,71 @@
+(* Refer to Alex Aiken, "The Cool Reference Manual":
+    http://theory.stanford.edu/~aiken/software/cool/cool-manual.pdf
+   for language specification.
+*)
+
+-- Exhibit various language constructs
+class Sample {
+    testCondition(x: Int): Bool {
+        if x = 0
+        then false
+        else
+            if x < (1 + 2) * 3
+            then true
+            else false
+            fi
+        fi
+    };
+
+    testLoop(y: Int): Bool {
+        while y > 0 loop
+        {
+            if not condition(y)
+            then y <- y / 2
+            else y <- y - 1;
+        }
+        pool
+    };
+
+    testAssign(z: Int): Bool {
+        i : Int;
+        i <- ~z;
+    };
+
+    testCase(var: Sample): SELF_TYPE {
+        io : IO <- new IO;
+        case var of
+            a : A => io.out_string("Class type is A\n");
+            b : B => io.out_string("Class type is B\n");
+            s : Sample => io.out_string("Class type is Sample\n");
+            o : Object => io.out_string("Class type is object\n");
+        esac
+    };
+
+    testLet(i: Int): Int {
+        let (a: Int in
+            let(b: Int <- 3, c: Int <- 4 in
+                {
+                    a <- 2;
+                    a * b * 2 / c;
+                }
+            )
+        )
+    };
+};
+
+-- Used to test subclasses
+class A inherits Sample {};
+class B inherits A {};
+
+class C {
+    main() : Int {
+        (new Sample).testLet(1)
+    };
+};
+
+-- "Hello, world" example
+class Main inherits IO {
+    main(): SELF_TYPE {
+        out_string("Hello, World.\n")
+    };
+};

samples/Gosu/Ronin.gs

@@ -0,0 +1,238 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+package ronin
+
+uses gw.util.concurrent.LockingLazyVar
+uses gw.lang.reflect.*
+uses java.lang.*
+uses java.io.*
+uses ronin.config.*
+uses org.slf4j.*
+
+/**
+ *  The central location for Ronin utility methods.  Controllers and templates should generally access the
+ *  methods and properties they inherit from {@link ronin.IRoninUtils} instead of using the methods and
+ *  properties here.
+ */
+class Ronin {
+
+  // One static field to rule the all...
+  static var _CONFIG : IRoninConfig as Config
+
+  // And one thread local to bind them
+  static var _CURRENT_REQUEST = new ThreadLocal<RoninRequest>();
+
+  // That's inconstructable
+  private construct() {}
+
+  internal static function init(servlet : RoninServlet, m : ApplicationMode, src : File) {
+    if(_CONFIG != null) {
+      throw "Cannot initialize a Ronin application multiple times!"
+    }
+    var cfg = TypeSystem.getByFullNameIfValid("config.RoninConfig")
+    var defaultWarning = false
+    if(cfg != null) {
+      var ctor = cfg.TypeInfo.getConstructor({ronin.config.ApplicationMode, ronin.RoninServlet})
+      if(ctor == null) {
+        throw "config.RoninConfig must have a constructor with the same signature as ronin.config.RoninConfig"
+      }
+      _CONFIG = ctor.Constructor.newInstance({m, servlet}) as IRoninConfig
+    } else {
+      _CONFIG = new DefaultRoninConfig(m, servlet)
+      defaultWarning = true
+    }
+    var roninLogger = TypeSystem.getByFullNameIfValid("ronin.RoninLoggerFactory")
+    if(roninLogger != null) {
+      roninLogger.TypeInfo.getMethod("init", {ronin.config.LogLevel}).CallHandler.handleCall(null, {LogLevel})
+    }
+    if(defaultWarning) {
+      log("No configuration was found at config.RoninConfig, using the default configuration...", :level=WARN)
+    }
+    Quartz.maybeStart()
+    ReloadManager.setSourceRoot(src)
+  }
+
+  internal static property set CurrentRequest(req : RoninRequest) {
+    _CURRENT_REQUEST.set(req)
+  }
+
+  //============================================
+  // Public API
+  //============================================
+
+  /**
+   *  The trace handler for the current request.
+   */
+  static property get CurrentTrace() : Trace {
+    return CurrentRequest?.Trace
+  }
+
+  /**
+   *  Ronin's representation of the current request.
+   */
+  static property get CurrentRequest() : RoninRequest {
+    return _CURRENT_REQUEST.get()
+  }
+
+  /**
+   *  The mode in which this application is running.
+   */
+  static property get Mode() : ApplicationMode {
+    return _CONFIG?.Mode ?: TESTING
+  }
+
+  /**
+   *  The log level at and above which log messages should be displayed.
+   */
+  static property get LogLevel() : LogLevel {
+    return _CONFIG?.LogLevel ?: DEBUG
+  }
+
+  /**
+   *  Whether or not to display detailed trace information on each request.
+   */
+  static property get TraceEnabled() : boolean {
+    return _CONFIG != null ? _CONFIG.TraceEnabled : true
+  }
+
+  /**
+   *  The default controller method to call when no method name is present in the request URL.
+   */
+  static property get DefaultAction() : String {
+    return _CONFIG?.DefaultAction
+  }
+
+  /**
+   *  The default controller to call when no controller name is present in the request URL.
+   */
+  static property get DefaultController() : Type {
+    return _CONFIG?.DefaultController
+  }
+
+  /**
+   *  The servlet responsible for handling Ronin requests.
+   */
+  static property get RoninServlet() : RoninServlet {
+    return _CONFIG?.RoninServlet
+  }
+
+  /**
+   *  The handler for request processing errors.
+   */
+  static property get ErrorHandler() : IErrorHandler {
+    return _CONFIG?.ErrorHandler
+  }
+
+  /**
+   *  The custom handler for logging messages.
+   */
+  static property get LogHandler() : ILogHandler {
+    return _CONFIG?.LogHandler
+  }
+
+  /**
+   *  Logs a message using the configured log handler.
+   *  @param msg The text of the message to log, or a block which returns said text.
+   *  @param level (Optional) The level at which to log the message.
+   *  @param component (Optional) The logical component from whence the message originated.
+   *  @param exception (Optional) An exception to associate with the message.
+   */
+  static function log(msg : Object, level : LogLevel = null, component : String = null, exception : java.lang.Throwable = null) {
+    if(level == null) {
+      level = INFO
+    }
+    if(LogLevel <= level) {
+      var msgStr : String
+      if(msg typeis block():String) {
+        msgStr = (msg as block():String)()
+      } else {
+        msgStr = msg as String
+      }
+      if(_CONFIG?.LogHandler != null) {
+        _CONFIG.LogHandler.log(msgStr, level, component, exception)
+      } else {
+        switch(level) {
+          case TRACE:
+            LoggerFactory.getLogger(component?:Logger.ROOT_LOGGER_NAME).trace(msgStr, exception)
+            break
+          case DEBUG:
+            LoggerFactory.getLogger(component?:Logger.ROOT_LOGGER_NAME).debug(msgStr, exception)
+            break
+          case INFO:
+            LoggerFactory.getLogger(component?:Logger.ROOT_LOGGER_NAME).info(msgStr, exception)
+            break
+          case WARN:
+            LoggerFactory.getLogger(component?:Logger.ROOT_LOGGER_NAME).warn(msgStr, exception)
+            break
+          case ERROR:
+          case FATAL:
+            LoggerFactory.getLogger(component?:Logger.ROOT_LOGGER_NAME).error(msgStr, exception)
+            break
+        }
+      }
+    }
+  }
+
+  /**
+   *  The caches known to Ronin.
+   */
+  static enum CacheStore {
+    REQUEST,
+    SESSION,
+    APPLICATION
+  }
+
+  /**
+   *  Retrieves a value from a cache, or computes and stores it if it is not in the cache.
+   *  @param value A block which will compute the desired value.
+   *  @param name (Optional) A unique identifier for the value.  Default is null, which means one will be
+   *  generated from the type of the value.
+   *  @param store (Optional) The cache store used to retrieve or store the value.  Default is the request cache.
+   *  @return The retrieved or computed value.
+   */
+  static function cache<T>(value : block():T, name : String = null, store : CacheStore = null) : T {
+    if(store == null or store == REQUEST) {
+      return _CONFIG.RequestCache.getValue(value, name)
+    } else if (store == SESSION) {
+      return _CONFIG.SessionCache.getValue(value, name)
+    } else if (store == APPLICATION) {
+      return _CONFIG.ApplicationCache.getValue(value, name)
+    } else {
+      throw "Don't know about CacheStore ${store}"
+    }
+  }
+
+  /**
+   *  Invalidates a cached value in a cache.
+   *  @param name The unique identifier for the value.
+   *  @param store The cache store in which to invalidate the value.
+   */
+  static function invalidate<T>(name : String, store : CacheStore) {
+    if(store == null or store == REQUEST) {
+      _CONFIG.RequestCache.invalidate(name)
+    } else if (store == SESSION) {
+      _CONFIG.SessionCache.invalidate(name)
+    } else if (store == APPLICATION) {
+      _CONFIG.ApplicationCache.invalidate(name)
+    } else {
+      throw "Don't know about CacheStore ${store}"
+    }
+  }
+
+
+  /**
+   *  Detects changes made to resources in the Ronin application and
+   *  reloads them.  This function should only be called when Ronin is
+   *  in development mode.
+   */
+  static function loadChanges() {
+    ReloadManager.detectAndReloadChangedResources() 
+  }
+
+}

samples/Gradle/build.gradle

@@ -0,0 +1,18 @@
+apply plugin: GreetingPlugin
+
+greeting.message = 'Hi from Gradle'
+
+class GreetingPlugin implements Plugin<Project> {
+    void apply(Project project) {
+        // Add the 'greeting' extension object
+        project.extensions.create("greeting", GreetingPluginExtension)
+        // Add a task that uses the configuration
+        project.task('hello') << {
+            println project.greeting.message
+        }
+    }
+}
+
+class GreetingPluginExtension {
+    def String message = 'Hello from GreetingPlugin'
+}

samples/Gradle/builder.gradle

@@ -0,0 +1,20 @@
+apply plugin: GreetingPlugin
+
+greeting {
+    message = 'Hi'
+    greeter = 'Gradle'
+}
+
+class GreetingPlugin implements Plugin<Project> {
+    void apply(Project project) {
+        project.extensions.create("greeting", GreetingPluginExtension)
+        project.task('hello') << {
+            println "${project.greeting.message} from ${project.greeting.greeter}"
+        }
+    }
+}
+
+class GreetingPluginExtension {
+    String message
+    String greeter
+}

samples/JavaScript/chart_composers.gs

@@ -0,0 +1,78 @@
+/*
+License
+Copyright [2013] [Farruco Sanjurjo Arcay]
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+*/
+
+var TagsTotalPerMonth;
+
+TagsTotalPerMonth = (function(){
+  function TagsTotalPerMonth(){};
+  
+  TagsTotalPerMonth.getDatasource = function (category, months, values){
+    return new CategoryMonthlyExpenseBarChartDataSource(category, months, values);
+  };
+  
+  TagsTotalPerMonth.getType = function (){ return Charts.ChartType.COLUMN};
+  
+  return TagsTotalPerMonth;
+})();
+
+
+var TagsTotalPerMonthWithMean;
+
+TagsTotalPerMonthWithMean = (function(){
+  function TagsTotalPerMonthWithMean(){};
+  
+  TagsTotalPerMonthWithMean.getDatasource = function (category, months, values){
+    return new CategoryMonthlyWithMeanExpenseDataSource(category, months, values);
+  };
+  
+  TagsTotalPerMonthWithMean.getType = function (){ return Charts.ChartType.LINE};
+  
+  return TagsTotalPerMonthWithMean;
+})();
+
+
+var TagsAccumulatedPerMonth;
+
+TagsAccumulatedPerMonth = (function(){
+  function TagsAccumulatedPerMonth(){};
+  
+  TagsAccumulatedPerMonth.getDatasource = function (category, months, values){
+    return new CategoryMonthlyAccumulated(category, months, values);
+  };
+  
+  TagsAccumulatedPerMonth.getType = function (){ return Charts.ChartType.AREA};
+  
+  return TagsAccumulatedPerMonth;
+})();
+
+var MonthTotalsPerTags;
+
+MonthTotalsPerTags = (function(){
+  function MonthTotalsPerTags(){};
+
+  MonthTotalsPerTags.getDatasource = function (month, tags, values){
+    return new CategoryExpenseDataSource(tags, month, values); 
+  };
+  
+  MonthTotalsPerTags.getType = function (){ return Charts.ChartType.PIE; };
+  
+  return MonthTotalsPerTags;
+})();
+
+var SavingsFlowChartComposer = (function(){
+  function SavingsFlowChartComposer(){};
+  
+  SavingsFlowChartComposer.getDatasource = function(months, values){
+    return new SavingsFlowDataSource(months, values);
+  };
+  
+  SavingsFlowChartComposer.getType = function(){ return Charts.ChartType.COLUMN; };
+  
+  return SavingsFlowChartComposer;
+})();

samples/JavaScript/itau.gs

@@ -0,0 +1,150 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2014 Thiago Brandão Damasceno
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+// based on http://ctrlq.org/code/19053-send-to-google-drive
+function sendToGoogleDrive() {
+
+  var gmailLabels           = 'inbox';
+  var driveFolder           = 'Itaú Notifications';
+  var spreadsheetName       = 'itau';
+  var archiveLabel          = 'itau.processed';
+  var itauNotificationEmail = 'comunicacaodigital@itau-unibanco.com.br';
+  var filter                = "from: " +
+                              itauNotificationEmail +
+                              " -label:" +
+                              archiveLabel +
+                              " label:" +
+                              gmailLabels;
+
+  // Create label for 'itau.processed' if it doesn't exist
+  var moveToLabel =  GmailApp.getUserLabelByName(archiveLabel);
+
+  if (!moveToLabel) {
+    moveToLabel = GmailApp.createLabel(archiveLabel);
+  }
+
+  // Create folder 'Itaú Notifications' if it doesn't exist
+  var folders = DriveApp.getFoldersByName(driveFolder);
+  var folder;
+
+  if (folders.hasNext()) {
+    folder = folders.next();
+  } else {
+    folder = DriveApp.createFolder(driveFolder);
+  }
+
+  // Create spreadsheet file 'itau' if it doesn't exist
+  var files = folder.getFilesByName(spreadsheetName);
+
+  // File is in DriveApp
+  // Doc is in SpreadsheetApp
+  // They are not interchangeable
+  var file, doc;
+
+  // Confusing :\
+  // As per: https://code.google.com/p/google-apps-script-issues/issues/detail?id=3578
+  if (files.hasNext()){
+    file = files.next();
+    doc = SpreadsheetApp.openById(file.getId());
+  } else {
+    doc = SpreadsheetApp.create(spreadsheetName);
+    file = DriveApp.getFileById(doc.getId());
+    folder.addFile(file);
+    DriveApp.removeFile(file);
+  }
+
+  var sheet = doc.getSheets()[0];
+
+  // Append header if first line
+  if(sheet.getLastRow() == 0){
+    sheet.appendRow(['Conta', 'Operação', 'Valor', 'Data', 'Hora', 'Email ID']);
+  }
+
+  var message, messages, account, operation, value, date, hour, emailID, plainBody;
+  var accountRegex = /Conta: (XXX[0-9\-]+)/;
+  var operationRegex = /Tipo de operação: ([A-Z]+)/;
+  var paymentRegex = /Pagamento de ([0-9A-Za-z\-]+)\ ?([0-9]+)?/;
+  var valueRegex = /Valor: R\$ ([0-9\,\.]+)/;
+  var dateRegex = /Data: ([0-9\/]+)/;
+  var hourRegex = /Hora: ([0-9\:]+)/;
+  var emailIDRegex = /E-mail nº ([0-9]+)/;
+
+  var threads = GmailApp.search(filter, 0, 100);
+
+  for (var x = 0; x < threads.length; x++) {
+    messages = threads[x].getMessages();
+
+    for (var i = 0; i < messages.length; i++) {
+      account, operation, value, date, hour, emailID = [];
+
+      message = messages[i];
+
+      plainBody = message.getPlainBody();
+
+      if(accountRegex.test(plainBody)) {
+        account = RegExp.$1;
+      }
+
+      if(operationRegex.test(plainBody)) {
+        operation = RegExp.$1;
+      }
+
+      if(valueRegex.test(plainBody)) {
+        value = RegExp.$1;
+      }
+
+      if(dateRegex.test(plainBody)) {
+        date = RegExp.$1;
+      }
+
+      if(hourRegex.test(plainBody)) {
+        hour = RegExp.$1;
+      }
+
+      if(emailIDRegex.test(plainBody)){
+        emailID = RegExp.$1;
+      }
+
+      if(paymentRegex.test(plainBody)){
+        operation = RegExp.$1;
+        if(RegExp.$2){
+          operation += ' ' + RegExp.$2
+        }
+        date = hour = ' - ';
+      }
+
+      if(account && operation && value && date && hour){
+        sheet.appendRow([account, operation, value, date, hour, emailID]);
+      }
+
+      // Logger.log(account);
+      // Logger.log(operation);
+      // Logger.log(value);
+      // Logger.log(date);
+      // Logger.log(hour);
+    }
+
+    threads[x].addLabel(moveToLabel);
+  }
+}

samples/Oz/example.oz

@@ -0,0 +1,52 @@
+% You can get a lot of information about Oz by following theses links  :
+% - http://mozart.github.io/
+% - http://en.wikipedia.org/wiki/Oz_(programming_language)
+% There is also a well known book that uses Oz for pedagogical reason :
+% - http://mitpress.mit.edu/books/concepts-techniques-and-models-computer-programming
+% And there are two courses on edX about 'Paradigms of Computer Programming' that also uses Oz for pedagogical reason :
+% - https://www.edx.org/node/2751#.VHijtfl5OSo
+% - https://www.edx.org/node/4436#.VHijzfl5OSo
+%
+% Here is an example of some code written with Oz.
+
+declare
+% Computes the sum of square of the N first integers.
+fun {Sum N}
+  local SumAux in
+    fun {SumAux N Acc}
+      if N==0 then Acc
+      else
+        {Sum N-1 Acc}
+      end
+    end
+    {SumAux N 0}
+  end
+end
+
+% Returns true if N is a prime and false otherwize
+fun {Prime N}
+  local PrimeAcc in
+    fun {PrimeAcc N Acc}
+	    if(N == 1) then false
+	    elseif(Acc == 1) then true
+	    else
+	      if (N mod Acc) == 0 then false
+	      else
+	       {PrimeAcc N Acc-1}
+	      end
+	   end
+    end
+  {PrimeAcc N (N div 2)}
+  end
+end
+
+% Reverse a list using cells and for loop (instead of recursivity)
+fun {Reverse L}
+  local RevList in
+    RevList = {NewCell nil}
+    for E in L do
+      RevList := E|@RevList
+    end
+    @RevList
+  end
+end

samples/RAML/api.raml

@@ -0,0 +1,39 @@
+#%RAML 0.8
+
+title: World Music API
+baseUri: http://example.api.com/{version}
+version: v1
+traits:
+  - paged:
+      queryParameters:
+        pages:
+          description: The number of pages to return
+          type: number
+  - secured: !include http://raml-example.com/secured.yml
+/songs:
+  is: [ paged, secured ]
+  get:
+    queryParameters:
+      genre:
+        description: filter the songs by genre
+  post:
+  /{songId}:
+    get:
+      responses:
+        200:
+          body:
+            application/json:
+              schema: |
+                { "$schema": "http://json-schema.org/schema",
+                  "type": "object",
+                  "description": "A canonical song",
+                  "properties": {
+                    "title":  { "type": "string" },
+                    "artist": { "type": "string" }
+                  },
+                  "required": [ "title", "artist" ]
+                }
+            application/xml:
+    delete:
+      description: |
+        This method will *delete* an **individual song**