Mojo🔥 Language Basics

Let’s start with the basics. Print “Hello Mojo🔥” just like you would in Python

Click for solution ✅
print("Hello Mojo🔥")

Awesome! Now let’s write a Python function and bring it over to Mojo🔥. Write a Python function that accepts 2 inputs and returns their sum as the output.

Note: You can run Python code in Mojo🔥 Notebooks by simply adding %%python at the start of the cell. This code will run be run by the Python interpretor, NOT Mojo🔥. It’s a great way to blend Mojo and Python code when getting started.

Click for solution ✅
%%python
def add_numbers(a,b):
    c = a + b
    return c
a = 2
b = 3
c = add_numbers(a,b)
print(c)

Great! Now remove the %%python and paste the function in the next cell. This should now run as Mojo🔥 code. Mojo shares syntax with Python making it easy for you to port your code over to Mojo for it’s performance benefits.

Convert python-like def() to mojo🔥 fn() by adding types

Unlike Python, Mojo is a compiled language and even though you can still use flexible types like in Python, Mojo lets you declare types so the compiler can optimize the code based on those types, and improve performance. Add type Float32 to a, b and return type.

Click for solution ✅
def add_numbers(a: Float32, b: Float32) -> Float32:
    c = a + b
    return c
a = 2
b = 3
c = add_numbers(a,b)
print(c)

#Hint: def add_numbers(a: Float32, b: Float32) ...

In addition to types, variables can be declared with let and var. Mojo offers optional variable declarations to declare variables as immutable with let (i.e. cannot be modified after creation) or mutable with var (i.e. can be modified). Benefits of variable declarations are type safety and performance.

Mojo🔥 also supports fn functions in addition to python-like def functions. fn functions enforce strict type checking and variable declarations. While def allows you to write more dynamic code, fn functions can improve performance by lowering overhead of figuring out data types at runtime and helps you avoid a variety of potential runtime errors.

Replace def by fn and add let or var

Click for solution ✅
fn add_numbers(a: Float32,b: Float32) -> Float32:
    var c: Float32 = 0
    c = a + b
    return c
let a = 2
let b = 3
let c = add_numbers(a,b)
print(c)

#Hint fn add_numbers(a: Float32,b: Float32) ...

Mojo compile-time parameters vs. runtime arguments

Since Mojo is a compiled language, it’s functions can take in compile-time parameters and runtime arguments. Mojo functions can take the format:

Function[parameters](arguments)

where parameters represent a compile-time value and arguments in Mojo represent runtime values.

In the following example, we have an fn function that has the parameters dtype: DType and arguments a: Tensor[dtype], b: Tensor[dtype]

Change alias dtype = DType.float32 to alias dtype = DType.float64 and re run the cell

from tensor import Tensor
from random import rand

fn add_tensors[dtype: DType](a: Tensor[dtype], b: Tensor[dtype]) -> Tensor[dtype]:
    let n = a.num_elements()
    var c = Tensor[dtype](n)
    for i in range(n):
        c[i] = a[i] +  b[i]
    return c

alias dtype = DType.float32

var a = rand[dtype](10)
var b = rand[dtype](10)
let c = add_tensors[dtype](a,b)

for i in range(10):
    print_no_newline(c[i]," ")

Using Python with Mojo

Mojo provides full interoperability with the Python ecosystem, making it easy to use the Python libraries while taking advantage of Mojo’s features and performance benefits. In addition to using %%python in Jupyter notebook cells, you can also import Python modules. For example you can load numpy using:

let np = Python.import_module("numpy")

And use it as you would in Python.

from python import Python
let np = Python.import_module("numpy")
let plt = Python.import_module("matplotlib.pyplot")

Using the np and plt to create a random array and plot it’s histogram as you would in Python

Click for solution ✅
alias N = 100000
var arr = np.random.randn(N)
plt.hist(arr,100)
plt.title("distribution of arr")
plt.grid(True)
plt.show()