Julia

# Defn
x = 5
 
# Can redefine constants which is not currently in use
pi = 5
 
# Operators in brackets
(+) = f # Reassigns the operator
 
_ = a # Discards a
a = _ # Error
 
# Assignment chaining
# Assignment is basically binding value to variable
a = (b = 5) + 3 # a=8, b=5
 
a = []
b = a # Binds b to the same array (no copy made)
 
c = nothing # Equivalent to None in python

# Types
Int8, UInt8, Int128, Bool, Float16, Float64
 
# Size is arch dependent
typeof(1) # Int64 in 64 bit
 
# Diff base
a = 0x123 # typeof returns UInt
b = 0b101011
c = 0o1723
d = -0x23
 
# Max/min repr values
typemin(Int32)
 
# Floats
a = 1e10
a = 1.32
b = 0x1p0
 
a = Inf
b = NaN
 
a = big"133444444444444444444444444"
a = BigInt(133444444444444444444444444)
 
# Easy poly exprs
2x^2 + 3x + 1
# 2^3x = 2^(3x)
# 2x^3 = 2(x^3)
 
a = (x-1)x
a = x(x-1) # Error due to fn application
a = 2(x+y) # Works because literal
 
zero(Float32) # 0.0f0
one(Int32) # 1

x / y # divide
x (division symbol) y # int divide
x \ y # inverse divide
x ^ y # power
 
NaN * false # 0.0
false * Inf # 0.0
 
x (|| or &&) y # Short circuited
 
x += 1
 
# Every binary op has a corresponding vectorized dot op
# Unary like ! and (root) too
[1, 2, 3] ^ 3 # Error
[1, 2, 3] .^ 3 # Elementwise mult
 
# Nested dot calls are fused & adjacent are converted to nested forms
x .+ 3 .* x.^2 = (+).(x, (*).(3, (^).(x, 2)))
 
# @. macro applies dot op to all elements inside
2 .* A.^2 .+ sin.(A) = @. 2A^2 + sin(A)
 
# Updating op too support dot
a .+= b or @. a += b = a .= a .+ b
 
1 .+ x # Error
 
# NaN is not equal to anything
NaN == NaN # False
[1, NaN] == [1, NaN] # False
isequal([1, NaN], [1, NaN]) # True & should be used
isinf(), isfinite(), isnan() # Other useful funcs
 
# Comparisons can be chained like python & dotted
# Order of comparison is undefined
0 .< A .< 1
1 < 2 <= 3 # true
1 > 2 <= 3 # false
 
# Op precedence (:x are symbols)
Base.operator_precedence(:+) # 11
Base.operator_associativity(:-) # :left
 
# Numeric conversions
T(x) or convert(T, x) # Int8(323) - Error
x % T # Converts int types, overflows if too big w/o error
round(Int, x) = Int(round(x))
 
# sinpi, cospi provide better repr of sin(pi*x)
a = sinpi(x)
a = sind(x) # In degrees (default is radian)

# Complex numbers
1 + 2im
(2 + 3im) - 1 # 1 + 3im
3/4im = 3 / (4im)
real(), imag(), conj(), angle(), abs(), abs2() # abs squared
complex(a, b) # Use over a + b*im
 
# Rational numbers (not floats!!!)
# Always reduced to lowest form
2 // 3 # Construction
numerator(), denominator()
2//3 == 6//9 # true
0 // 0 # Error

# Char
a = 'x'
b = Int(a) # 120, Int64
c = '\u0ff' or '\U10ffff'
d = '\n' or '\t'
 
# Strings
a = "hi" or """hello"""
b = "hellllooooo \
	hi"
c = """jefej
	ejofefj"""
	
c = a[1] or a[begin] or a[end]
d = b[1:2] # Range indexing & makes a copy
e = SubString(b, 1, 2) or @views b[1:2] # Creates a view, not a copy
 
for c in s
	println(c)
end
 
