Merge branch '2025W' of https://github.com/JuliaTeachingCTU/Scientific-Programming-in-Julia into 2025W

Author: TheMrGhostman

docs/src/lectures/lecture_06/lecture.md

@@ -318,17 +318,19 @@ and the output is used mainly for debugging / inspection.
 Language introspection is very convenient for investigating, how things are implemented and how they are optimized / compiled to the native code.
 
 ::: note "Reminder `@which`"
-	Though we have already used it quite a few times, recall the very useful macro `@which`, which identifies the concrete function called in a function call. For example `@which mapreduce(sin, +, [1,2,3,4])`. Note again that the macro here is a convenience macro to obtain types of arguments from the expression. Under the hood, it calls `InteractiveUtils.which(function_name, (Base.typesof)(args...))`. Funny enough, you can call `@which InteractiveUtils.which(+, (Base.typesof)(1,1))` to inspect, where `which` is defined.
+Though we have already used it quite a few times, recall the very useful macro `@which`, which identifies the concrete function called in a function call. For example `@which mapreduce(sin, +, [1,2,3,4])`. Note again that the macro here is a convenience macro to obtain types of arguments from the expression. Under the hood, it calls `InteractiveUtils.which(function_name, (Base.typesof)(args...))`. Funny enough, you can call `@which InteractiveUtils.which(+, (Base.typesof)(1,1))` to inspect, where `which` is defined.
 
-    Alternatively, you can invest time in learning `Cthulhu.jl` package, which is a tool for inspecting functions called in a function. In other words it will simplify a recursive call of which when one is interested in how internals of some function are implemented.
+Alternatively, you can invest time in learning `Cthulhu.jl` package, which is a tool for inspecting functions called in a function. In other words it will simplify a recursive call of which when one is interested in how internals of some function are implemented.
+:::
 
 ::: note "Effect analysis"
