Noir

https://noir-lang.org/docs/
Admin
Noir is an open-source Domain-Specific Language for safe and seamless construction of...
Tokens:113,531
Snippets:1,026
Trust Score:7.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Install Noirup Toolchain Manager

Source: https://noir-lang.org/docs/getting_started/noir_installation

Downloads and executes the installation script for noirup. This is the primary method for setting up the Noir environment on Unix-like systems.

```bash
curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash
```

--------------------------------

### Setup TypeScript and Noir Codegen

Source: https://noir-lang.org/docs/reference/noir_codegen

Commands to initialize a TypeScript project and install the necessary noir_codegen dependency.

```shell
yarn add typescript -D
npx tsc --init
yarn add @noir-lang/noir_codegen -D
```

--------------------------------

### Nargo debugger session example

Source: https://noir-lang.org/docs/how_to/debugger/debugging_with_the_repl

A demonstration of a full debugging session for a test function, showing the start, execution, and exit sequence.

```bash
$ nargo debug --test-name test_simple_equal
[simple_noir_project] Starting debugger
At opcode 0:0 :: BRILLIG CALL func 0: inputs: [], outputs: []
> continue
(Continuing execution...)
Finished execution
> quit
[simple_noir_project] Circuit witness successfully solved
[simple_noir_project] Testing test_simple_equal... ok
```

--------------------------------

### Create Noir Project Structure

Source: https://noir-lang.org/docs/tutorials/noirjs_app

Sets up the basic directory structure for a Noir project, including the 'circuit/src' directory and the 'main.nr' and 'Nargo.toml' files. This is the minimal setup required to start writing Noir code.

```bash
mkdir -p circuit/src  
touch circuit/src/main.nr circuit/Nargo.toml  
```

--------------------------------

### Noir Main Function Signature Examples

Source: https://noir-lang.org/docs/noir/concepts/functions

Provides examples of valid and invalid parameter types for the 'main' function in Noir. 'main' requires parameters with a fixed size at compile time.

```noir
fn main(x : Field) // this is fine: passing a Field
fn main(x : [Field; 2]) // this is also fine: passing a Field with known size at compile-time
fn main(x : (Field, bool)) // 👌: passing a (Field, bool) tuple means size 2
fn main(x : str<5>) // this is fine, as long as you pass a string of size 5

fn main(x : Vec<Field>) // can't compile, has variable size
fn main(x : [Field]) // can't compile, has variable size
```

--------------------------------

### Install Nargo CLI

Source: https://noir-lang.org/docs/getting_started/quick_start

Uses the noirup script to download and install the Nargo CLI tool for managing Noir projects.

```bash
curl -L https://raw.githubusercontent.com/noir-lang/noirup/refs/heads/main/install | bash
noirup
```

--------------------------------

### Prover.toml Input Example

Source: https://noir-lang.org/docs/getting_started/project_breakdown

Example Prover.toml file providing input values for a Noir program's main function.

```toml
x = "1"
y = "2"

```

--------------------------------

### Nargo Project Structure Example

Source: https://noir-lang.org/docs/getting_started/project_breakdown

Illustrates the basic file and directory structure of a Nargo project created with `nargo new`.

```bash
- src 
- Prover.toml 
- Nargo.toml 

```

--------------------------------

### Nargo.toml Configuration for Binary Project

Source: https://noir-lang.org/docs/getting_started/project_breakdown

Example of a Nargo.toml file for a binary project, specifying package details and dependencies.

```toml
[package]
name = "noir_starter"
type = "bin"
authors = ["Alice"]
compiler_version = "0.9.0"
description = "Getting started with Noir"
entry = "circuit/main.nr"
license = "MIT"

[dependencies]
ecrecover = {tag = "v0.9.0", git = "https://github.com/colinnielsen/ecrecover-noir.git"}

```

--------------------------------

### Noir Main Function Example

Source: https://noir-lang.org/docs/getting_started/project_breakdown

A simple Noir program demonstrating a main function with input parameters and an assertion.

```noir
fn main(x : Field, y : Field) {
    assert(x != y);
}

```

--------------------------------

### Command to Start Vite Development Server (Shell)

Source: https://noir-lang.org/docs/tutorials/noirjs_app

A simple shell command to start the Vite development server, which is used to serve the Noir.js web application locally.

```shell
yarn vite dev

```

--------------------------------

### Noir Higher-Order Function Example

Source: https://noir-lang.org/docs/noir/concepts/data_types/function_types

