From 876e413558f84d195be625b5c94081c7b6cf6192 Mon Sep 17 00:00:00 2001 From: Martijn Visser Date: Tue, 14 Aug 2018 22:19:14 +0200 Subject: [PATCH] fix julia 0.7 deprecation warnings --- julia.html.markdown | 63 +++++++++++++++++++++++---------------------- 1 file changed, 32 insertions(+), 31 deletions(-) diff --git a/julia.html.markdown b/julia.html.markdown index 8cbe3d5e..30aeefc2 100644 --- a/julia.html.markdown +++ b/julia.html.markdown @@ -56,10 +56,10 @@ xor(2, 4) # => 6 # bitwise xor 2 >> 1 # => 1 # arithmetic shift right 2 << 1 # => 4 # logical/arithmetic shift left -# You can use the bits function to see the binary representation of a number. -bits(12345) +# You can use the bitstring function to see the binary representation of a number. +bitstring(12345) # => "0000000000000000000000000000000000000000000000000011000000111001" -bits(12345.0) +bitstring(12345.0) # => "0100000011001000000111001000000000000000000000000000000000000000" # Boolean values are primitives @@ -107,8 +107,9 @@ try catch ; end # 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 # 4 is less than 5.300000 +# Another way to format strings is the printf macro from the stdlib Printf. +using Printf +@printf "%d is less than %f\n" 4.5 5.3 # => 5 is less than 5.300000 # Printing is easy println("I'm Julia. Nice to meet you!") @@ -128,7 +129,7 @@ some_var # => 5 # Accessing a previously unassigned variable is an error try - some_other_var # => ERROR: some_other_var not defined + some_other_var # => ERROR: UndefVarError: some_other_var not defined catch e println(e) end @@ -190,9 +191,9 @@ 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] +# we also have popfirst! and pushfirst! +popfirst!(a) # => 1 and a is now [2,4,3,4,5,6] +pushfirst!(a, 7) # => [7,2,4,3,4,5,6] # Function names that end in exclamations points indicate that they modify # their argument. @@ -236,7 +237,7 @@ length(a) # => 8 # Tuples are immutable. tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple. tup[1] # => 1 - try: +try tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64) catch e println(e) @@ -373,10 +374,11 @@ end # 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 +let x = 0 + while x < 4 + println(x) + x += 1 # Shorthand for x = x + 1 + end end # prints: # 0 @@ -530,13 +532,13 @@ typeof(DataType) # => DataType # Users can define types # They are like records or structs in other languages. -# New types are defined using the `type` keyword. +# New types are defined using the `struct` keyword. -# type Name +# struct Name # field::OptionalType # ... # end -type Tiger +struct Tiger taillength::Float64 coatcolor # not including a type annotation is the same as `::Any` end @@ -556,6 +558,7 @@ sherekhan = typeof(tigger)(5.6, "fire") # => Tiger(5.6,"fire") abstract type Cat end # just a name and point in the type hierarchy # Abstract types cannot be instantiated, but can have subtypes. +using InteractiveUtils # defines the subtype and supertype function # For example, Number is an abstract type subtypes(Number) # => 2-element Array{Any,1}: # Complex{T<:Real} @@ -563,13 +566,11 @@ subtypes(Number) # => 2-element Array{Any,1}: subtypes(Cat) # => 0-element Array{Any,1} # AbstractString, as the name implies, is also an abstract type -subtypes(AbstractString) # 6-element Array{Union{DataType, UnionAll},1}: - # Base.SubstitutionString - # Base.Test.GenericString - # DirectIndexString - # RevString - # String - # SubString +subtypes(AbstractString) # 4-element Array{Any,1}: + # String + # SubString + # SubstitutionString + # Test.GenericString # Every type has a super type; use the `supertype` function to get it. typeof(5) # => Int64 @@ -584,10 +585,10 @@ supertype(Any) # => Any typeof("fire") # => String supertype(String) # => AbstractString # Likewise here with String -supertype(DirectIndexString) # => AbstractString +supertype(SubString) # => AbstractString # <: is the subtyping operator -type Lion <: Cat # Lion is a subtype of Cat +struct Lion <: Cat # Lion is a subtype of Cat mane_color roar::AbstractString end @@ -598,10 +599,10 @@ end 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 +struct Panther <: Cat # Panther is also a subtype of Cat eye_color Panther() = new("green") - # Panthers will only have this constructor, and no default constructor. + # Panthers will only have this constructor, and no default constructor. end # Using inner constructors, like Panther does, gives you control # over how values of the type can be created. @@ -636,9 +637,9 @@ 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 +Tiger <: Cat # => false +Lion <: Cat # => true +Panther <: Cat # => true # Defining a function that takes Cats function pet_cat(cat::Cat)