-    The compiler is analysing the code to automatically infer some properties, which can help it to create more efficient code. This is analysis id called effect analysis and you can execute it yourself using `Base.infer_effects`. For example for our `nextfib` we obtain (on 1.11.1)
-    ```julia
-    julia> Base.infer_effects(nextfib, (Int,))
-    (+c,+e,+n,!t,+s,+m,+u,+o,+r)
-    ```
-    See the documentation for (Base.@assume_effects)[https://docs.julialang.org/en/v1/base/base/#Base.@assume_effects] for details of individual fields.
+The compiler is analysing the code to automatically infer some properties, which can help it to create more efficient code. This is analysis id called effect analysis and you can execute it yourself using `Base.infer_effects`. For example for our `nextfib` we obtain (on 1.11.1)
+```julia
+julia> Base.infer_effects(nextfib, (Int,))
+(+c,+e,+n,!t,+s,+m,+u,+o,+r)
+```
+See the documentation for (Base.@assume_effects)[https://docs.julialang.org/en/v1/base/base/#Base.@assume_effects] for details of individual fields.
+:::
 
 ### Broadcasting
 Broadcasting is not a unique concept in programming languages (Python/Numpy, MATLAB), however its implementation in Julia allows to easily fuse operations. For example 
@@ -399,9 +401,9 @@ unstable_pack = [Wolf("1", 1), Wolf("2", 2), Sheep("3", 3)]
 @code_typed map(sound, stable_pack)
 @code_typed map(sound, unstable_pack)
 ```
-::: info 
-	## Cthulhu.jl
-	`Cthulhu.jl` is a library (tool) which simplifies the above, where we want to iteratively dive into functions called in some piece of code (typically some function). `Cthulhu` is different from te normal debugger, since the debugger is executing the code, while `Cthulhu` is just lower_typing the code and presenting functions (with type of arguments inferred).
+::: info Cthulhu.jl
+`Cthulhu.jl` is a library (tool) which simplifies the above, where we want to iteratively dive into functions called in some piece of code (typically some function). `Cthulhu` is different from te normal debugger, since the debugger is executing the code, while `Cthulhu` is just lower_typing the code and presenting functions (with type of arguments inferred).
+:::
 
 ```julia
 using Cthulhu
@@ -468,57 +470,59 @@ The parsed code `p` is of type `Expr`, which according to Julia's help[^2] is *a
 [^2]: Help: [`Core.Expr`](https://docs.julialang.org/en/v1/base/base/#Core.Expr)
 
 ::: info "Symbol type"
-	When manipulations of expressions, we encounter the term `Symbol`. `Symbol` is the smallest atom from which the program (in AST representation) is built. It is used to identify an element in the language, for example variable, keyword or function name. Symbol is not a string, since string represents itself, whereas `Symbol` can represent something else (a variable). An illustrative example[^3] goes as follows.
-	```julia
-	julia> eval(:foo)
-	ERROR: foo not defined
+When manipulations of expressions, we encounter the term `Symbol`. `Symbol` is the smallest atom from which the program (in AST representation) is built. It is used to identify an element in the language, for example variable, keyword or function name. Symbol is not a string, since string represents itself, whereas `Symbol` can represent something else (a variable). An illustrative example[^3] goes as follows.
+```julia
+julia> eval(:foo)
+ERROR: foo not defined
 
-	julia> foo = "hello"
-	"hello"
+julia> foo = "hello"
+"hello"
 
-	julia> eval(:foo)
-	"hello"
+julia> eval(:foo)
+"hello"
 
-	julia> eval("foo")
-	"foo"
-	```
-	which shows that what the symbol `:foo` evaluates to depends on what – if anything – the variable `foo` is bound to, whereas "foo" always just evaluates to "foo".
+julia> eval("foo")
+"foo"
+```
+which shows that what the symbol `:foo` evaluates to depends on what – if anything – the variable `foo` is bound to, whereas "foo" always just evaluates to "foo".
 
-	Symbols can be constructed either by prepending any string with `:` or by calling `Symbol(...)`, which concatenates the arguments and create the symbol out of it. All of the following are symbols
-	```julia
-	julia> :+
-	:+
+Symbols can be constructed either by prepending any string with `:` or by calling `Symbol(...)`, which concatenates the arguments and create the symbol out of it. All of the following are symbols
+```julia
+julia> :+
+:+
 
-	julia> :function
-	:function
+julia> :function
+:function
 
-	julia> :call
-	:call
+julia> :call
+:call
 
-	julia> :x
-	:x
+julia> :x
+:x
 
-	julia> Symbol(:Very,"_twisted_",:symbol,"_definition")
-	:Very_twisted_symbol_definition
+julia> Symbol(:Very,"_twisted_",:symbol,"_definition")
+:Very_twisted_symbol_definition
 
-	julia> Symbol("Symbol with blanks")
-	Symbol("Symbol with blanks")
-	```
-	Symbols therefore allows us to operate with a piece of code without evaluating it.
+julia> Symbol("Symbol with blanks")
+Symbol("Symbol with blanks")
+```
+Symbols therefore allows us to operate with a piece of code without evaluating it.
 
-	In Julia, symbols are "interned strings", which means that compiler attaches each string a unique identifier (integer), such that it can quickly compare them. Compiler uses Symbols exclusively and the important feature is that they can be quickly compared. This is why people like to use them as keys in `Dict`.
+In Julia, symbols are "interned strings", which means that compiler attaches each string a unique identifier (integer), such that it can quickly compare them. Compiler uses Symbols exclusively and the important feature is that they can be quickly compared. This is why people like to use them as keys in `Dict`.
+:::
 
 [^3]: An [example](https://stackoverflow.com/questions/23480722/what-is-a-symbol-in-julia) provided by Stefan Karpinski.
 
 ::: info "Expressions"
-	From Julia's help[^2]:
+From Julia's help[^2]:
 
-	`Expr(head::Symbol, args...)`
+`Expr(head::Symbol, args...)`
 
-	A type representing compound expressions in parsed julia code (ASTs). Each expression consists of a head `Symbol` identifying which kind of expression it is (e.g. a call, for loop, conditional statement, etc.), and subexpressions (e.g. the arguments of a call).
-	The subexpressions are stored in a `Vector{Any}` field called args. 
+A type representing compound expressions in parsed julia code (ASTs). Each expression consists of a head `Symbol` identifying which kind of expression it is (e.g. a call, for loop, conditional statement, etc.), and subexpressions (e.g. the arguments of a call).
+The subexpressions are stored in a `Vector{Any}` field called args. 
 
-	The expression is simple yet very flexible. The head `Symbol` tells how the expression should be treated and arguments provide all needed parameters. Notice that the structure is also type-unstable. This is not a big deal, since the expression is used to generate code, hence it is not executed repeatedly.
+The expression is simple yet very flexible. The head `Symbol` tells how the expression should be treated and arguments provide all needed parameters. Notice that the structure is also type-unstable. This is not a big deal, since the expression is used to generate code, hence it is not executed repeatedly.
+:::
 
 ## Construct code from scratch
 Since `Expr` is a Julia structure, we can construct it manually as we can construct any other structure

docs/src/lectures/lecture_07/lecture.md

@@ -74,22 +74,21 @@ CodeInfo(
 )
 ```
 
-::: info 
-    ### Scope of eval
-    `eval` function is always evaluated in the global scope of the `Module` in which the macro is called (note that there is that by default you operate in the `Main` module). Moreover, `eval` takes effect **after** the function has been has been executed. This can be demonstrated as 
-    ```julia
-    add1(x) = x + 1
-    function redefine_add(x)
-        eval(:(add1(x) = x - 1))
-        add1(x)
-    end
-    julia> redefine_add(1)
-    2
-    
-    julia> redefine_add(1)
-    0
-    
-    ```
+::: info Scope of eval
+`eval` function is always evaluated in the global scope of the `Module` in which it is called (note that there is that by default you operate in the `Main` module). Moreover, `eval` takes effect **after** the function has been has been executed. This can be demonstrated as 
+```julia
+add1(x) = x + 1
+function redefine_add(x)
+    eval(:(add1(x) = x - 1))
+    add1(x)
+end
+julia> redefine_add(1)
+2
+
+julia> redefine_add(1)
+0
+```
+:::
 
 Macros are quite tricky to debug. Macro `@macroexpand` allows to observe the expansion of macros. Observe the effect as
 ```julia
@@ -103,7 +102,6 @@ function cosp2(x)
 	@replace_sin 2 + sin(x)
 end
 ```
-
 First, Julia parses the code into the AST as
 ```julia
 ex = Meta.parse("""
@@ -161,7 +159,6 @@ end
 ```
 (the `@showarg(1 + 1, :x)` raises an error, since `:(:x)` is of Type `QuoteNode`). 
 
-
 Observe that macro dispatch is based on the types of AST that are handed to the macro, not the types that the AST evaluates to at runtime.
 
 List of all defined versions of macro
@@ -228,44 +225,44 @@ end
 The error code snippet errors telling us that the expression `"$"` is outside of a quote block. This is because the macro `@no_quote` has returned a block with `$` occuring outside of `quote` or string definition.
 
 ::: info
-    Some macros like `@eval` (recall last example)
-    ```julia
-    for f in [:setindex!, :getindex, :size, :length]
-        @eval $(f)(A::MyMatrix, args...) = $(f)(A.x, args...)
-    end
-    ```
-    or `@benchmark` support interpolation of values. This interpolation needs to be handled by the logic of the macro and is not automatically handled by Julia language.
+Some macros like `@eval` (recall last example)
+```julia
+for f in [:setindex!, :getindex, :size, :length]
+    @eval $(f)(A::MyMatrix, args...) = $(f)(A.x, args...)
+end
+```
+or `@benchmark` support interpolation of values. This interpolation needs to be handled by the logic of the macro and is not automatically handled by Julia language.
+:::
 
 Macros do not know about runtime values, they only know about syntax trees. When a macro receives an expression with a `$x` in it, it can't interpolate the value of x into the syntax tree because it reads the syntax tree before `x` ever has a value! 
 
 Instead, when a macro is given an expression with `$` in it, it assumes you're going to give your own meaning to `$x`. In the case of BenchmarkTools.jl they return code that has to wait until runtime to receive the value of `x` and then splice that value into an expression which is evaluated and benchmarked. Nowhere in the actual body of the macro do they have access to the value of `x` though.
 
 
-::: info 
-	### Why `$` for interpolation?
-	The `$` string for interpolation was used as it identifies the interpolation inside the string and inside the command. For example
-	```julia
-	a = 5
-	s = "a = $(a)"
-	typoef(s)
-	println(s)
-	filename = "/tmp/test_of_interpolation"
-	run(`touch $(filename)`)
-	```
+::: info Why `$` for interpolation?
+The `$` string for interpolation was used as it identifies the interpolation inside the string and inside the command. For example
+```julia
+a = 5
+s = "a = $(a)"
+typoef(s)
+println(s)
+filename = "/tmp/test_of_interpolation"
+run(`touch $(filename)`)
+```
+:::
 
-## [Macro hygiene](@id lec7_hygiene)
+## Macro hygiene
 Macro hygiene is a term coined in 1986 addressing the following problem: if you're automatically generating code, it's possible that you will introduce variable names in your generated code that will clash with existing variable names in the scope in which a macro is called. These clashes might cause your generated code to read from or write to variables that you should not be interacting with. A macro is hygienic when it does not interact with existing variables, which means that when macro is evaluated, it should not have any effect on the surrounding code. 
 
 By default, all macros in Julia are hygienic which means that variables introduced in the macro have automatically generated names, where Julia ensures they will not collide with user's variable. These variables are created by `gensym` function / macro. 
 
-::: info 
-    ### gensym
-    
-    `gensym([tag])` Generates a symbol which will not conflict with other variable names.
-    ```julia
-    julia> gensym("hello")
-    Symbol("##hello#257")
-    ```
+::: info gensym
+`gensym([tag])` Generates a symbol which will not conflict with other variable names.
+```julia
+julia> gensym("hello")
+Symbol("##hello#257")
+```
+:::
 
 Let's demonstrate it on our own version of an macro `@elapsed` which will return the time that was needed to evaluate the block of code.
 ```julia
@@ -477,7 +474,7 @@ module Exfiltrator
 const environment = Dict{Symbol, Any}()
 
 function copy_variables!(d::Dict)
-	foreach(k -> delete!(environment, k), keys(environment))
+	empty!(environment)
 	for (k, v) in d
 		environment[k] = v
 	end