Demonstrates the usage of higher-order functions in Noir with a practical example. It shows how to define a function that accepts another function as an argument and asserts its return value.

```noir
fn assert_returns_100(f: fn() -> Field) {
    assert(f() == 100);
}

fn main() {
    assert_returns_100(|| 100); // ok
    assert_returns_100(|| 150); // fails
}
```

--------------------------------

### Nargo.toml Configuration for Workspace

Source: https://noir-lang.org/docs/getting_started/project_breakdown

Example of a Nargo.toml file defining a workspace with multiple member crates.

```toml
[workspace]
members = ["crates/a", "crates/b"]
default-member = "crates/a"

```

--------------------------------

### Noir: Brillig Manual Constraint Coverage Example

Source: https://noir-lang.org/docs/noir/concepts/unconstrained

Demonstrates the Brillig manual constraint coverage check in Noir. It shows how results from an unconstrained function call must be constrained to ensure security. The example illustrates that a descendant value of a result must be checked against a descendant value of an argument, as seen in the `assert` statement.

```noir
unconstrained fn factor(v0: Field) -> [Field; 2] {
    ...
}

fn main f0 (foo: Field) -> [Field; 2] {
    let factored = unsafe { factor(foo) };
    assert(factored[0] * factored[1] == foo);
    return factored
}
```

--------------------------------

### Install NoirJS and Barretenberg Dependencies

Source: https://noir-lang.org/docs/tutorials/noirjs_app

Installs the necessary packages for NoirJS and Barretenberg, including the NoirJS package for program execution and witness generation, and bb.js for the Barretenberg proving backend. It also includes Vite for bundling and related polyfills.

```bash
yarn add @noir-lang/noir_js@1.0.0-beta.15 @aztec/bb.js@3.0.0-nightly.20251104 buffer vite vite-plugin-node-polyfills@0.17.0  
```

--------------------------------

### Define Circuit Inputs

Source: https://noir-lang.org/docs/getting_started/quick_start

Example content for the Prover.toml file to provide input values for circuit execution.

```toml
x = "1"
y = "2"
```

--------------------------------

### Noir Lambda Syntax Example

Source: https://noir-lang.org/docs/noir/concepts/functions

Demonstrates the creation and usage of anonymous functions (lambdas) in Noir. Lambdas are defined using the Rust-like syntax `|arg1, arg2, ..., argN| return_expression`. This example shows a simple lambda that adds 50 to its input value.

```Noir
let add_50 = |val| val + 50;
assert(add_50(100) == 150);

```

--------------------------------

### Initialize and Use HashMap in Noir

Source: https://noir-lang.org/docs/noir/standard_library/containers/hashmap

Demonstrates how to instantiate a HashMap with a specific capacity and hasher, insert key-value pairs, and retrieve values using the get method.

```noir
use poseidon::poseidon2::Poseidon2Hasher;
let mut map: HashMap<Field, u32, 12, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
map.insert(1, 2);
map.insert(3, 4);
let two = map.get(1).unwrap();
```

--------------------------------

### Execute Nargo with Custom Prover Configuration

Source: https://noir-lang.org/docs/getting_started/project_breakdown

Demonstrates how to use the Nargo CLI to execute circuits with specific input files. The first example uses the default configuration, while the second uses the -p flag to specify a custom TOML file.

```bash
nargo execute foo
```

```bash
nargo execute -p OtherProver bar
```

--------------------------------

### Prover.toml Example for Array of Structs

Source: https://noir-lang.org/docs/getting_started/project_breakdown

Prover.toml configuration for providing values for an array of structs used as input in a Noir program.

```toml
[[foos]] # foos[0]
bar = 0
baz = 0

[[foos]] # foos[1]
bar = 0
baz = 0

[[foos]] # foos[2]
bar = 1
baz = 2

```

--------------------------------

### Field Power and Constraint Methods

Source: https://noir-lang.org/docs/noir/concepts/data_types/fields

Examples for calculating powers of a field and applying bit-size constraints to ensure efficient proving.

```noir
fn main() {  
    let field = 2; 
    let pow = field.pow_32(4);  
    assert(pow == 16);  
    field.assert_max_bit_size::<32>();  
}
```

--------------------------------

### Noir Struct and Array Input Example

Source: https://noir-lang.org/docs/getting_started/project_breakdown

Demonstrates passing an array of structs to a Noir program and returning a public field.

```noir
// main.nr
struct Foo {
    bar: Field,
    baz: Field,
}

fn main(foos: [Foo; 3]) -> pub Field {
    foos[2].bar + foos[2].baz
}

```