nextind(), prevind(), eachindex() # To find valid indices
codeunit(s, i) # Access raw codeunit
 
# Concatenation
c = string(a, ", ", b)
c = a * ", " * b # * used rather than + to show noncommutativity
 
# Interpolation
a = 234
b = "$(a + 1) $a"
 
# Functions
findfirst(c, s), findlast(c, s), findnext(c, s, i)
occursin(s1, s2)
repeat(s, times), replace(s1, func)
join(vec, s, last_s)
length(s)
 
# Regex
reg = r"^\s" or Regex(str)
occursin(reg, s), match(reg, s)
 
# Byte array literals
bal = b"hello" # UInt8 array
 
# Version literals
ver = v"0.2"
 
# Raw literals
r = raw"huehfu" # Extra quotation should be escaped

# Definitions
function f(x, y)
	x + y
end
 
f(x, y) = x + y
 
# Calling
f(2, 3)
g = f
g(2, 3)
 
# Arg behaviour
function f!(x::Vec, y::Integer)
	x[1] = 5 # Mutates
	y = 7 # No mutation of og object
 
# Return types
# Return type enforced and return value is converted
function g(x) :: Int8 
	x
end
 
# Operator fn
# Except for &&, || all other can be used as fn
+(1, 2, 3) # 6
 
# Anon fn
x -> x^2 + x + 1
() -> 3
(x, y) -> x + y
 
# Tuples
a = (1, 2, 3) # Immutable, fixed length containers
b = (1,)
println(a[0])
 
# Named tuples
x = (a=2, b=3)
x[0] or x.a
 
# Destructuring
(a, b, c) = [1, 2, 3] # RHS has to be an iterable
_, _, c = [1, 2, 3]
arr[0], b = [1, 2] # arr[0] is mutated
 
# Slurping
# Assignment of a collection of remaining elements
a, b..., c = "hello" # a=h, b=ell, c=o
 
# Argument destructuring
f((x, y)) = x + y
f((2, 3))
 
# Property destructuring
foo((; x, y)) = x + y
foo((x=2, y=2)) # Advantage is that both structs and namedtuples can be passed
 
# Varargs
# In definition
foo(a, b, x...) = x # x is a tuple
# In caller
x = (2, 3, 4)
foo(1, x...) # a=1, b=2, x=(3, 4), the callee need not be a varargs function
 
# Optional args
function x(a, b=1, c=1)
	a
end
x(1)
x(1, 2)
x(1, 2, 3)
methods(x) # Shows all possible methods of fn x
 
# Keyword args
function x(a, b; c=1, d=1, kwargs...) # kwargs collects extra keyword args (a immutable key value iterator)
	a
end
x(1, 2, c=1, d=2)
x(1, 2, c=1, :d=>2)
# In case kwargs has same name as other keyword arg, that arg takes pref
 
# Concise do blocks
# do creates an anon fn
# do a, b = 2 args & do (a, b) = tuple arg
# do can capture vars from outer scope and automatically close streams, etc
map(x->x, [])
map([]) do x
	x
end
 
# Composition & piping
(f \circ g)(x) = f(g(x))
1:10 |> sum |> sqrt
["a", "b"] .|> [uppercase, lowercase]

# Compound exprs
z = begin
	x = 1
	y = 2
	x + y
end
z = (x=1; y=2; x+y)
 
# Conditional eval
if x < y
	...
elseif x > y
	...
else 
	...
end
 
a ? b : c
 
# Short circuits
n >= 0 || error("n must be positive")
 
# Loops
i = 0
while i <= 3
	global i += 1
end
 
for i = 1:3 # 1:3 is a range object
	...
end
for i in []
	...
end
for i = 1:2, j = 3:i # Nested loop, break exits both loops
	...
end
for (i, j) in zip([], []) ...
 
# Exceptions
struct Custom <: Exception 
	var::Symbol
end # Custom exception
throw(DomainError(1, ""))
error("") # Stops execution
try
	...
catch e
	if isa(e, DomainError) ...
