Merge pull request #1 from adambard/master

update

1 files changed, 73 insertions, 42 deletions

diff --git a/julia.html.markdown b/julia.html.markdown
index 3a52018c..85033aa6 100644
--- a/julia.html.markdown
+++ b/julia.html.markdown
@@ -2,19 +2,20 @@
 language: Julia
 contributors:
     - ["Leah Hanson", "http://leahhanson.us"]
+    - ["Pranit Bauva", "http://github.com/pranitbauva1997"]
 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 October 18th, 2013.
+This is based on Julia 0.4.
 
 ```ruby
 
 # Single line comments start with a hash (pound) symbol.
 #= Multiline comments can be written
-   by putting '#=' before the text  and '=#' 
+   by putting '#=' before the text  and '=#'
    after the text. They can also be nested.
 =#
 
@@ -22,7 +23,7 @@ This is based on the current development version of Julia, as of October 18th, 2
 ## 1. Primitive Datatypes and Operators
 ####################################################
 
-# Everything in Julia is a expression.
+# Everything in Julia is an expression.
 
 # There are several basic types of numbers.
 3 # => 3 (Int64)
@@ -81,17 +82,20 @@ false
 # Strings are created with "
 "This is a string."
 
+# Julia has several types of strings, including ASCIIString and UTF8String.
+# More on this in the Types section.
+
 # Character literals are written with '
 'a'
 
-# A string can be indexed like an array of characters
+# Some strings 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 recommended (map, for loops, etc).
 
 # $ can be used for string interpolation:
 "2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
-# You can put any Julia expression inside the parenthesis.
+# You can put any Julia expression inside the parentheses.
 
 # Another way to format strings is the printf macro.
 @printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000
@@ -99,6 +103,11 @@ false
 # Printing is easy
 println("I'm Julia. Nice to meet you!")
 
+# String can be compared lexicographically
+"good" > "bye" # => true
+"good" == "good" # => true
+"1 + 2 = 3" == "1 + 2 = $(1+2)" # => true
+
 ####################################################
 ## 2. Variables and Collections
 ####################################################
@@ -114,11 +123,11 @@ catch e
     println(e)
 end
 
-# Variable names start with a letter.
+# Variable names start with a letter or underscore.
 # After that, you can use letters, digits, underscores, and exclamation points.
 SomeOtherVar123! = 6 # => 6
 
-# You can also use unicode characters
+# You can also use certain unicode characters
 ☃ = 8 # => 8
 # These are especially handy for mathematical notation
 2 * π # => 6.283185307179586
@@ -142,12 +151,16 @@ a = Int64[] # => 0-element Int64 Array
 
 # 1-dimensional array literals can be written with comma-separated values.
 b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6]
+b = [4; 5; 6] # => 3-element Int64 Array: [4, 5, 6]
 b[1] # => 4
 b[end] # => 6
 
-# 2-dimentional arrays use space-separated values and semicolon-separated rows.
+# 2-dimensional arrays use space-separated values and semicolon-separated rows.
 matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
 
+# Arrays of a particular Type
+b = Int8[4, 5, 6] # => 3-element Int8 Array: [4, 5, 6]
+
 # Add stuff to the end of a list with push! and append!
 push!(a,1)     # => [1]
 push!(a,2)     # => [1,2]
@@ -190,7 +203,7 @@ end
 # inside the julia folder to find these files.
 
 # You can initialize arrays from ranges
-a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5]
+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]
@@ -242,7 +255,7 @@ e, d = d, e  # => (5,4) # d is now 5 and e is now 4
 empty_dict = Dict() # => Dict{Any,Any}()
 
 # You can create a dictionary using a literal
-filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
+filled_dict = Dict("one"=> 1, "two"=> 2, "three"=> 3)
 # => Dict{ASCIIString,Int64}
 
 # Look up values with []
@@ -259,12 +272,12 @@ values(filled_dict)
 # Note - Same as above regarding key ordering.
 
 # Check for existence of keys in a dictionary with in, haskey
-in(("one", 1), filled_dict) # => true
-in(("two", 3), filled_dict) # => false
+in(("one" => 1), filled_dict) # => true
+in(("two" => 3), filled_dict) # => false
 haskey(filled_dict, "one") # => true
 haskey(filled_dict, 1) # => false
 
-# Trying to look up a non-existant key will raise an error
+# Trying to look up a non-existent key will raise an error
 try
     filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
 catch e
@@ -279,7 +292,7 @@ get(filled_dict,"four",4) # => 4
 # Use Sets to represent collections of unordered, unique values
 empty_set = Set() # => Set{Any}()
 # Initialize a set with values
-filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+filled_set = Set([1,2,2,3,4]) # => Set{Int64}(1,2,3,4)
 
 # Add more values to a set
 push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
@@ -289,10 +302,10 @@ in(2, filled_set) # => true
 in(10, filled_set) # => false
 
 # There are functions for set intersection, union, and difference.
-other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
+other_set = Set([3, 4, 5, 6]) # => Set{Int64}(6,4,5,3)
 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)
+setdiff(Set([1,2,3,4]),Set([2,3,5])) # => Set{Int64}(1,4)
 
 
 ####################################################
@@ -314,7 +327,7 @@ end
 
 
 # For loops iterate over iterables.
-# Iterable types include Range, Array, Set, Dict, and String.
+# Iterable types include Range, Array, Set, Dict, and AbstractString.
 for animal=["dog", "cat", "mouse"]
     println("$animal is a mammal")
     # You can use $ to interpolate variables or expression into strings
@@ -333,7 +346,7 @@ end
 #    cat is a mammal
 #    mouse is a mammal
 
-for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+for a in Dict("dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal")
     println("$(a[1]) is a $(a[2])")
 end
 # prints:
@@ -341,7 +354,7 @@ end
 #    cat is a mammal
 #    mouse is a mammal
 
-for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+for (k,v) in Dict("dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal")
     println("$k is a $v")
 end
 # prints:
@@ -387,6 +400,14 @@ end
 
 add(5, 6) # => 11 after printing out "x is 5 and y is 6"
 
+# Compact assignment of functions
+f_add(x, y) = x + y # => "f (generic function with 1 method)"
+f_add(3, 4) # => 7
+
+# Function can also return multiple values as tuple
+f(x, y) = x + y, x - y
+f(3, 4) # => (7, -1)
+
 # You can define functions that take a variable number of
 # positional arguments
 function varargs(args...)
@@ -399,14 +420,12 @@ varargs(1,2,3) # => (1,2,3)
 
 # The ... is called a splat.
 # We just used it in a function definition.
-# It can also be used in a fuction call,
+# It can also be used in a function 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)
+add([5,6]...) # this is equivalent to add(5,6)
 
-x = (1,2,3)     # => (1,2,3)
-Set(x)          # => Set{(Int64,Int64,Int64)}((1,2,3)) # a Set of Tuples
-Set(x...)       # => Set{Int64}(2,3,1)
+x = (5,6)     # => (5,6)
+add(x...)     # this is equivalent to add(5,6)
 
 
 # You can define functions with optional positional arguments
@@ -426,7 +445,7 @@ end
 
 # You can define functions that take keyword arguments
 function keyword_args(;k1=4,name2="hello") # note the ;
-    return ["k1"=>k1,"name2"=>name2]
+    return Dict("k1"=>k1,"name2"=>name2)
 end
 
 keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
@@ -528,35 +547,47 @@ 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}
+subtypes(Number) # => 2-element Array{Any,1}:
                  #     Complex{T<:Real}
-                 #     ImaginaryUnit
                  #     Real
 subtypes(Cat) # => 0-element Array{Any,1}
 
+# AbstractString, as the name implies, is also an abstract type
+subtypes(AbstractString)    # 8-element Array{Any,1}:
+                            #  Base.SubstitutionString{T<:AbstractString}
+                            #  DirectIndexString
+                            #  RepString
+                            #  RevString{T<:AbstractString}
+                            #  RopeString
+                            #  SubString{T<:AbstractString}
+                            #  UTF16String
+                            #  UTF8String
+
 # Every type has a super type; use the `super` function to get it.
 typeof(5) # => Int64
 super(Int64) # => Signed
-super(Signed) # => Real
+super(Signed) # => Integer
+super(Integer) # => Real
 super(Real) # => Number
 super(Number) # => Any
-super(super(Signed)) # => Number
+super(super(Signed)) # => Real
 super(Any) # => Any
 # All of these type, except for Int64, are abstract.
+typeof("fire") # => ASCIIString
+super(ASCIIString) # => DirectIndexString
+super(DirectIndexString) # => AbstractString
+# Likewise here with ASCIIString
 
 # <: is the subtyping operator
 type Lion <: Cat # Lion is a subtype of Cat
   mane_color
-  roar::String
+  roar::AbstractString
 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)
+Lion(roar::AbstractString) = 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
@@ -670,7 +701,7 @@ square_area(l) = l * l      # square_area (generic function with 1 method)
 square_area(5) #25
 
 # What happens when we feed square_area an integer?
-code_native(square_area, (Int32,))  
+code_native(square_area, (Int32,))
 	#	    .section    __TEXT,__text,regular,pure_instructions
 	#	Filename: none
 	#	Source line: 1              # Prologue
@@ -703,10 +734,10 @@ code_native(square_area, (Float64,))
 	#	    vmulsd  XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX)
 	#	    pop RBP
 	#	    ret
-	#	
+	#
 # Note that julia will use floating point instructions if any of the
-# arguements are floats.
-# Let's calculate the area of a circle 
+# arguments are floats.
+# Let's calculate the area of a circle
 circle_area(r) = pi * r * r     # circle_area (generic function with 1 method)
 circle_area(5)                  # 78.53981633974483
 
@@ -737,11 +768,11 @@ code_native(circle_area, (Float64,))
 	#	    vmulsd  XMM0, XMM1, XMM0
 	#	    pop RBP
 	#	    ret
-	#	
+	#
 ```
 
 ## Further Reading
 
-You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/manual/)
+You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/#Manual-1)
 
-The best place to get help with Julia is the (very friendly) [mailing list](https://groups.google.com/forum/#!forum/julia-users).
+The best place to get help with Julia is the (very friendly) [Discourse forum](https://discourse.julialang.org/).