--------------------------------

### Vector Manipulation Methods

Source: https://noir-lang.org/docs/noir/concepts/data_types/vectors

Examples of common vector operations including push_front, pop_front, pop_back, append, insert, and remove.

```noir
let mut new_vector: [Field] = @[];  
new_vector = new_vector.push_front(20);  
assert(new_vector[0] == 20);

let (first_elem, rest_of_vector) = vector.pop_front();
let (popped_vector, last_elem) = vector.pop_back();
let append = @[1, 2].append(@[3, 4, 5]);
new_vector = rest_of_vector.insert(2, 100);
let (remove_vector, removed_elem) = vector.remove(3);
```

--------------------------------

### Example: Using as_quoted_str with Macro Insertion

Source: https://noir-lang.org/docs/noir/standard_library/meta/ctstring

Demonstrates how to use the `as_quoted_str` method in conjunction with macro insertion (`!`) to obtain a compile-time string literal of a known size.

```noir
let my_ctstring = "foo bar".as_ctstring();
let my_str: str<7> = my_ctstring.as_quoted_str!();

assert_eq(crate::meta::type_of(my_str), quote { str<7> }.as_type());
```

--------------------------------

### Using Runtime Assertions in Noir

Source: https://noir-lang.org/docs/noir/concepts/assert

Demonstrates the use of the 'assert' function to enforce predicates at runtime. Includes examples of basic equality checks, custom string messages, format strings, and using custom types as error messages.

```rust
fn main(x : Field, y : Field) { assert(x == y); }
assert(x == y, "x and y are not equal");
assert(x == y, f"Expected x == y, but got {x} == {y}");
struct myStruct { myField: Field }
let s = myStruct { myField: y };
assert(s.myField == x, s);
```

--------------------------------

### Define Oracle with Array Parameters

Source: https://noir-lang.org/docs/how_to/how-to-oracles

Example of defining an oracle that accepts and returns array types instead of single field values.

```noir
#[oracle(getSqrt)]
unconstrained fn sqrt([Field; 2]) -> [Field; 2] { }
```

--------------------------------

### Noir: Brillig Constraints Check with Lookback

Source: https://noir-lang.org/docs/noir/concepts/unconstrained

Illustrates the use of the `--enable-brillig-constraints-check-lookback` option in Noir's `nargo` tool. This option helps avoid false positives in the Brillig constraint coverage check by following descendant values from operations preceding the call itself, as shown in the `unconstrained_add` example.

```noir
unconstrained fn unconstrained_add(v0: Field, v1: Field) -> Field {
    v0 + v1
}

fn main f0 (v0: Field, v1: Field) {
    let foo = v0 + v1;
    let bar = unsafe { unconstrained_add(v0, v1) };
    assert(foo == bar);
    return bar
}
```

--------------------------------

### Initialize Noir Project

Source: https://noir-lang.org/docs/getting_started/quick_start

Creates a new Noir project directory structure including the main circuit file and configuration file.

```bash
nargo new hello_world
```

--------------------------------

### Initialize and Populate BoundedVec

Source: https://noir-lang.org/docs/noir/standard_library/containers/boundedvec

Demonstrates how to instantiate a BoundedVec with a specified maximum length and populate it using a loop.

```noir
let mut vector: BoundedVec<Field, 10> = BoundedVec::new();
for i in 0..5 {
    vector.push(i);
}
assert(vector.len() == 5);
assert(vector.max_len() == 10);
```

--------------------------------

### Instantiate and Access Struct Fields

Source: https://noir-lang.org/docs/noir/concepts/data_types/structs

Shows how to create an instance of a struct using key-value pairs and how to access individual fields using dot notation.

```noir
fn main() {  
    let legs = 4;  
  
    let dog = Animal {  
        eyes: 2,  
        hands: 0,  
        legs,  
    };  
  
    let zero = dog.hands;  
}  
```

--------------------------------

### Noir fmtstr as_quoted_str Method and Example

Source: https://noir-lang.org/docs/noir/standard_library/fmtstr

The `as_quoted_str` method for the `fmtstr<N, T>` type returns the format string's content, including the leading and trailing double quotes, as a `Quoted` string literal. The example demonstrates its usage in a comptime block, asserting the formatted output.

```noir
pub comptime fn as_quoted_str(self) -> Quoted {
  
}
```

```noir
comptime {
        let x = 1;
        let f: str<_> = f"x = {x}".as_quoted_str!();
        assert_eq(f, "x = 0x01");
    }
```

--------------------------------

