Merge pull request #1 from adambard/master

Merge from original adambard

1 files changed, 503 insertions, 0 deletions

diff --git a/vala.html.markdown b/vala.html.markdown
new file mode 100755
index 00000000..393578b0
--- /dev/null
+++ b/vala.html.markdown
@@ -0,0 +1,503 @@
+---
+language: vala
+contributors:
+    - ["Milo Gilad", "https://github.com/Myl0g"]
+filename: LearnVala.vala
+---
+
+In GNOME's own words, "Vala is a programming language that aims to bring modern programming language features to GNOME developers without imposing any additional runtime requirements and without using a different ABI compared to applications and libraries written in C."
+
+Vala has aspects of Java and C#, so it'll be natural to those who know either.
+
+[Read more here.](https://wiki.gnome.org/Projects/Vala)
+
+```vala
+
+// Single line comment
+
+/* Multiline
+Comment */
+
+/**
+* Documentation comment
+*/
+
+/* Data Types */
+
+char character = 'a'
+unichar unicode_character = 'u' // 32-bit unicode character
+
+int i = 2; // ints can also have guaranteed sizes (e.g. int64, uint64)
+uint j = -6; // Won't compile; unsigned ints can only be positive
+
+long k;
+
+short l;
+ushort m;
+
+string text = "Hello,"; // Note that the == operator will check string content
+
+string verbatim = """This is a verbatim (a.k.a. raw) string. Special characters
+(e.g. \n and "") are not interpreted. They may also be multiple lines long.""";
+
+// String Templates allow for easy string formatting
+string string_template = @"$text world"; // "$text" evaluates to "Hello,"
+
+int test = 5;
+int test2 = 10;
+string template2 = @"$(test * test2) is a number."; // Expression evaluation
+
+string template_slice = string_template[7:12]; // => "world"
+
+// Most data types have methods for parsing.
+
+bool parse_bool = bool.parse("false"); // => false
+int parse_int = int.parse("-52"); // => -52
+string parse_string = parse_int.to_string(); // => "-52"
+
+/* Basic I/O */
+
+stdout.printf(parse_string); // Prints to console
+string input = stdin.read_line(); // Gets input from console
+
+stderr.printf("Error message"); // Error printing
+
+/* Arrays */
+
+int[] int_array = new int[10]; // Array of ints with 10 slots
+int better_int_array[10]; // Above expression, shortened
+int_array.length; // => 10;
+
+int[] int_array2 = {5, 10, 15, 20}; // Can be created on-the-fly
+
+int[] array_slice = int_array2[1:3]; // Slice (copy of data)
+unowned int[] array_slice_ref = int_array2[1:3]; // Reference to data
+
+// Multi-dimensional Arrays (defined with a number of commas in the brackets)
+
+int[,] multi_array = new int[6,4]; // 6 is the number of arrays, 4 is their size
+int[,] multi_array2 = {{7, 4, 6, 4},
+                       {3, 2, 4, 6},
+                       {5, 9, 5, 1}}; // new int[3,4]
+multi_array2[2,3] = 12; // 2 is the array, 3 is the index in the array
+int first_d = multi_array2.length[0] // => 3
+int second_d = multi_array2.length[1] // => 4
+
+// Stacked arrays (e.g. int[][]) where array lengths vary are not supported.
+
+// Multi-dimensional arrays cannot be sliced, nor can they be converted to one-
+// dimensional.
+
+int[] add_to_array = {};
+add_to_array += 12; // Arrays can be dynamically added to
+
+add_to_array.resize(20); // Array now has 20 slots
+
+uint8[] chars = "test message".data;
+chars.move(5, 0, 7);
+stdout.printf((string) chars); // Casts the array to a string and prints it
+
+/* Control Flow */
+
+int a = 1;
+int b = 2;
+int[] foreach_demo = {2, 4, 6, 8};
+
+while (b > a) { // While loop; checks if expression is true before executing
+  b--;
+}
+
+do {
+  b--;
+}
+while (b > a); // Do While loop; executes the code in "do" before while (b > a)
+
+for (a = 0; a < 10; a++) { stdout.printf("%d\n", a); } // for loop
+
+foreach (int foreach_demo_var in foreach_demo) {
+  stdout.printf("%d\n", foreach_demo_var);
+} // foreach works on any iterable collection
+
+if (a == 0) {
+  stdout.printf("%d\n", a);
+} else if (a > 1) {
+  stdout.printf("%d\n", a);
+} else {
+  stdout.printf("A is less than 0");
+} // if-then-else
+
+switch (a) {
+  case 1:
+    stdout.printf("A is 1\n");
+    break;
+  case 5:
+  case 10:
+    stdout.printf("A is 5 or 10\n");
+    break;
+  default:
+    stdout.printf("???\n")
+    break;
+} // switch statement
+
+/* Type Casting and Inference */
+
+int cast_to_float = 10;
+float casted_float = (float) cast_to_float; // static casting; no runtime checks
+
+// For runtime checks, use dynamic casting.
+// Dynamically casted objects must be the following:
+// - Object's class is the same class as the desired type
+// - Object's class is a subclass of the desired type
+// - Desired class is an interface implemented by the object's class
+
+float dyna_casted_float = cast_to_float as float // Won't compile
+
+var inferred_string = "hello"; // Type inference
+
+/* Methods (a.k.a. functions) */
+
+int method_demo(string arg1, Object arg2) { // Returns int and takes args
+    return 1;
+}
+
+// Vala methods cannot be overloaded.
+
+void some_method(string text) { }
+void some_method(int number) { }  // Won't compile
+
+// To achieve similar functionality, use default argument values.
+
+void some_better_method(string text, int number = 0) { }
+
+some_better_method("text");
+some_better_method("text", 12);
+
+// varargs (variable-length argument lists) are also supported.
+
+void method_with_varargs(int arg1, ...) {
+    var varargs_list = va_list(); // gets the varargs list
+
+    string arg_string = varargs_list.arg(); // gets arguments, one after another
+    int int_vararg = varargs_list.arg();
+
+    stdout.printf("%s, %d\n", arg_string, int_vararg)
+}
+
+string? ok_to_be_null(int? test_int) { } // "?" denotes possible null value
+
+// Delegates
+
+delegate void DelegateDemo(char char_a);
+
+void delegate_match(char char_a) { // Matches DelegateDemo's signature
+  stdout.printf("%d\n");
+}
+
+void call_delegate(DelegateDemo d, char char_b) { // Takes a delegate arg
+  d(char_b) // calls delegate
+}
+
+void final_delegate_demo() {
+  call_delegate(delegate_match); // Passes matching method as argument
+}
+
+// Lambdas (a.k.a. Anonymous Methods) are defined with "=>"
+
+(a) => { stdout.printf("%d\n", a); } // Prints "a"
+
+/* Namespaces */
+
+namespace NamespaceDemo {
+  // Allows you to organize variable names
+  int namespace_int = 12;
+}
+namespace_int += 5; // Won't compile
+
+using NamespaceDemo;
+namespace_int += 5; // Valid
+
+/* Structs and Enums */
+
+struct Closet {
+  public uint shirts; // Default access modifier is private
+  public uint jackets;
+}
+
+Closet struct_init_1 = Closet(); // or Closet struct_init_1 = {};
+Closet struct_init_2 = {15, 3};
+var struct_init_3 = Closet() { // Type inference also works
+  shirts = 15;
+  jackets = 3;
+}
+
+enum HouseSize { // An example of an enum
+  SMALL,
+  MODERATE,
+  BIG
+}
+
+/* Classes and Object-Oriented Programming */
+
+class Message : GLib.Object { // Class Message extends GLib's Object
+  private string sender; // a private field
+  public string text {get; set;} // a public property (more on that later)
+  protected bool is_digital = true; // protected (this class and subclasses)
+  internal bool sent = false; // internal (classes in same package)
+
+  public void send(string sender) { // public method
+    this.sender = sender;
+    sent = true;
+  }
+
+  public Message() { // Constructor
+    // ...
+  }
+
+}
+
+// Since method overloading isn't possible, you can't overload constructors.
+// However, you can use named constructors to achieve the same functionality.
+
+public class Calculator : GLib.Object {
+
+    public Calculator() {
+    }
+
+    public Calculator.with_name(string name) {
+    }
+
+    public Calculator.model(string model_id, string name = "") {
+      this.with_name(@"$model_id $name"); // Chained constructors with "this"
+    }
+    ~Calculator() { } // Only needed if you're using manual memory management
+}
+
+var calc1 = new Calculator.with_name("Temp");
+var calc2 = new Calculator.model("TI-84");
+
+// Signals (a.k.a. events or event listeners) are a way to execute multiple
+// methods with the same signature at the same time.
+
+public class SignalDemo : GLib.Object {
+  public signal void sig_demo(int sig_demo_int); // Must be public
+
+  public static int main(string[] args) {
+    // main method; program does not compile without it
+
+    var sig_demo_class = new SignalDemo(); // New instance of class
+
+    sig_demo_class.sig_demo.connect((ob, sig_int) => { // Lambda used as handler
+        stdout.printf("%d\n", sig_int); // "ob" is object on which it is emitted
+      });
+
+    sig_demo_class.sig_demo(27); // Signal is emitted
+
+    return 0;
+  }
+}
+
+// You may use the connect() method and attach as many handlers as you'd like.
+// They'll all run at around the same time when the signal is emitted.
+
+// Properties (getters and setters)
+
+class Animal : GLib.Object {
+  private int _legs; // prefixed with underscore to prevent name clashes
+
+  public int legs {
+    get { return _legs; }
+    set { _legs = value; }
+  }
+
+  public int eyes { get; set; default = 5; } // Shorter way
+  public int kingdom { get; private set; default = "Animalia"} // Read-only
+
+  public static void main(string args[]) {
+    rabbit = new Animal();
+
+    // All GLib.Objects have a signal "notify" emitted when a property changes.
+
+    // If you specify a specific property, replace all underscores with dashes
+    // to conform to the GObject naming convention.
+
+    rabbit.notify["eyes"].connect((s, p) => { // Remove the ["eyes"] for all
+      stdout.printf("Property '%s' has changed!\n", p.name);
+    });
+
+    rabbit.legs = 2;
+    rabbit.legs += 2;
+    rabbit.eyes = 2;
+
+  }
+}
+
+// Inheritance: Vala classes may inherit 1 class. Inheritance is not implicit.
+
+class SuperDemo : GLib.Object {
+  public int data1;
+  protected int data2;
+  internal int data3;
+  private int data4;
+
+  public static void test_method {  } // Statics can be called w/out an object
+}
+class SubDemo : SuperDemo {
+  public static void main(string args[]) {
+    stdout.printf((string) data1); // Will compile
+    stdout.printf((string) data2); // Protected can be accessed by subclasses
+    stdout.printf((string) data3); // Internal is accessible to package
+    stdout.printf((string) data4); // Won't compile
+  }
+}
+
+// Abstract Classes and Methods
+
+public abstract class OperatingSystem : GLib.Object {
+  public void turn_on() {
+    stdout.printf("Booted successfully.\n");
+  }
+  public abstract void use_computer();
+}
+
+public class Linux : OperatingSystem {
+  public override void use_computer() { // Abstract methods must be overridden
+    stdout.printf("Beep boop\n");
+  }
+}
+
+// Add default behavior to an abstract method by making it "virtual".
+
+public abstract class HardDrive : GLib.Object {
+  public virtual void die() {
+    stdout.printf("CLICK-CLICK-CLICK\n");
+  }
+}
+public class MyHD : HardDrive {
+  public override void die() {
+    return;
+  }
+}
+
+// Interfaces: classes can implement any number of these.
+
+interface Laptop { // May only contain abstracts or virtuals
+  public abstract void turn_on();
+  public abstract void turn_off();
+
+  public abstract int cores; // Won't compile; fields cannot be abstract
+  public abstract int cores {get; set;} // Will compile
+
+  public virtual void keyboard() { // Virtuals are allowed (unlike Java/C#)
+    stdout.printf("Clickity-clack\n");
+  }
+}
+
+// The ability to use virtuals in Vala means that multiple inheritance is
+// possible (albeit somewhat confined)
+
+// Interfaces cannot implement interfaces, but they may specify that certain
+// interfaces or classes must be also implemented (pre-requisites).
+
+public interface CellPhone : Collection, GLib.Object {}
+
+// You can get the type info of a class at runtime dynamically.
+
+bool type_info = object is TypeName; // uses "is" to get a bool
+
+Type type_info2 = object.get_type();
+var type_name = type_info2.name();
+
+Type type_info3 = typeof(Linux);
+Linux type_demo = (Linux) Object.new(type_info3);
+
+// Generics
+
+class Computer<OperatingSystem> : GLib.Object {
+  private OperatingSystem os;
+
+  public void install_os(OperatingSystem os) {
+    this.os = os;
+  }
+  public OperatingSystem retrieve_os() {
+    return this.os;
+  }
+}
+
+var new_computer = new Computer<Linux>();
+
+/* Other Features */
+
+// Assertions: crash if a statement is not true (at runtime)
+
+bool is_true = true;
+assert(is_true);
+
+// Contract Programming
+
+int contract_demo(int arg1, int arg2) {
+  requires(arg1 > 0 && arg1 < 10) // Notice the lack of semicolon
+  requires(arg2 >= 12)
+  ensures(result >= 0)
+}
+
+// Error Handling
+
+void error_demo(int int_ex) throws GError {
+  if (int_ex != 1) {
+    throw new GError("TEST MESSAGE");
+  }
+}
+void error_demo2() {
+  try {
+    error_demo(0);
+  } catch (GError ge) {
+    stdout.printf("%s\n", ge.message);
+  }
+}
+
+// Main Loop
+
+void main() {
+
+  var main_loop = new MainLoop();
+  var time = new TimeoutSource(2000);
+
+  time.set_callback(() => { // Executes the following lambda after 2000ms
+      stdout.printf("2000ms have passed\n");
+      main_loop.quit();
+      return false;
+  });
+
+  time.attach(main_loop.get_context());
+
+  loop.run();
+}
+
+// Pointers (manual memory management)
+
+Object* pointer_obj = new Object(); // Creates Object instance and gives pointer
+
+pointer_obj->some_method(); // Executes some_method
+pointer_obj->some_data; // Returns some_data
+
+delete pointer_obj;
+
+int more = 57;
+int* more_pointer = &i; // & = address-of
+int indirection_demo = more_pointer*; // indirection
+
+// Profiles: affect which Vala features are avaliable and which libraries the
+// C-code will use.
+// - gobject (default)
+// posix
+// dova
+// Use "--profile=whatever" when compiling.
+
+```
+* More Vala documentation can be found [here](https://valadoc.org/).
+* [Alternate construction syntax](https://wiki.gnome.org/Projects/Vala/Tutorial#GObject-Style_Construction) similar to GObject
+* More on contract programming [here](http://en.wikipedia.org/wiki/Contract_programming)
+* Collections library can be found [here](https://wiki.gnome.org/Projects/Vala/Tutorial#Collections)
+* [Multithreading](https://wiki.gnome.org/Projects/Vala/Tutorial#Multi-Threading)
+* Read about building GUIs with GTK+ and Vala [here](http://archive.is/7C7bw).
+* D-Bus [integration](https://wiki.gnome.org/Projects/Vala/Tutorial#D-Bus_Integration)