else # Used instead of extending try so as to not catch more errors
	...
finally
	...
end

# Local scope
 
# Constants (best used with globals, local consts are not supported)
const pi = 3.14
const a, b = 1, 2
x::Float64 = 2.7 # Automatically a constant if globally declared

# Types
(1+2)::Int # Asserts type
a::Int = 1 + 2 # Specifies/Declares type
 
# Abstract types
abstract type Number end
abstract type Signed <: Integer end # <: specifies supertype (defaults to Any)
 
Integer <: Number # true
 
# Primitives
primitive type Float16 <: AbstractFloat 16 end # Specify bits
 
# Composite types
struct Foo
	bar
	baz::Int
end
mutable struct A
	a
	const b::Int
end
foo = Foo("", 1) # Constructor
foo.bar # ""
fieldnames(Foo) # (:bar, :baz)
 
# Type unions
IntOrStr = Union{Int, AbstractString}
Option = Union{Nothing, Int} # Like Option<T>
 
# Parametric types (types with parameters)
# Composite
struct Point{T}
	x::T
	y::T
end
Point{AbstractString} <: Point # true
Point{<:AbstractString} # Subtypes also accepted now
Point{Float64}(1.0, 2.0)
# Abstract
abstract type Pointy{T, X} end
abstract type Pointy{T<:Real} end # Guard
 
# Tuple types
Tuple{Int, String}
Tuple{Int, Vararg{String}} # Variable arg type
 
# Named tuple types
@NamedTuple{a::Int, b::String}
@NamedTuple begin 
	a::Int 
	b::String
end 
 
# UnionAll types

# Defn
f(x::Float64) = 2x
f(x::Number) = 2x
f(2.0)
f(2)
 
# Parametric methods
same_type(x::T, y::T) where {T} = true
same_type(x,y) = false
same_type_numeric(x::T, y::T) where {T<:Number} = true # Guard
 
# Redefining methods
 
# Design patterns
 

module FastThings
end
 
# Qualification
Base.sin()
Base.:+ # Needs a colon for operators
 
# Exports
module A
export b, C
const C = 5
b(x) = x
end
 
# Using modules
using A # Adds elements of export list to global namespace
using .A # Load module from locally defined module
import A # Allows only qualified access (export list does not matter)
import A as B
import A:a as b
using .A:a, b, A # Specific name imports (specify modulename itself to import it too)
 
# Adding methods
using .A or import .A:a # using .A:a won't work
A.a() = ...
 
# Baremodules (w/o containing Base, eval and include)
baremodule A
 
# Submodules
module A
module B
import ..C:a # Each . = parent
end
end

"Info" # Interpreted as markdown
foo(x) = x
 
# Enables to use raw, and other types of string including interpolation
@doc raw"""
"""
f(x) = x
 
@doc(@doc foo!)foo # Use foo!'s documentation

zeroes(Int8, (2, 3))
ones(...), trues(), falses()
reshape(), copy(), deepcopy()
range(), fill!()
Matrix{T}()
 
# Array literals
[1, 2, 3] # Tries to promote if diff types, else heterogeneous
Int8[1, 2, 3]
 
# Concatenation
[1:2, 4:5] # 2D array
[1:2; 4:5] # Vertically concats (1, 2, 4, 5)'
[1:2;; 4:5] # Horizontally concat (1, 2, 4, 5)
 
# Comprehensions
[x + y for x=1:2, y=2:3 if x + y == 2]
[(i,j) for i=1:3 for j=1:i] # Nested loop
 
# Generators
(i*2 for i=1:10)
 
# Indexing
a[1, 2]
a[(1, 2)]
x[2:3, 2:end-1] 
 
# Indexed assignment
x[2, 3] = 1
x[CartesianIndex(1, 2, 3)] # Groups indices into one obj
x[[false, true], :] # Boolean indexing
x[map(ispow2, x)]
x[5] # If x is multidim, a single element is returned in column major form