### Derive Hash Trait

Source: https://noir-lang.org/docs/noir/standard_library/meta

An example implementation of a derive handler for the Hash trait using make_trait_impl.

```rust
comptime fn derive_hash(s: TypeDefinition) -> Quoted {  
    let name = quote { $crate::hash::Hash };  
    let signature = quote { fn hash<H>(_self: Self, _state: &mut H) where H: $crate::hash::Hasher };  
    let for_each_field = |name| quote { _self.$name.hash(_state); };  
    crate::meta::make_trait_impl(  
        s,  
        name,  
        signature,  
        for_each_field,  
        quote {},  
        |fields| fields,  
    )  
}
```

--------------------------------

### Initialize and Use Noir Vectors

Source: https://noir-lang.org/docs/noir/concepts/data_types/vectors

Demonstrates how to declare a vector using the @[] literal syntax and how to add elements using push_back.

```noir
fn main() -> pub u32 {  
    let mut vector: [Field] = @[0; 2];  
  
    let mut new_vector = vector.push_back(6);  
    new_vector.len()  
}
```

--------------------------------

### Instantiate Noir and Barretenberg backend

Source: https://noir-lang.org/docs/tutorials/noirjs_app

Initializes the Noir instance and the UltraHonkBackend using the compiled circuit bytecode and the Barretenberg API.

```javascript
show('logs', 'Creating Noir...');
const noir = new Noir(circuit);
show('logs', 'Creating Barretenberg...');
const barretenbergAPI = await Barretenberg.new();
show('logs', 'Creating UltraHonkBackend...');
const backend = new UltraHonkBackend(circuit.bytecode, barretenbergAPI);
```

--------------------------------

### Noir Function to TypeScript Binding Example

Source: https://noir-lang.org/docs/reference/noir_codegen

Demonstrates the transformation of a Noir function into a generated TypeScript function for circuit execution.

```noir
#[export]
fn not_equal(x: Field, y: Field) -> bool {
    x != y
}
```

```typescript
export type Field = string;

export const is_equal_circuit: CompiledCircuit = {"abi":{...}, "bytecode": "..."};

export async function is_equal(x: Field, y: Field, foreignCallHandler?: ForeignCallHandler): Promise<boolean> {
  const program = new Noir(is_equal_circuit);
  const args: InputMap = { x, y };
  const { returnValue } = await program.execute(args, foreignCallHandler);
  return returnValue as boolean;
}
```

--------------------------------

### Create HashMap with Default or Hasher

Source: https://noir-lang.org/docs/noir/standard_library/containers/hashmap

Shows how to create an empty HashMap using the default constructor or by providing a specific BuildHasher instance.

```noir
let hashmap: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
assert(hashmap.is_empty());

let my_hasher: BuildHasherDefault<Poseidon2Hasher> = Default::default();
let hashmap_with_hasher: HashMap<u8, u32, 10, BuildHasherDefault<Poseidon2Hasher>> = HashMap::with_hasher(my_hasher);
```

--------------------------------

### Instantiating and Indexing Arrays in Noir

Source: https://noir-lang.org/docs/noir/concepts/data_types/arrays

Demonstrates how to declare arrays with explicit or inferred types, access elements via indexing, and create arrays with repeated values.

```noir
fn main(x : u64, y : u64) { let my_arr = [x, y]; let your_arr: [u64; 2] = [x, y]; }
fn main() { let a = [1, 2, 3, 4, 5]; let first = a[0]; let second = a[1]; }
let array: [Field; 32] = [0; 32];
```

--------------------------------

### Reduce Array Elements in Noir

Source: https://noir-lang.org/docs/noir/concepts/data_types/arrays

Reduces a non-empty array to a single value using the first element as the starting accumulator.

```Noir
fn main() {  
    let arr = [2, 2, 2, 2, 2];  
    let reduced = arr.reduce(|a, b| a + b);  
    assert(reduced == 10);  
}
```

--------------------------------

### Mutable Reference Limitation Example

Source: https://noir-lang.org/docs/reference/debugger/debugger_known_limitations

Demonstrates a scenario where the Noir debugger fails to observe state changes made through mutable references.

```noir
let mut x = 1;  
let y = &mut x;  
*y = 2;
```

--------------------------------

### Token Combination and Formatting

Source: https://noir-lang.org/docs/noir/concepts/comptime

Demonstrates how to combine and format tokens, including converting between string and Quoted types, and handling spaces between tokens.

