summaryrefslogtreecommitdiffhomepage
diff options
context:
space:
mode:
Diffstat
-rw-r--r--bash.html.markdown9
-rw-r--r--csharp.html.markdown581
-rw-r--r--es-es/coffeescript-es.html.markdown4
-rw-r--r--fr-fr/python-fr.html.markdown4
-rw-r--r--haskell.html.markdown2
-rw-r--r--julia.html.markdown299
6 files changed, 587 insertions, 312 deletions
diff --git a/bash.html.markdown b/bash.html.markdown
index 276bc31f..d208b957 100644
--- a/bash.html.markdown
+++ b/bash.html.markdown
@@ -117,7 +117,7 @@ done
# You can also define functions
# Definition:
-foo ()
+function foo ()
{
echo "Arguments work just like script arguments: $@"
echo "And: $1 $2..."
@@ -125,6 +125,13 @@ foo ()
return 0
}
+# or simply
+bar ()
+{
+ echo "Another way to declare functions!"
+ return 0
+}
+
# Calling your function
foo "My name is" $NAME
diff --git a/csharp.html.markdown b/csharp.html.markdown
index ccc0ffad..87c2f704 100644
--- a/csharp.html.markdown
+++ b/csharp.html.markdown
@@ -4,6 +4,7 @@ contributors:
- ["Irfan Charania", "https://github.com/irfancharania"]
- ["Max Yankov", "https://github.com/golergka"]
- ["Melvyn Laïly", "http://x2a.yt"]
+ - ["Shaun McCarthy", "http://www.shaunmccarthy.com"]
filename: LearnCSharp.cs
---
@@ -23,7 +24,12 @@ Multi-line comments look like this
// Specify namespaces application will be using
using System;
using System.Collections.Generic;
-
+using System.Data.Entity;
+using System.Dynamic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Net;
+using System.Threading.Tasks;
// defines scope to organize code into "packages"
namespace Learning
@@ -32,8 +38,8 @@ namespace Learning
// you're allowed to do otherwise, but shouldn't for sanity.
public class LearnCSharp
{
- // A console application must have a main method as an entry point
- public static void Main(string[] args)
+ // BASIC SYNTAX - skip to INTERESTING FEATURES if you have used Java or C++ before
+ public static void Syntax()
{
// Use Console.WriteLine to print lines
Console.WriteLine("Hello World");
@@ -46,7 +52,6 @@ namespace Learning
Console.Write("Hello ");
Console.Write("World");
-
///////////////////////////////////////////////////
// Types & Variables
//
@@ -61,140 +66,83 @@ namespace Learning
// (0 <= byte <= 255)
byte fooByte = 100;
- // Short - Signed 16-bit integer
- // (-32,768 <= short <= 32,767)
+ // Short - 16-bit integer
+ // Signed - (-32,768 <= short <= 32,767)
+ // Unsigned - (0 <= ushort <= 65,535)
short fooShort = 10000;
-
- // Ushort - Unsigned 16-bit integer
- // (0 <= ushort <= 65,535)
ushort fooUshort = 10000;
- // Integer - Signed 32-bit integer
- // (-2,147,483,648 <= int <= 2,147,483,647)
- int fooInt = 1;
+ // Integer - 32-bit integer
+ int fooInt = 1; // (-2,147,483,648 <= int <= 2,147,483,647)
+ uint fooUint = 1; // (0 <= uint <= 4,294,967,295)
- // Uinteger - Unsigned 32-bit integer
- // (0 <= uint <= 4,294,967,295)
- uint fooUint = 1;
-
- // Long - Signed 64-bit integer
- // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
- long fooLong = 100000L;
+ // Long - 64-bit integer
+ long fooLong = 100000L; // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+ ulong fooUlong = 100000L; // (0 <= ulong <= 18,446,744,073,709,551,615)
+ // Numbers default to being int or uint depending on size.
// L is used to denote that this variable value is of type long or ulong
- // anything without is treated as int or uint depending on size.
- // Ulong - Unsigned 64-bit integer
- // (0 <= ulong <= 18,446,744,073,709,551,615)
- ulong fooUlong = 100000L;
+ // Double - Double-precision 64-bit IEEE 754 Floating Point
+ double fooDouble = 123.4; // Precision: 15-16 digits
// Float - Single-precision 32-bit IEEE 754 Floating Point
- // Precision: 7 digits
- float fooFloat = 234.5f;
- // f is used to denote that this variable value is of type float;
- // otherwise it is treated as double.
+ float fooFloat = 234.5f; // Precision: 7 digits
+ // f is used to denote that this variable value is of type float
- // Double - Double-precision 64-bit IEEE 754 Floating Point
- // Precision: 15-16 digits
- double fooDouble = 123.4;
-
- // Decimal - a 128-bits data type, with more precision than other floating-point types,
- // suited for financial and monetary calculations
- decimal fooDecimal = 150.3m;
+ // Decimal - a 128-bits data type, with more precision than other floating-point types,
+ // suited for financial and monetary calculations
+ decimal fooDecimal = 150.3m;
// Boolean - true & false
- bool fooBoolean = true;
- bool barBoolean = false;
+ bool fooBoolean = true; // or false
// Char - A single 16-bit Unicode character
char fooChar = 'A';
// Strings -- unlike the previous base types which are all value types,
- // a string is a reference type. That is, you can set it to null
- string fooString = "My string is here!";
+ // a string is a reference type. That is, you can set it to null
+ string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
Console.WriteLine(fooString);
- // You can access each character of the string with an indexer:
- char charFromString = fooString[1]; // 'y'
- // Strings are immutable: you can't do fooString[1] = 'X';
- // formatting
+ // You can access each character of the string with an indexer:
+ char charFromString = fooString[1]; // 'y'
+ // Strings are immutable: you can't do fooString[1] = 'X';
+
+ // Compare strings with current culture, ignoring case
+ string.Compare(fooString, "x", StringComparison.CurrentCultureIgnoreCase);
+
+ // Formatting, based on sprintf
string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
- Console.WriteLine(fooFormattedString);
- // formatting dates
+ // Dates & Formatting
DateTime fooDate = DateTime.Now;
Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
- // \n is an escaped character that starts a new line
- string barString = "Printing on a new line?\nNo Problem!";
- Console.WriteLine(barString);
-
- // it can be written prettier by using the @ symbol
+ // You can split a string over two lines with the @ symbol. To escape " use ""
string bazString = @"Here's some stuff
- on a new line!";
- Console.WriteLine(bazString);
-
- // quotes need to be escaped
- // use \" normally
- string quotedString = "some \"quoted\" stuff";
- Console.WriteLine(quotedString);
-
- // use "" when strings start with @
- string quotedString2 = @"some MORE ""quoted"" stuff";
- Console.WriteLine(quotedString2);
+on a new line! ""Wow!"", the masses cried";
// Use const or read-only to make a variable immutable
// const values are calculated at compile time
const int HOURS_I_WORK_PER_WEEK = 9001;
- // Nullable types
- // any value type (i.e. not a class) can be made nullable by suffixing a ?
- // <type>? <var name> = <value>
- int? nullable = null;
- Console.WriteLine("Nullable variable: " + nullable);
-
- // In order to use nullable's value, you have to use Value property
- // or to explicitly cast it
- DateTime? nullableDate = null;
- // The previous line would not have compiled without the '?'
- // because DateTime is a value type
- // <type>? is equivalent to writing Nullable<type>
- Nullable<DateTime> otherNullableDate = nullableDate;
-
- nullableDate = DateTime.Now;
- Console.WriteLine("Nullable value is: " + nullableDate.Value + " or: " + (DateTime) nullableDate );
-
- // ?? is syntactic sugar for specifying default value
- // in case variable is null
- int notNullable = nullable ?? 0;
- Console.WriteLine("Not nullable variable: " + notNullable);
-
- // Var - compiler will choose the most appropriate type based on value
- // Please note that this does not remove type safety.
- // In this case, the type of fooImplicit is known to be a bool at compile time
- var fooImplicit = true;
-
///////////////////////////////////////////////////
// Data Structures
///////////////////////////////////////////////////
- Console.WriteLine("\n->Data Structures");
- // Arrays
+ // Arrays - zero indexed
// The array size must be decided upon declaration
// The format for declaring an array is follows:
// <datatype>[] <var name> = new <datatype>[<array size>];
int[] intArray = new int[10];
- string[] stringArray = new string[1];
- bool[] boolArray = new bool[100];
// Another way to declare & initialize an array
int[] y = { 9000, 1000, 1337 };
// Indexing an array - Accessing an element
Console.WriteLine("intArray @ 0: " + intArray[0]);
-
- // Arrays are zero-indexed and mutable.
+ // Arrays are mutable.
intArray[1] = 1;
- Console.WriteLine("intArray @ 1: " + intArray[1]); // => 1
// Lists
// Lists are used more frequently than arrays as they are more flexible
@@ -202,28 +150,21 @@ namespace Learning
// List<datatype> <var name> = new List<datatype>();
List<int> intList = new List<int>();
List<string> stringList = new List<string>();
-
- // Another way to declare & initialize a list
- List<int> z = new List<int> { 9000, 1000, 1337 };
-
- // Indexing a list - Accessing an element
- // Lists are zero-indexed and mutable.
- Console.WriteLine("z @ 0: " + z[2]);
+ List<int> z = new List<int> { 9000, 1000, 1337 }; // intialize
+ // The <> are for generics - Check out the cool stuff section
// Lists don't default to a value;
// A value must be added before accessing the index
intList.Add(1);
Console.WriteLine("intList @ 0: " + intList[0]);
-
// Others data structures to check out:
- //
// Stack/Queue
// Dictionary (an implementation of a hash map)
+ // HashSet
// Read-only Collections
// Tuple (.Net 4+)
-
///////////////////////////////////////
// Operators
///////////////////////////////////////
@@ -232,10 +173,7 @@ namespace Learning
int i1 = 1, i2 = 2; // Shorthand for multiple declarations
// Arithmetic is straightforward
- Console.WriteLine("1+2 = " + (i1 + i2)); // => 3
- Console.WriteLine("2-1 = " + (i2 - i1)); // => 1
- Console.WriteLine("2*1 = " + (i2 * i1)); // => 2
- Console.WriteLine("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down)
+ Console.WriteLine(i1 + i2 - i1 * 3 / 7); //
// Modulo
Console.WriteLine("11%3 = " + (11 % 3)); // => 2
@@ -266,7 +204,6 @@ namespace Learning
Console.WriteLine(i--); //i = 1. Post-Decrementation
Console.WriteLine(--i); //i = 0. Pre-Decrementation
-
///////////////////////////////////////
// Control Structures
///////////////////////////////////////
@@ -291,50 +228,37 @@ namespace Learning
// A simple if/else can be written as follows
// <condition> ? <true> : <false>
string isTrue = (true) ? "True" : "False";
- Console.WriteLine("Ternary demo: " + isTrue);
-
// While loop
int fooWhile = 0;
while (fooWhile < 100)
{
- //Console.WriteLine(fooWhile);
- //Increment the counter
//Iterated 99 times, fooWhile 0->99
fooWhile++;
}
- Console.WriteLine("fooWhile Value: " + fooWhile);
// Do While Loop
int fooDoWhile = 0;
do
{
- //Console.WriteLine(fooDoWhile);
- //Increment the counter
//Iterated 99 times, fooDoWhile 0->99
fooDoWhile++;
} while (fooDoWhile < 100);
- Console.WriteLine("fooDoWhile Value: " + fooDoWhile);
- // For Loop
- int fooFor;
//for loop structure => for(<start_statement>; <conditional>; <step>)
- for (fooFor = 0; fooFor < 10; fooFor++)
+ for (int fooFor = 0; fooFor < 10; fooFor++)
{
- //Console.WriteLine(fooFor);
//Iterated 10 times, fooFor 0->9
}
- Console.WriteLine("fooFor Value: " + fooFor);
-
- // For Each Loop
+
+ // For Each Loop
// foreach loop structure => foreach(<iteratorType> <iteratorName> in <enumerable>)
- // The foreach loop loops over any object implementing IEnumerable or IEnumerable<T>
- // All the collection types (Array, List, Dictionary...) in the .Net framework
- // implement one or both of these interfaces.
- // (The ToCharArray() could be removed, because a string also implements IEnumerable)
+ // The foreach loop loops over any object implementing IEnumerable or IEnumerable<T>
+ // All the collection types (Array, List, Dictionary...) in the .Net framework
+ // implement one or both of these interfaces.
+ // (The ToCharArray() could be removed, because a string also implements IEnumerable)
foreach (char character in "Hello World".ToCharArray())
{
- //Console.WriteLine(character);
//Iterated over all the characters in the string
}
@@ -356,20 +280,18 @@ namespace Learning
case 3:
monthString = "March";
break;
- // You can assign more than one case to an action
- // But you can't add an action without a break before another case
- // (if you want to do this, you would have to explicitly add a goto case x
- case 6:
- case 7:
- case 8:
- monthString = "Summer time!!";
- break;
+ // You can assign more than one case to an action
+ // But you can't add an action without a break before another case
+ // (if you want to do this, you would have to explicitly add a goto case x
+ case 6:
+ case 7:
+ case 8:
+ monthString = "Summer time!!";
+ break;
default:
monthString = "Some other month";
break;
}
- Console.WriteLine("Switch Case Result: " + monthString);
-
///////////////////////////////////////
// Converting Data Types And Typecasting
@@ -384,46 +306,228 @@ namespace Learning
// try parse will default to type default on failure
// in this case: 0
int tryInt;
- int.TryParse("123", out tryInt);
+ if (int.TryParse("123", out tryInt)) // Funciton is boolean
+ Console.WriteLine(tryInt); // 123
// Convert Integer To String
// Convert class has a number of methods to facilitate conversions
Convert.ToString(123);
+ // or
+ tryInt.ToString();
+ }
- ///////////////////////////////////////
- // Classes And Functions
- ///////////////////////////////////////
-
- Console.WriteLine("\n->Classes & Functions");
-
- // (definition of the Bicycle class follows)
+ ///////////////////////////////////////
+ // CLASSES - see definitions at end of file
+ ///////////////////////////////////////
+ public static void Classes()
+ {
+ // See Declaration of objects at end of file
// Use new to instantiate a class
Bicycle trek = new Bicycle();
// Call object methods
- trek.speedUp(3); // You should always use setter and getter methods
- trek.setCadence(100);
+ trek.SpeedUp(3); // You should always use setter and getter methods
+ trek.Cadence = 100;
// ToString is a convention to display the value of this Object.
- Console.WriteLine("trek info: " + trek.ToString());
-
- // Instantiate another new Bicycle
- Bicycle octo = new Bicycle(5, 10);
- Console.WriteLine("octo info: " + octo.ToString());
+ Console.WriteLine("trek info: " + trek.Info());
// Instantiate a new Penny Farthing
PennyFarthing funbike = new PennyFarthing(1, 10);
- Console.WriteLine("funbike info: " + funbike.ToString());
+ Console.WriteLine("funbike info: " + funbike.Info());
Console.Read();
} // End main method
+ // CONSOLE ENTRY A console application must have a main method as an entry point
+ public static void Main(string[] args)
+ {
+ OtherInterestingFeatures();
+ }
+
+ //
+ // INTERESTING FEATURES
+ //
+
+ // DEFAULT METHOD SIGNATURES
+
+ public // Visibility
+ static // Allows for direct call on class without object
+ int // Return Type,
+ MethodSignatures(
+ int maxCount, // First variable, expects an int
+ int count = 0, // will default the value to 0 if not passed in
+ int another = 3,
+ params string[] otherParams // captures all other parameters passed to method
+ )
+ {
+ return -1;
+ }
+
+ // Methods can have the same name, as long as the signature is unique
+ public static void MethodSignature(string maxCount)
+ {
+ }
+
+ // GENERICS
+ // The classes for TKey and TValue is specified by the user calling this function.
+ // This method emulates the SetDefault of Python
+ public static TValue SetDefault<TKey, TValue>(
+ IDictionary<TKey, TValue> dictionary,
+ TKey key,
+ TValue defaultItem)
+ {
+ TValue result;
+ if (!dictionary.TryGetValue(key, out result))
+ return dictionary[key] = defaultItem;
+ return result;
+ }
+
+ // You can narrow down the objects that are passed in
+ public static void IterateAndPrint<T>(T toPrint) where T: IEnumerable<int>
+ {
+ // We can iterate, since T is a IEnumerable
+ foreach (var item in toPrint)
+ // Item is an int
+ Console.WriteLine(item.ToString());
+ }
+
+ public static void OtherInterestingFeatures()
+ {
+ // OPTIONAL PARAMETERS
+ MethodSignatures(3, 1, 3, "Some", "Extra", "Strings");
+ MethodSignatures(3, another: 3); // explicity set a parameter, skipping optional ones
+
+ // EXTENSION METHODS
+ int i = 3;
+ i.Print(); // Defined below
+
+ // NULLABLE TYPES - great for database interaction / return values
+ // any value type (i.e. not a class) can be made nullable by suffixing a ?
+ // <type>? <var name> = <value>
+ int? nullable = null; // short hand for Nullable<int>
+ Console.WriteLine("Nullable variable: " + nullable);
+ bool hasValue = nullable.HasValue; // true if not null
+
+ // ?? is syntactic sugar for specifying default value (coalesce)
+ // in case variable is null
+ int notNullable = nullable ?? 0; // 0
+
+ // IMPLICITLY TYPED VARIABLES - you can let the compiler work out what the type is:
+ var magic = "magic is a string, at compile time, so you still get type safety";
+ // magic = 9; will not work as magic is a string, not an int
+
+ // GENERICS
+ //
+ var phonebook = new Dictionary<string, string>() {
+ {"Sarah", "212 555 5555"} // Add some entries to the phone book
+ };
+
+ // Calling SETDEFAULT defined as a generic above
+ Console.WriteLine(SetDefault<string,string>(phonebook, "Shaun", "No Phone")); // No Phone
+ // nb, you don't need to specify the TKey and TValue since they can be
+ // derived implicitly
+ Console.WriteLine(SetDefault(phonebook, "Sarah", "No Phone")); // 212 555 5555
+
+ // LAMBDA EXPRESSIONS - allow you to write code in line
+ Func<int, int> square = (x) => x * x; // Last T item is the return value
+ Console.WriteLine(square(3)); // 9
+
+ // PARALLEL FRAMEWORK
+ // http://blogs.msdn.com/b/csharpfaq/archive/2010/06/01/parallel-programming-in-net-framework-4-getting-started.aspx
+ var websites = new string[] {
+ "http://www.google.com", "http://www.reddit.com",
+ "http://www.shaunmccarthy.com"
+ };
+ var responses = new Dictionary<string, string>();
+
+ // Will spin up separate threads for each request, and join on them
+ // before going to the next step!
+ Parallel.ForEach(websites,
+ new ParallelOptions() {MaxDegreeOfParallelism = 3}, // max of 3 threads
+ website =>
+ {
+ // Do something that takes a long time on the file
+ using (var r = WebRequest.Create(new Uri(website)).GetResponse())
+ {
+ responses[website] = r.ContentType;
+ }
+ });
+
+ // This won't happen till after all requests have been completed
+ foreach (var key in responses.Keys)
+ Console.WriteLine("{0}:{1}", key, responses[key]);
+
+ // DYNAMIC OBJECTS (great for working with other languages)
+ dynamic student = new ExpandoObject();
+ student.FirstName = "First Name"; // No need to define class first!
+
+ // You can even add methods (returns a string, and takes in a string)
+ student.Introduce = new Func<string, string>(
+ (introduceTo) => string.Format("Hey {0}, this is {1}", student.FirstName, introduceTo));
+ Console.WriteLine(student.Introduce("Beth"));
+
+ // IQUERYABLE<T> - almost all collections implement this, which gives you a lot of
+ // very useful Map / Filter / Reduce style methods
+ var bikes = new List<Bicycle>();
+ bikes.Sort(); // Sorts the array
+ bikes.Sort((b1, b2) => b1.Wheels.CompareTo(b2.Wheels)); // Sorts based on wheels
+ var result = bikes
+ .Where(b => b.Wheels > 3) // Filters - chainable (returns IQueryable of previous type)
+ .Where(b => b.IsBroken && b.HasTassles)
+ .Select(b => b.ToString()); // Map - we only this selects, so result is a IQueryable<string>
+
+ var sum = bikes.Sum(b => b.Wheels); // Reduce - sums all the wheels in the collection
+
+ // Create a list of IMPLICIT objects based on some parameters of the bike
+ var bikeSummaries = bikes.Select(b=>new { Name = b.Name, IsAwesome = !b.IsBroken && b.HasTassles });
+ // Hard to show here, but you get type ahead completion since the compiler can implicitly work
+ // out the types above!
+ foreach (var bikeSummary in bikeSummaries.Where(b => b.IsAwesome))
+ Console.WriteLine(bikeSummary.Name);
+
+ // ASPARALLEL
+ // And this is where things get wicked - combines linq and parallel operations
+ var threeWheelers = bikes.AsParallel().Where(b => b.Wheels == 3).Select(b => b.Name);
+ // this will happen in parallel! Threads will automagically be spun up and the
+ // results divvied amongst them! Amazing for large datasets when you have lots of
+ // cores
+
+ // LINQ - maps a store to IQueryable<T> objects, with delayed execution
+ // e.g. LinqToSql - maps to a database, LinqToXml maps to an xml document
+ var db = new BikeRespository();
+
+ // execution is delayed, which is great when querying a database
+ var fitler = db.Bikes.Where(b => b.HasTassles); // no query run
+ if (42 > 6) // You can keep adding filters, even conditionally - great for "advanced search" functionality
+ fitler = fitler.Where(b => b.IsBroken); // no query run
+
+ var query = fitler
+ .OrderBy(b => b.Wheels)
+ .ThenBy(b => b.Name)
+ .Select(b => b.Name); // still no query run
+
+ // Now the query runs, but opens a reader, so only populates are you iterate through
+ foreach (string bike in query)
+ Console.WriteLine(result);
+
+
+
+ }
} // End LearnCSharp class
// You can include other classes in a .cs file
+ public static class Extensions
+ {
+ // EXTENSION FUNCTIONS
+ public static void Print(this object obj)
+ {
+ Console.WriteLine(obj.ToString());
+ }
+ }
// Class Declaration Syntax:
// <public/private/protected/internal> class <class name>{
@@ -434,64 +538,88 @@ namespace Learning
public class Bicycle
{
// Bicycle's Fields/Variables
- public int cadence; // Public: Can be accessed from anywhere
- private int _speed; // Private: Only accessible from within the class
- protected int gear; // Protected: Accessible from the class and subclasses
- internal int wheels; // Internal: Accessible from within the assembly
- string name; // Everything is private by default: Only accessible from within this class
+ public int Cadence // Public: Can be accessed from anywhere
+ {
+ get // get - define a method to retrieve the property
+ {
+ return _cadence;
+ }
+ set // set - define a method to set a proprety
+ {
+ _cadence = value; // Value is the value passed in to to the setter
+ }
+ }
+ private int _cadence;
+
+ protected virtual int Gear // Protected: Accessible from the class and subclasses
+ {
+ get; // creates an auto property so you don't need a member field
+ set;
+ }
+
+ internal int Wheels // Internal: Accessible from within the assembly
+ {
+ get;
+ private set; // You can set modifiers on the get/set methods
+ }
+
+ int _speed; // Everything is private by default: Only accessible from within this class.
+ // can also use keyword privatee
+ public string Name { get; set; }
// Enum is a value type that consists of a set of named constants
- // It is really just mapping a name to a value (an int, unless specified otherwise).
- // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
- // An enum can't contain the same value twice.
- public enum Brand
+ // It is really just mapping a name to a value (an int, unless specified otherwise).
+ // The approved types for an enum are byte, sbyte, short, ushort, int, uint, long, or ulong.
+ // An enum can't contain the same value twice.
+ public enum BikeBrand
{
AIST,
BMC,
- Electra=42, //you can explicitly set a value to a name
+ Electra = 42, //you can explicitly set a value to a name
Gitane
}
// We defined this type inside a Bicycle class, so it is a nested type
// Code outside of this class should reference this type as Bicycle.Brand
- public Brand brand; // After declaring an enum type, we can declare the field of this type
+ public BikeBrand Brand; // After declaring an enum type, we can declare the field of this type
// Static members belong to the type itself rather then specific object.
- static public int bicyclesCreated = 0;
// You can access them without a reference to any object:
// Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
+ static public int BicyclesCreated = 0;
// readonly values are set at run time
// they can only be assigned upon declaration or in a constructor
- readonly bool hasCardsInSpokes = false; // read-only private
+ readonly bool _hasCardsInSpokes = false; // read-only private
// Constructors are a way of creating classes
// This is a default constructor
- private Bicycle()
+ public Bicycle()
{
- gear = 1;
- cadence = 50;
+ this.Gear = 1; // you can access mmebers of the object with the keyword this
+ Cadence = 50; // but you don't always need it
_speed = 5;
- name = "Bontrager";
- brand = Brand.AIST;
- bicyclesCreated++;
+ Name = "Bontrager";
+ Brand = BikeBrand.AIST;
+ BicyclesCreated++;
}
// This is a specified constructor (it contains arguments)
public Bicycle(int startCadence, int startSpeed, int startGear,
- string name, bool hasCardsInSpokes, Brand brand)
+ string name, bool hasCardsInSpokes, BikeBrand brand)
+ : base() // calls base first
{
- this.gear = startGear; // "this" keyword denotes the current object
- this.cadence = startCadence;
- this._speed = startSpeed;
- this.name = name; // it can be useful when there's a name conflict
- this.hasCardsInSpokes = hasCardsInSpokes;
- this.brand = brand;
+ Gear = startGear;
+ Cadence = startCadence;
+ _speed = startSpeed;
+ Name = name;
+ _hasCardsInSpokes = hasCardsInSpokes;
+ Brand = brand;
}
// Constructors can be chained
- public Bicycle(int startCadence, int startSpeed, Brand brand) :
- this(startCadence, startSpeed, 0, "big wheels", true)
+ public Bicycle(int startCadence, int startSpeed, BikeBrand brand) :
+ this(startCadence, startSpeed, 0, "big wheels", true, brand)
{
}
@@ -501,27 +629,8 @@ namespace Learning
// classes can implement getters and setters for their fields
// or they can implement properties (this is the preferred way in C#)
- // Method declaration syntax:
- // <scope> <return type> <method name>(<args>)
- public int GetCadence()
- {
- return cadence;
- }
-
- // void methods require no return statement
- public void SetCadence(int newValue)
- {
- cadence = newValue;
- }
-
- // virtual keyword indicates this method can be overridden in a derived class
- public virtual void SetGear(int newValue)
- {
- gear = newValue;
- }
-
// Method parameters can have default values.
- // In this case, methods can be called with these parameters omitted
+ // In this case, methods can be called with these parameters omitted
public void SpeedUp(int increment = 1)
{
_speed += increment;
@@ -541,12 +650,12 @@ namespace Learning
get { return _hasTassles; }
set { _hasTassles = value; }
}
-
- // You can also define an automatic property in one line
- // this syntax will create a backing field automatically.
- // You can set an access modifier on either the getter or the setter (or both)
- // to restrict its access:
- public bool IsBroken { get; private set; }
+
+ // You can also define an automatic property in one line
+ // this syntax will create a backing field automatically.
+ // You can set an access modifier on either the getter or the setter (or both)
+ // to restrict its access:
+ public bool IsBroken { get; private set; }
// Properties can be auto-implemented
public int FrameSize
@@ -558,13 +667,13 @@ namespace Learning
}
//Method to display the attribute values of this Object.
- public override string ToString()
+ public virtual string Info()
{
- return "gear: " + gear +
- " cadence: " + cadence +
- " speed: " + _speed +
- " name: " + name +
- " cards in spokes: " + (hasCardsInSpokes ? "yes" : "no") +
+ return "Gear: " + Gear +
+ " Cadence: " + Cadence +
+ " Speed: " + _speed +
+ " Name: " + Name +
+ " Cards in Spokes: " + (_hasCardsInSpokes ? "yes" : "no") +
"\n------------------------------\n"
;
}
@@ -573,9 +682,10 @@ namespace Learning
public static bool DidWeCreateEnoughBycles()
{
// Within a static method, we only can reference static class members
- return bicyclesCreated > 9000;
+ return BicyclesCreated > 9000;
} // If your class only needs static members, consider marking the class itself as static.
+
} // end class Bicycle
// PennyFarthing is a subclass of Bicycle
@@ -586,20 +696,27 @@ namespace Learning
// calling parent constructor
public PennyFarthing(int startCadence, int startSpeed) :
- base(startCadence, startSpeed, 0, "PennyFarthing", true)
+ base(startCadence, startSpeed, 0, "PennyFarthing", true, BikeBrand.Electra)
{
}
- public override void SetGear(int gear)
+ protected override int Gear
{
- gear = 0;
+ get
+ {
+ return 0;
+ }
+ set
+ {
+ throw new ArgumentException("You can't change gears on a PennyFarthing");
+ }
}
- public override string ToString()
+ public override string Info()
{
string result = "PennyFarthing bicycle ";
result += base.ToString(); // Calling the base version of the method
- return reuslt;
+ return result;
}
}
@@ -624,7 +741,7 @@ namespace Learning
damage += meters;
}
- public void Broken
+ public bool Broken
{
get
{
@@ -632,24 +749,34 @@ namespace Learning
}
}
}
-} // End Namespace
+ /// <summary>
+ /// Used to connect to DB for LinqToSql example.
+ /// EntityFramework Code First is awesome (similar to Ruby's ActiveRecord, but bidirectional)
+ /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
+ /// </summary>
+ public class BikeRespository : DbSet
+ {
+ public BikeRespository()
+ : base()
+ {
+ }
+
+ public DbSet<Bicycle> Bikes { get; set; }
+ }
+} // End Namespace
```
## Topics Not Covered
* Flags
* Attributes
- * Generics (T), Delegates, Func, Actions, lambda expressions
* Static properties
* Exceptions, Abstraction
- * LINQ
* ASP.NET (Web Forms/MVC/WebMatrix)
* Winforms
* Windows Presentation Foundation (WPF)
-
-
## Further Reading
* [DotNetPerls](http://www.dotnetperls.com)
diff --git a/es-es/coffeescript-es.html.markdown b/es-es/coffeescript-es.html.markdown
index 78bb9be5..6bf430e6 100644
--- a/es-es/coffeescript-es.html.markdown
+++ b/es-es/coffeescript-es.html.markdown
@@ -44,7 +44,7 @@ math =
# "cube": function(x) { return x * square(x); }
#}
-# Símbolos:
+# Número de argumentos variable:
race = (winner, runners...) ->
print winner, runners
@@ -52,6 +52,6 @@ race = (winner, runners...) ->
alert "I knew it!" if elvis?
#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
-# Colecciones por comprensión:
+# Listas:
cubes = (math.cube num for num in list) #=> ...
```
diff --git a/fr-fr/python-fr.html.markdown b/fr-fr/python-fr.html.markdown
index 2bf0afd0..9dbdafe1 100644
--- a/fr-fr/python-fr.html.markdown
+++ b/fr-fr/python-fr.html.markdown
@@ -156,9 +156,9 @@ li[4] # Lève un 'IndexError'
# On peut accèder à des rangs de valeurs avec la syntaxe "slice"
# (C'est un rang de type 'fermé/ouvert' pour les plus matheux)
li[1:3] #=> [2, 4]
-# Sans spécifier de début de rang
+# Sans spécifier de fin de rang, on "saute" le début de la liste
li[2:] #=> [4, 3]
-# Sans spécifier de fin de rang
+# Sans spécifier de début de rang, on "saute" la fin de la liste
li[:3] #=> [1, 2, 4]
# Retirer un élément spécifique dee la liste avec "del"
diff --git a/haskell.html.markdown b/haskell.html.markdown
index 6b3c6e17..267b40af 100644
--- a/haskell.html.markdown
+++ b/haskell.html.markdown
@@ -11,7 +11,7 @@ makes coding a real joy for me.
```haskell
-- Single line comments start with two dashes.
{- Multiline comments can be enclosed
-en a block like this.
+in a block like this.
-}
----------------------------------------------------
diff --git a/julia.html.markdown b/julia.html.markdown
index cf3a464b..4ebd50ff 100644
--- a/julia.html.markdown
+++ b/julia.html.markdown
@@ -8,7 +8,7 @@ filename: learnjulia.jl
Julia is a new homoiconic functional language focused on technical computing.
While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python.
-This is based on the current development version of Julia, as of June 29th, 2013.
+This is based on the current development version of Julia, as of October 18th, 2013.
```ruby
@@ -20,20 +20,20 @@ This is based on the current development version of Julia, as of June 29th, 2013
# Everything in Julia is a expression.
-# You have numbers
+# There are several basic types of numbers.
3 #=> 3 (Int64)
3.2 #=> 3.2 (Float64)
2 + 1im #=> 2 + 1im (Complex{Int64})
2//3 #=> 2//3 (Rational{Int64})
-# Math is what you would expect
+# All of the normal infix operators are available.
1 + 1 #=> 2
8 - 1 #=> 7
10 * 2 #=> 20
35 / 5 #=> 7.0
+5 / 2 #=> 2.5 # dividing an Int by an Int always results in a Float
+div(5, 2) #=> 2 # for a truncated result, use div
5 \ 35 #=> 7.0
-5 / 2 #=> 2.5
-div(5, 2) #=> 2
2 ^ 2 #=> 4 # power, not bitwise xor
12 % 10 #=> 2
@@ -77,11 +77,13 @@ false
# Strings are created with "
"This is a string."
-# Character literals written with '
+# Character literals are written with '
'a'
-# A string can be treated like a list of characters
+# A string can be indexed like an array of characters
"This is a string"[1] #=> 'T' # Julia indexes from 1
+# However, this is will not work well for UTF8 strings,
+# so iterating over strings is reccommended (map, for loops, etc).
# $ can be used for string interpolation:
"2 + 2 = $(2 + 2)" #=> "2 + 2 = 4"
@@ -94,10 +96,10 @@ false
## 2. Variables and Collections
####################################################
-# Printing is pretty easy
+# Printing is easy
println("I'm Julia. Nice to meet you!")
-# No need to declare variables before assigning to them.
+# You don't declare variables before assigning to them.
some_var = 5 #=> 5
some_var #=> 5
@@ -108,12 +110,14 @@ catch e
println(e)
end
-# Variable name start with a letter. You can use uppercase letters, digits,
-# and exclamation points as well after the initial alphabetic character.
+# Variable names start with a letter.
+# After that, you can use letters, digits, underscores, and exclamation points.
SomeOtherVar123! = 6 #=> 6
# You can also use unicode characters
☃ = 8 #=> 8
+# These are especially handy for mathematical notation
+2 * π #=> 6.283185307179586
# A note on naming conventions in Julia:
#
@@ -158,6 +162,10 @@ a[1] #=> 1 # remember that Julia indexes from 1, not 0!
# indexing expression
a[end] #=> 6
+# we also have shift and unshift
+shift!(a) #=> 1 and a is now [2,4,3,4,5,6]
+unshift!(a,7) #=> [7,2,4,3,4,5,6]
+
# Function names that end in exclamations points indicate that they modify
# their argument.
arr = [5,4,6] #=> 3-element Int64 Array: [5,4,6]
@@ -182,23 +190,24 @@ a = [1:5] #=> 5-element Int64 Array: [1,2,3,4,5]
# You can look at ranges with slice syntax.
a[1:3] #=> [1, 2, 3]
a[2:] #=> [2, 3, 4, 5]
+a[2:end] #=> [2, 3, 4, 5]
-# Remove arbitrary elements from a list with splice!
+# Remove elements from an array by index with splice!
arr = [3,4,5]
splice!(arr,2) #=> 4 ; arr is now [3,5]
# Concatenate lists with append!
b = [1,2,3]
-append!(a,b) # Now a is [1, 3, 4, 5, 1, 2, 3]
+append!(a,b) # Now a is [1, 2, 3, 4, 5, 1, 2, 3]
-# Check for existence in a list with contains
-contains(a,1) #=> true
+# Check for existence in a list with in
+in(a,1) #=> true
# Examine the length with length
-length(a) #=> 7
+length(a) #=> 8
# Tuples are immutable.
-tup = (1, 2, 3) #=>(1,2,3) # an (Int64,Int64,Int64) tuple.
+tup = (1, 2, 3) #=> (1,2,3) # an (Int64,Int64,Int64) tuple.
tup[1] #=> 1
try:
tup[0] = 3 #=> ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
@@ -209,22 +218,26 @@ end
# Many list functions also work on tuples
length(tup) #=> 3
tup[1:2] #=> (1,2)
-contains(tup,2) #=> true
+in(tup,2) #=> true
# You can unpack tuples into variables
a, b, c = (1, 2, 3) #=> (1,2,3) # a is now 1, b is now 2 and c is now 3
-# Tuples are created by default if you leave out the parentheses
+# Tuples are created even if you leave out the parentheses
d, e, f = 4, 5, 6 #=> (4,5,6)
-# Now look how easy it is to swap two values
+# A 1-element tuple is distinct from the value it contains
+(1,) == 1 #=> false
+(1) == 1 #=> true
+
+# Look how easy it is to swap two values
e, d = d, e #=> (5,4) # d is now 5 and e is now 4
# Dictionaries store mappings
empty_dict = Dict() #=> Dict{Any,Any}()
-# Here is a prefilled dictionary
+# You can create a dictionary using a literal
filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
# => Dict{ASCIIString,Int64}
@@ -241,31 +254,35 @@ values(filled_dict)
#=> ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
# Note - Same as above regarding key ordering.
-# Check for existence of keys in a dictionary with contains, haskey
-contains(filled_dict, ("one", 1)) #=> true
-contains(filled_dict, ("two", 3)) #=> false
+# Check for existence of keys in a dictionary with in, haskey
+in(filled_dict, ("one", 1)) #=> true
+in(filled_dict, ("two", 3)) #=> false
haskey(filled_dict, "one") #=> true
haskey(filled_dict, 1) #=> false
-# Trying to look up a non-existing key will raise an error
+# Trying to look up a non-existant key will raise an error
try
filled_dict["four"] #=> ERROR: key not found: four in getindex at dict.jl:489
catch e
println(e)
end
-# Use get method to avoid the error
+# Use the get method to avoid that error by providing a default value
# get(dictionary,key,default_value)
get(filled_dict,"one",4) #=> 1
get(filled_dict,"four",4) #=> 4
-# Sets store sets
+# Use Sets to represent collections of unordered, unique values
empty_set = Set() #=> Set{Any}()
-# Initialize a set with a bunch of values
+# Initialize a set with values
filled_set = Set(1,2,2,3,4) #=> Set{Int64}(1,2,3,4)
-# Add more items to a set
-add!(filled_set,5) #=> Set{Int64}(5,4,2,3,1)
+# Add more values to a set
+push!(filled_set,5) #=> Set{Int64}(5,4,2,3,1)
+
+# Check if the values are in the set
+in(filled_set,2) #=> true
+in(filled_set,10) #=> false
# There are functions for set intersection, union, and difference.
other_set = Set(3, 4, 5, 6) #=> Set{Int64}(6,4,5,3)
@@ -273,10 +290,6 @@ intersect(filled_set, other_set) #=> Set{Int64}(3,4,5)
union(filled_set, other_set) #=> Set{Int64}(1,2,3,4,5,6)
setdiff(Set(1,2,3,4),Set(2,3,5)) #=> Set{Int64}(1,4)
-# Check for existence in a set with contains
-contains(filled_set,2) #=> true
-contains(filled_set,10) #=> false
-
####################################################
## 3. Control Flow
@@ -285,8 +298,7 @@ contains(filled_set,10) #=> false
# Let's make a variable
some_var = 5
-# Here is an if statement. Indentation is NOT meaningful in Julia.
-# prints "some var is smaller than 10"
+# Here is an if statement. Indentation is not meaningful in Julia.
if some_var > 10
println("some_var is totally bigger than 10.")
elseif some_var < 10 # This elseif clause is optional.
@@ -294,44 +306,56 @@ elseif some_var < 10 # This elseif clause is optional.
else # The else clause is optional too.
println("some_var is indeed 10.")
end
+#=> prints "some var is smaller than 10"
-# For loops iterate over iterables, such as ranges, lists, sets, dicts, strings.
-
+# For loops iterate over iterables.
+# Iterable types include Range, Array, Set, Dict, and String.
for animal=["dog", "cat", "mouse"]
- # You can use $ to interpolate into strings
println("$animal is a mammal")
+ # You can use $ to interpolate variables or expression into strings
end
# prints:
# dog is a mammal
# cat is a mammal
# mouse is a mammal
-# You can use in instead of =, if you want.
+# You can use 'in' instead of '='.
for animal in ["dog", "cat", "mouse"]
println("$animal is a mammal")
end
+# prints:
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
- println("$(a[1]) is $(a[2])")
+ println("$(a[1]) is a $(a[2])")
end
+# prints:
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
- println("$k is $v")
+ println("$k is a $v")
end
-
-
-# While loops go until a condition is no longer met.
# prints:
-# 0
-# 1
-# 2
-# 3
+# dog is a mammal
+# cat is a mammal
+# mouse is a mammal
+
+# While loops loop while a condition is true
x = 0
while x < 4
println(x)
x += 1 # Shorthand for x = x + 1
end
+# prints:
+# 0
+# 1
+# 2
+# 3
# Handle exceptions with a try/except block
try
@@ -346,11 +370,14 @@ end
## 4. Functions
####################################################
-# Use the keyword function to create new functions
+# The keyword 'function' creates new functions
+#function name(arglist)
+# body...
+#end
function add(x, y)
println("x is $x and y is $y")
- # Functions implicitly return the value of their last statement
+ # Functions return the value of their last statement
x + y
end
@@ -360,13 +387,16 @@ add(5, 6) #=> 11 after printing out "x is 5 and y is 6"
# positional arguments
function varargs(args...)
return args
+ # use the keyword return to return anywhere in the function
end
+#=> varargs (generic function with 1 method)
varargs(1,2,3) #=> (1,2,3)
# The ... is called a splat.
-# It can also be used in a fuction call
-# to splat a list or tuple out to be the arguments
+# We just used it in a function definition.
+# It can also be used in a fuction call,
+# where it will splat an Array or Tuple's contents into the argument list.
Set([1,2,3]) #=> Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays
Set([1,2,3]...) #=> Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3)
@@ -399,7 +429,7 @@ keyword_args(name2="ness") #=> ["name2"=>"ness","k1"=>4]
keyword_args(k1="mine") #=> ["k1"=>"mine","name2"=>"hello"]
keyword_args() #=> ["name2"=>"hello","k2"=>4]
-# You can also do both at once
+# You can combine all kinds of arguments in the same function
function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
println("normal arg: $normal_arg")
println("optional arg: $optional_positional_arg")
@@ -420,12 +450,15 @@ function create_adder(x)
return adder
end
-# or equivalently
+# This is "stabby lambda syntax" for creating anonymous functions
+(x -> x > 2)(3) #=> true
+
+# This function is identical to create_adder implementation above.
function create_adder(x)
y -> x + y
end
-# you can also name the internal function, if you want
+# You can also name the internal function, if you want
function create_adder(x)
function adder(y)
x + y
@@ -436,61 +469,114 @@ end
add_10 = create_adder(10)
add_10(3) #=> 13
-# The first two inner functions above are anonymous functions
-(x -> x > 2)(3) #=> true
# There are built-in higher order functions
map(add_10, [1,2,3]) #=> [11, 12, 13]
filter(x -> x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
-# We can use list comprehensions for nice maps and filters
+# We can use list comprehensions for nicer maps
[add_10(i) for i=[1, 2, 3]] #=> [11, 12, 13]
[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
####################################################
-## 5. Types and Multiple-Dispatch
+## 5. Types
####################################################
-# Type definition
+# Julia has a type system.
+# Every value has a type; variables do not have types themselves.
+# You can use the `typeof` function to get the type of a value.
+typeof(5) #=> Int64
+
+# Types are first-class values
+typeof(Int64) #=> DataType
+typeof(DataType) #=> DataType
+# DataType is the type that represents types, including itself.
+
+# Types are used for documentation, optimizations, and dispatch.
+# They are not statically checked.
+
+# Users can define types
+# They are like records or structs in other languages.
+# New types are defined used the `type` keyword.
+
+# type Name
+# field::OptionalType
+# ...
+# end
type Tiger
taillength::Float64
- coatcolor # no type annotation is implicitly Any
+ coatcolor # not including a type annotation is the same as `::Any`
end
-# default constructor is the properties in order
-# so, Tiger(taillength,coatcolor)
-# Type instantiation
-tigger = Tiger(3.5,"orange") # the type doubles as the constructor function
+# The default constructor's arguments are the properties
+# of the tyep, in order the order they are listed in the definition
+tigger = Tiger(3.5,"orange") #=> Tiger(3.5,"orange")
+
+# The type doubles as the constructor function for values of that type
+sherekhan = typeof(tigger)(5.6,"fire") #=> Tiger(5.6,"fire")
-# Abtract Types
-abstract Cat # just a name and point in the type hierarchy
+# These struct-style types are called concrete types
+# They can be instantiated, but cannot have subtypes.
+# The other kind of types is abstract types.
-# * types defined with the type keyword are concrete types; they can be
-# instantiated
-#
-# * types defined with the abstract keyword are abstract types; they can
-# have subtypes.
-#
-# * each type has one supertype; a supertype can have zero or more subtypes.
+# abstract Name
+abstract Cat # just a name and point in the type hierarchy
+# Abstract types cannot be instantiated, but can have subtypes.
+# For example, Number is an abstract type
+subtypes(Number) #=> 6-element Array{Any,1}:
+ # Complex{Float16}
+ # Complex{Float32}
+ # Complex{Float64}
+ # Complex{T<:Real}
+ # ImaginaryUnit
+ # Real
+subtypes(Cat) #=> 0-element Array{Any,1}
+
+# Every type has a super type; use the `super` function to get it.
+typeof(5) #=> Int64
+super(Int64) #=> Signed
+super(Signed) #=> Real
+super(Real) #=> Number
+super(Number) #=> Any
+super(super(Signed)) #=> Number
+super(Any) #=> Any
+# All of these type, except for Int64, are abstract.
+
+# <: is the subtyping operator
type Lion <: Cat # Lion is a subtype of Cat
mane_color
roar::String
end
+# You can define more constructors for your type
+# Just define a function of the same name as the type
+# and call an existing constructor to get a value of the correct type
+Lion(roar::String) = Lion("green",roar)
+# This is an outer constructor because it's outside the type definition
+
type Panther <: Cat # Panther is also a subtype of Cat
eye_color
Panther() = new("green")
# Panthers will only have this constructor, and no default constructor.
end
+# Using inner constructors, like Panter does, gives you control
+# over how values of the type can be created.
+# When possible, you should use outer constructors rather than inner ones.
-# Multiple Dispatch
+####################################################
+## 6. Multiple-Dispatch
+####################################################
# In Julia, all named functions are generic functions
# This means that they are built up from many small methods
-# For example, let's make a function meow:
+# Each constructor for Lion is a method of the generic function Lion.
+
+# For a non-constructor example, let's make a function meow:
+
+# Definitions for Lion, Panther, Tiger
function meow(cat::Lion)
- cat.roar # access properties using dot notation
+ cat.roar # access type properties using dot notation
end
function meow(cat::Panther)
@@ -501,21 +587,75 @@ function meow(cat::Tiger)
"rawwwr"
end
+# Testing the meow function
meow(tigger) #=> "rawwr"
meow(Lion("brown","ROAAR")) #=> "ROAAR"
meow(Panther()) #=> "grrr"
+# Review the local type hierarchy
+issubtype(Tiger,Cat) #=> false
+issubtype(Lion,Cat) #=> true
+issubtype(Panther,Cat) #=> true
+
+# Defining a function that takes Cats
function pet_cat(cat::Cat)
println("The cat says $(meow(cat))")
end
+pet_cat(Lion("42")) #=> prints "The cat says 42"
try
pet_cat(tigger) #=> ERROR: no method pet_cat(Tiger,)
catch e
println(e)
end
-pet_cat(Lion(Panther(),"42")) #=> prints "The cat says 42"
+# In OO languages, single dispatch is common;
+# this means that the method is picked based on the type of the first argument.
+# In Julia, all of the argument types contribute to selecting the best method.
+
+# Let's define a function with more arguments, so we can see the difference
+function fight(t::Tiger,c::Cat)
+ println("The $(t.coatcolor) tiger wins!")
+end
+#=> fight (generic function with 1 method)
+
+fight(tigger,Panther()) #=> prints The orange tiger wins!
+fight(tigger,Lion("ROAR")) #=> prints The orange tiger wins!
+
+# Let's change the behavior when the Cat is specifically a Lion
+fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
+#=> fight (generic function with 2 methods)
+
+fight(tigger,Panther()) #=> prints The orange tiger wins!
+fight(tigger,Lion("ROAR")) #=> prints The green-maned lion wins!
+
+# We don't need a Tiger in order to fight
+fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
+#=> fight (generic function with 3 methods)
+
+fight(Lion("balooga!"),Panther()) #=> prints The victorious cat says grrr
+try
+ fight(Panther(),Lion("RAWR")) #=> ERROR: no method fight(Panther,Lion)
+catch
+end
+
+# Also let the cat go first
+fight(c::Cat,l::Lion) = println("The cat beats the Lion")
+#=> Warning: New definition
+# fight(Cat,Lion) at none:1
+# is ambiguous with
+# fight(Lion,Cat) at none:2.
+# Make sure
+# fight(Lion,Lion)
+# is defined first.
+#fight (generic function with 4 methods)
+
+# This warning is because it's unclear which fight will be called in:
+fight(Lion("RAR"),Lion("brown","rarrr")) #=> prints The victorious cat says rarrr
+# The result may be different in other versions of Julia
+
+fight(l::Lion,l2::Lion) = println("The lions come to a tie")
+fight(Lion("RAR"),Lion("brown","rarrr")) #=> prints The lions come to a tie
```
@@ -523,3 +663,4 @@ pet_cat(Lion(Panther(),"42")) #=> prints "The cat says 42"
You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/manual/)
+The best place to get help with Julia is the (very friendly) [mailing list](https://groups.google.com/forum/#!forum/julia-users).