```APIDOC
## Combining Tokens

### Description
Explains how `Quoted` tokens are combined and the difference between string and vector appending. Shows how to use format strings and `.quoted_contents()` for string semantics, and `.tokens()` for iterating over individual tokens.

### Method
N/A (Illustrative Code)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```noir
comptime {
    let x = 3;
    let q = quote { foo$x }; // This is [foo, 3], not [foo3]

    // Spaces are ignored in general, they're never part of a token
    assert_eq(q, quote { foo   3 });
}
```

### Response
N/A

## Concatenating Quoted Values

### Description
Provides a function `concatenate` to join two `Quoted` values, ensuring each has only one token. Also includes `double_spaced` to format a `Quoted` value with double spaces between tokens, and a test case.

### Method
N/A (Illustrative Code)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```noir
comptime fn concatenate(q1: Quoted, q2: Quoted) -> Quoted {
        assert(q1.tokens().len() <= 1);
        assert(q2.tokens().len() <= 1);

        f"{q1}{q2}".quoted_contents()
    }

    // The CtString type is also useful for a compile-time string of unbounded size
    // so that you can append to it in a loop.
    comptime fn double_spaced(q: Quoted) -> CtString {
        let mut result = "".as_ctstring();

        for token in q.tokens() {
            if result != "".as_ctstring() {
                result = result.append_str("  ");
            }
            result = result.append_fmtstr(f"{token}");
        }

        result
    }

    #[test]
    fn concatenate_test() {
        comptime {
            let result = concatenate(quote {foo}, quote {bar});
            assert_eq(result, quote {foobar});

            let result = double_spaced(quote {foo bar 3}).as_quoted_str!();
            assert_eq(result, "foo  bar  3");
        }
    }
```

### Response
N/A
```

--------------------------------

### Define a Noir test function

Source: https://noir-lang.org/docs/how_to/debugger/debugging_with_the_repl

A basic example of a Noir test function using the #[test] attribute and an assert statement to verify equality.

```noir
#[test]
fn test_simple_equal() {
    let x = 2;
    let y = 1 + 1;
    assert(x == y, "should be equal");
}
```

--------------------------------

### Noir BoundedVec: Get Max Length

Source: https://noir-lang.org/docs/noir/standard_library/containers/boundedvec

Returns the maximum number of elements the vector can hold, which is determined by the `MaxLen` generic parameter it was initialized with.

```noir
pub fn max_len(_self: BoundedVec<T, MaxLen>) -> u64 {
  
}
```

```noir
let mut v: BoundedVec<Field, 5> = BoundedVec::new();

    assert(v.max_len() == 5);
    v.push(10);
    assert(v.max_len() == 5);

```

--------------------------------

### Declare and Import Modules in Noir

Source: https://noir-lang.org/docs/noir/modules_packages_crates/modules

Demonstrates how to define a module in the crate root using 'mod' and invoke its functions. Shows both flat file structure (src/foo.nr) and directory-based structure (src/foo/mod.nr).

```Noir
// src/main.nr
mod foo;

fn main() {
    foo::hello_world();
}

// src/foo.nr
fn from_foo() {}
```

--------------------------------

### Noir BoundedVec: Get Length

Source: https://noir-lang.org/docs/noir/standard_library/containers/boundedvec

Returns the current number of elements in the vector. This value increases when elements are pushed and decreases when elements are popped.

```noir
pub fn len(self) -> u64 {
  
}
```

```noir
let mut v: BoundedVec<Field, 4> = BoundedVec::new();
    assert(v.len() == 0);

    v.push(100);
    assert(v.len() == 1);

    v.push(200);
    v.push(300);
    v.push(400);
    assert(v.len() == 4);

    let _ = v.pop();
    let _ = v.pop();
    assert(v.len() == 2);

```

--------------------------------

### Get Module Parent

Source: https://noir-lang.org/docs/noir/standard_library/meta/module

Returns the parent module of the current module, if one exists. Returns an Option type which is None for the top-level module.

```noir
mod module1 {  
    pub mod module2 {}  
}  
  
#[test]  
fn parent_test() {  
    comptime {  
        let my_module2 = quote [module1::module2].as_module().unwrap();  
        assert_eq(my_module2.name(), quote [module2]);  
  
        let my_module1 = my_module2.parent().unwrap();  
        assert_eq(my_module1.name(), quote [module1]);  
  
        let top_level_module = my_module1.parent().unwrap();  
        assert_eq(top_level_module.name(), quote []);  
    }  
}
```

--------------------------------

### Noir String Declaration and Logging

Source: https://noir-lang.org/docs/noir/concepts/data_types/strings

Demonstrates the declaration of fixed-length strings and their usage with logging functions like println() and assert(). It shows how to define string variables with specific lengths and compare them.

```Noir
fn main(message : pub str<11>, hex_as_string : str<4>) {
    println(message);
    assert(message == "hello world");
    assert(hex_as_string == "0x41");
}
```

--------------------------------

### Noir: Get Function Name

Source: https://noir-lang.org/docs/noir/standard_library/meta/function_def

Returns the name of the function definition as a `Quoted` type. This allows for programmatic access to the function's identifier.

```Noir
pub comptime fn name(self) -> Quoted {}
```

--------------------------------

### Run Noir REPL Debugger

Source: https://noir-lang.org/docs/reference/debugger/debugger_repl

Command to initialize the Noir debugger. It supports optional flags for prover configuration, test selection, and oracle resolution.

```bash
nargo debug [OPTIONS] [WITNESS_NAME]
```

--------------------------------

### Configure CORS Middleware for Express

Source: https://noir-lang.org/docs/how_to/how-to-oracles

Provides instructions for installing and configuring the CORS middleware in an Express application to resolve cross-origin request issues during development.

```bash
yarn add cors
```

```javascript
import cors from "cors";

const app = express();
app.use(cors());
```

--------------------------------

### Basic println and print Usage in Noir

Source: https://noir-lang.org/docs/noir/standard_library/logging

Demonstrates the basic usage of `println` and `print` with different data types like structs, integers, and strings in Noir. These statements are useful for debugging purposes. Note that vectors are currently unsupported.

```Noir
struct Person {
    age: u32,
    height: u32,
}

fn main(age: u32, height: u32) {
    let person = Person {
        age: age,
        height: height,
    };
    println(person);
    println(age + height);
    println("Hello world!");
}

```

--------------------------------

### Derive Ord Trait

Source: https://noir-lang.org/docs/noir/standard_library/meta

An example implementation of a derive handler for the Ord trait using make_trait_impl, demonstrating how to handle field comparisons and result accumulation.

```rust
comptime fn derive_ord(s: TypeDefinition) -> Quoted {  
    let name = quote { $crate::cmp::Ord };  
    let signature = quote { fn cmp(_self: Self, _other: Self) -> $crate::cmp::Ordering };  
    let for_each_field = |name| quote {  
        if result == $crate::cmp::Ordering::equal() {  
            result = _self.$name.cmp(_other.$name);  
        }  
    };  
    let body = |fields| quote {  
        let mut result = $crate::cmp::Ordering::equal();  
        $fields  
        result  
    };  
    crate::meta::make_trait_impl(s, name, signature, for_each_field, quote {}, body)  
}
```

--------------------------------

### Noir: Get Function Return Type

Source: https://noir-lang.org/docs/noir/standard_library/meta/function_def

Retrieves the `Type` of the value returned by the function definition. This is essential for type checking and understanding function outputs.

```Noir
pub comptime fn return_type(self) -> Type {}
```

--------------------------------

### Initialize JavaScript boilerplate for Noir app

Source: https://noir-lang.org/docs/tutorials/noirjs_app

Provides helper functions for logging to the UI and sets up an event listener for the submit button. This serves as the foundation for handling circuit execution logic.

```javascript
const show = (id, content) => {
  const container = document.getElementById(id);
  container.appendChild(document.createTextNode(content));
  container.appendChild(document.createElement('br'));
};

document.getElementById('submit').addEventListener('click', async () => {
  try {
    // code will go in here
  }  catch {
    show('logs', 'Oh 💔');
  }
});
```

--------------------------------

### Profile Noir Program Proving Backend Gates

Source: https://noir-lang.org/docs/tooling/profiler

This command profiles the proving backend gates footprint of a Noir program. It requires the path to the program's artifact, the proving backend binary, and an output directory. Dependencies include the Noir compiler and a compatible proving backend (e.g., Barretenberg). The output is a flamegraph visualizing gate distribution.

```bash
noir-profiler gates --artifact-path ./target/program.json --backend-path bb --output ./target -- --include_gates_per_opcode
```

--------------------------------

### Manage Nargo Versions with Noirup

Source: https://noir-lang.org/docs/getting_started/noir_installation

Commands to install specific versions or nightly builds of Nargo. These commands allow developers to switch between different toolchain releases.

```bash
noirup --version nightly
noirup --version <version>
```

--------------------------------

### Define and use unsigned integers

Source: https://noir-lang.org/docs/noir/concepts/data_types/integers

Demonstrates declaring unsigned integers using the 'u' prefix and bit size, and performing basic arithmetic.

```noir
fn main() {  
    let x: u8 = 1;  
    let y = 1_u8;  
    let z = x + y;  
    assert (z == 2);  
}
```

--------------------------------

### Get HashMap capacity in Noir

Source: https://noir-lang.org/docs/noir/standard_library/containers/hashmap

Returns the static maximum capacity of the hash map. Note that Noir hashmaps have a fixed capacity defined at compile time.

```Noir
pub fn capacity(_self: Self) -> u32 { }
let empty_map: HashMap<Field, Field, 42, BuildHasherDefault<Poseidon2Hasher>> = HashMap::default();
assert(empty_map.capacity() == 42);
```

--------------------------------

### Using $crate for Path Resolution

Source: https://noir-lang.org/docs/noir/concepts/comptime

Shows how to use the $crate keyword within a quote to ensure that function paths resolve correctly regardless of where the macro is invoked.

```Noir
pub fn double(x: u64) -> u64 { x * 2 }  

comptime fn double_twice(code: Quoted) -> Quoted {  
    quote {  
        $crate::double($crate::double($code))  
    }  
}
```

--------------------------------

### Specify Local Dependency in Nargo.toml

Source: https://noir-lang.org/docs/noir/modules_packages_crates/dependencies

This snippet demonstrates how to include a dependency that is located on your local file system. It uses the 'path' key to specify the relative location of the local library crate.

```toml
# Nargo.toml  
  
[dependencies]  
lib_a = { path = "../lib_a" }  

```

--------------------------------

### Noir TypedExpr: Get Type

Source: https://noir-lang.org/docs/noir/standard_library/meta/typed_expr

Returns the type of a resolved expression. If there were errors during resolution, it returns Option::none(). This is useful for inspecting the type information of expressions.

```noir
pub comptime fn get_type(self) -> Option<Type> {}
```

--------------------------------

### Compile Nargo from Source

Source: https://noir-lang.org/docs/getting_started/noir_installation

Commands to build Nargo from various source locations including specific branches, forks, pull requests, commits, or local directories.

```bash
noirup --branch <branch-name>
noirup --repo <username/repo>
noirup --repo <username/repo> --branch <branch-name>
noirup --pr <pr-number>
noirup -C <commit-hash>
noirup --path ./path/to/local/source
```

--------------------------------

### Handling Overlapping Trait Implementations

Source: https://noir-lang.org/docs/noir/concepts/traits

Provides an example of an invalid implementation that causes an overlap error, demonstrating Noir's strict rules against ambiguous trait resolution.

```Noir
trait Trait {} impl<A, B> Trait for (A, B) {} impl Trait for (Field, Field) {}
```

--------------------------------

### Noir TypedExpr: Get Function Definition

Source: https://noir-lang.org/docs/noir/standard_library/meta/typed_expr

Retrieves the function definition if the expression refers to one. Returns Option::none() otherwise. This method operates on resolved and type-checked expressions.

```noir
pub comptime fn as_function_definition(self) -> Option<FunctionDefinition> {}
```

--------------------------------

### Using Compile-Time Static Assertions in Noir

Source: https://noir-lang.org/docs/noir/concepts/assert

Demonstrates the use of 'static_assert' to validate conditions during compilation. Shows how to use it with constants and known lengths, and illustrates scenarios where it fails due to dynamic runtime values.

```rust
fn main(xs: [Field; 3]) {
    let x = 2;
    let y = 4;
    static_assert(x + x == y, "expected 2 + 2 to equal 4");
    static_assert(xs.len() == 3, "expected the input to have 3 elements");
}
static_assert(x + x == y, f"Expected 2 + 2 to equal 4 but got: {x} + {x} == {y}");
fn main(x : Field, y : Field) {
    static_assert(x == 2, "expected x to be known at compile-time and equal to 2");
    let mut example_vector = @[];
    if y == 4 { example_vector = example_vector.push_back(0); }
    static_assert(example_vector.len() == 0, "expected an empty vector, known at compile-time");
}
```

--------------------------------

### Create New BoundedVec with Type Annotation

Source: https://noir-lang.org/docs/noir/standard_library/containers/boundedvec

Shows the correct way to initialize a BoundedVec using explicit type annotations to define the maximum length.

```noir
fn good() -> BoundedVec<Field, 10> {
    let v1: BoundedVec<Field, 3> = BoundedVec::new();
    let v2 = BoundedVec::new();
    v2
}
```

--------------------------------

### Noir Variable Shadowing Example

Source: https://noir-lang.org/docs/noir/concepts/shadowing

Demonstrates how variables can be shadowed in Noir. The inner scope re-declares 'x', affecting its value locally without changing the outer scope's 'x'.

```Noir
fn main() {
    let x = 5;

    {
        let x = x * 2;
        assert (x == 10);
    }

    assert (x == 5);
}
```

--------------------------------

### Global Variable Declaration and Usage

Source: https://noir-lang.org/docs/noir/concepts/globals

Demonstrates the basic syntax for declaring global variables with specified types and their usage in functions.

```APIDOC
## Global Variables

### Declaration and Initialization

Noir supports global variables that must have their types explicitly specified by the user.

```noir
global N: Field = 5;

global TUPLE: (Field, Field) = (3, 2);

fn main() {
    assert(N == 5);
    assert(N == TUPLE.0 + TUPLE.1);
}
```

### Dependency Rules

Globals can be initialized with any expression, but they must not depend on themselves to avoid dependency cycles.

```noir
// This will cause a dependency error
global T: u32 = foo(T);
```

### Globals for Array Lengths

If initialized to a literal integer, globals can define the length of an array.

```noir
global N: u32 = 2;

fn main(y : [Field; N]) {
    assert(y[0] == y[1])
}
```

### Importing Globals from Other Modules

Globals can be imported or referenced from other modules like any other name.

```noir
global N: Field = 20;

fn main() {
    assert(my_submodule::N != N);
}

mod my_submodule {
    global N: Field = 10;
}
```

### Global Variable Expansion

When a global is used, Noir replaces its name with its definition at each occurrence. This means function calls in initializations will be repeated.

```noir
global RESULT: [Field; 100] = foo();

fn foo() -> [Field; 100] {
    // ... implementation ...
}
```

Noir typically optimizes function calls that don't depend on program inputs into constants. However, be mindful of side effects (like `println`) in called functions, as they will occur on each use.
```

--------------------------------

### Noir: Get Function's Module

Source: https://noir-lang.org/docs/noir/standard_library/meta/function_def

Retrieves the `Module` object representing the module in which the function definition is declared. This provides context about the function's location within the project structure.

```Noir
pub comptime fn module(self) -> Module {}
```

--------------------------------

### Demonstrating Noir Type Coercions

Source: https://noir-lang.org/docs/noir/concepts/data_types/coercions

This example illustrates how Noir automatically coerces fixed-size arrays to vectors, constrained functions to unconstrained functions, and string literals to CtString within comptime blocks.

```noir
fn requires_vector(_vector: [Field]) {}  
comptime fn requires_ct_string(_s: CtString) {}  
  
fn main() {  
    let array: [Field; 4] = [1, 2, 3, 4];  
  
    // Ok - array is converted to a vector  
    requires_vector(array);  
    // equivalent to:  
    requires_vector(array.as_vector());  
  
    // coerce a constrained function to an unconstrained one:  
    let f: unconstrained fn([Field]) = requires_vector;  
  
    comptime {  
        // Passing a str<6> where a CtString is expected  
        requires_ct_string("hello!")  
    }  
}  
```

--------------------------------

### Noir: Get Function Parameters

Source: https://noir-lang.org/docs/noir/standard_library/meta/function_def

Returns a list of tuples, where each tuple contains a parameter's pattern (`Quoted`) and its type (`Type`). This method provides detailed information about the function's signature.

```Noir
pub comptime fn parameters(self) -> [(Quoted, Type)] {}
```

--------------------------------

### Define Comptime Blocks

Source: https://noir-lang.org/docs/noir/concepts/comptime

Demonstrates how to use comptime blocks within functions to execute code during the compilation phase.

```noir
fn one() {  
    comptime { println("one"); }  
}  
  
fn two() {  
    comptime { println("two"); }  
}
```

--------------------------------

### Mutable References and Value Copying in Noir

Source: https://noir-lang.org/docs/noir/concepts/mutability

Explains that creating a mutable reference requires the original variable to be mutable. Demonstrates dereferencing to get a copy of the value and how mutations on the copy do not affect the original.

```noir
fn main() {
    let mut x = 1;
    let x_ref = &mut x;

    let mut y = *x_ref;
    let y_ref = &mut y;

    x = 2;
    *x_ref = 3;

    y = 4;
    *y_ref = 5;

    assert(x == 3);
    assert(*x_ref == 3);
    assert(y == 5);
    assert(*y_ref == 5);
}
```
Tokens:
Raw