# Functional Market

# Functional Market `1.0.2`

## function pointers

If there is a conflict between the subject and the skeleton or moulinette, the subject is always right.
However, please report any inconsistencies to your assistant.
Submissions

- intranet: https://intra.forge.epita.fr/epita-prepa-computer-science/prog-104-p-03-2030/root/
- opening: `2026-04-06 10:42`
- closing: `2026-04-13 10:42`
- git tags:
  - `submit-*` (limit: 3 per week)
  - `archi-*` (limit: 2 per hour)

Repository structure
At the end, your git repo must follow this architecture:

    epita-prepa-computer-science-prog-104-p-03-2030-firstname.lastname
    ├── functional_market
    │   ├── Fundamentals
    │   │   ├── calculator.c
    │   │   ├── calculator.h
    │   │   ├── crepe_stream.c
    │   │   ├── crepe_stream.h
    │   │   ├── intro.c
    │   │   ├── intro.h
    │   │   ├── toolbox.c
    │   │   └── toolbox.h
    │   └── Proficiencies
    │       ├── list.c
    │       ├── list.h
    │       ├── visitor.c
    │       └── visitor.h
    ├── .gitignore
    └── README

Do not forget to check the following requirements before submitting your work:

- You shall obviously replace `firstname.lastname` with your login.
- The `.gitignore` file is mandatory.
- Remove all personal tests from your code, except those from the `Tests` folder.
- The given prototypes must be strictly respected.
- The code MUST compile! Otherwise you will not receive a grade.

.gitignore example
Here is an example of a `.gitignore` file:

    *.a
    *.lib
    *.o
    *.obj
    *.out

    .idea/
    *~
    *.DotSettings.user

This needs to be setup before the first submission!

# Introduction

In this practical, you will learn about how to use Function pointers.
You will need to have a thorough understanding of arrays, and trees.
You will also be using notions from previous practicals such as linked lists.
Here's a reminder: if you have trouble understanding something, just ask your assistants by making a ticker on discord!
Authorized includes

    #include <stddef.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>

Lore
The market will open soon! However, it's not ready, the villager need your help!
Lore
A villager needs your help at the crepe stand, get your tools and help them!

### `fundamentals/intro.c`

Lore
Before being able to help anyone, you need to learn how to use your tools.
To start off, you have to implement a function that returns the result of passing its `input` to a function pointer `computer`.
Prototype(s)

    int compute(int input, int (*executor)(int));

Code example(s)

    int next(int n)
    {
        return n + 1;
    }

    #include <stdio.h>
    int main(void)
    {
        int n = 3;
        printf("compute(%d, &next) = %d\n", n, compute(n, &next));
    }

Output

    compute(3, &next) = 4

Now, you have to return a function pointer depending on the `name`.
When this function pointer is executed, it needs to print one of the following lines depending on the name given.
Output

    # name = "Isabelle":
    Hello Isabelle!

    # name = "Tom Nook":
    Hi Tom Nook.

    # name = "Blathers":
    Good night Blathers!

    # name = "Mr. Resetti":
    How are you doing Mr. Resetti?

    # Anything else (including NULL):
    I don't know you!

Warning(s)
Don't forget to add a newline at the end!
Hint(s)
That means you will need to create multiple auxiliary functions. Their names do not matter, they only need to follow the right signature.
Prototype(s)

    void (*greet(char *name))(void);

Information
Understanding the signature of this function is part of the exercise.
Code example(s)

    int main(int argc, char *argv[])
    {
        (void)argc;
        (*greet(argv[1]))();
    }

Output

    $ ./greet Isabelle
    Hello Isabelle!
    $ ./greet Toto
    I don't know you!

### `fundamentals/calculator.c`

Lore
You shouldn't forget your trusty calculator!
Danger(s)
For this function, you MUST NOT use any `if`, `for`, `while` or `switch`.
Instead, you MUST use a lookup table, that store multiple functions.
You SHOULD use a typedef for functions that take two integers and return an integer.
If you do, you MUST name it `operator` and put it into your `calculator.h`.
For this function, you should return the result of the operation between `a` and `b` depending on `op`.
calculator.h

    enum operation
    {
        ADD,
        SUB,
        MUL,
        DIV,
        MOD,
    };

Prototype(s)

    int calculator(int a, int b, enum operation op);

Hint(s)
You do not need to care about invalid operations such as division by zero, and they will not be tested.
Code example(s)

    #include <stdio.h>
    int main(void)
    {
        int a = 4;
        int b = 6;
        enum operation op = ADD;
        printf("calculator(%d, %d, %d) = %d\n", a, b, op, calculator(a, b, op));
    }

Output

    calculator(4, 6, 0) = 10

### `fundamentals/toolbox.c`

Lore
One last step before you go to the market: put all your tools in the toolbox.
Information
Here are structures as well as typedefs you will be using for the following exercises.
They are already present in the `toolbox.h` header file.
Each typedef is explained in its associated function.
There will also be examples provided to better understand how they work.
In an array, only `data` itself is allocated on the heap, not its elements.
A `NULL` array is treated as an empty array, not an error.
The reason the `data` of an array is a `void *` is to allow any type of element,
such as integers, strings and other structs.
To modify its content, it is usually cast as a `char *` to have an easy access to each byte.
Here is a simple example on how to access an element of the array:
Code example(s)

    char *data = arr->data;
    char *second_element = data + arr->elem_size;
    char *fifth_element = data + 4 * arr->elem_size; // Don't forget array indexes are zero-based

toolbox.h

    #include <stddef.h>

    typedef int (*comparator)(void *, void *);
    typedef void (*mapper)(void *, void *);
    typedef int (*predicate)(void *);
    typedef void *(*reducer)(void *, void *);
    typedef void (*acceptor)(void *);

    struct array
    {
        void *data;
        size_t len;
        size_t elem_size;
    };

This function applies `f` on every element of `arr`.
Hint(s)
An `acceptor` is a function that takes a pointer to an element of the array.
Prototype(s)

    void foreach(struct array *arr, acceptor f);

Code example(s)

    #include <stdio.h>
    #include <stdlib.h>

    void print_int(int *n)
    {
        printf("%d\n", *n);
    }

    int main(void)
    {
        struct array arr = {
            .data = calloc(4, sizeof(int)),
            .len = 4,
            .elem_size = sizeof(int),
        };

        int *data = arr.data;
        data[0] = 0;
        data[1] = 1;
        data[2] = 2;
        data[3] = 3;

        foreach(&arr, (acceptor)&print_int);

        free(arr.data);
    }

Output

    0
    1
    2
    3

This function returns `arr` sorted according to `f`.
Hint(s)
A `comparator` is a function that takes two pointers to elements of the array,
and returns a value :
- equal to 0 if they are equal
- less than 0 if the first is less than the second
- greater than 0 if the first is greater than the second
Danger(s)
Be careful, only the content of `arr` must change, you MUST return `arr`.
Prototype(s)

    struct array *sort(struct array *arr, comparator f);

Code example(s)

    #include <stdio.h>
    #include <stdlib.h>

    int reverse(int *a, int *b)
    {
        return *b - *a;
    }

    void print_int(int *n)
    {
        printf("%d\n", *n);
    }

    int main(void)
    {
        struct array arr = {
            .data = calloc(4, sizeof(int)),
            .len = 4,
            .elem_size = sizeof(int),
        };

        int *data = arr.data;
        data[0] = 0;
        data[1] = 1;
        data[2] = 2;
        data[3] = 3;

        foreach(sort(&arr, (comparator)&reverse), (acceptor)&print_int);

        free(arr.data);
    }

Output

    3
    2
    1
    0

This function returns `arr` mapped according to `f`.
Hint(s)
A `mapper` is a function that takes two pointers.
The first is the destination, and the second is the source.
Information
To map an array means creating a new array by applying a function on each of the elements.
The types of the elements in the array before and after mapping CAN be different.
Danger(s)
Be careful, only the content of `arr` must change, you MUST return `arr`.
You will need to reallocate a new `arr->data`, and free the previous one.
Hint(s)
`output_size` is the size of an element after mapping.
Don't forget to update `arr` with it!
Prototype(s)

    struct array *map(struct array *arr, size_t output_size, mapper f);

Code example(s)

    #include <stdio.h>
    #include <stdlib.h>

    void next(double *res, int *n)
    {
        *res = *n + 1;
    }

    void print_double(double *n)
    {
        printf("%.1lf\n", *n);
    }

    int main(void)
    {
        struct array arr = {
            .data = calloc(4, sizeof(int)),
            .len = 4,
            .elem_size = sizeof(int),
        };

        int *data = arr.data;
        data[0] = 0;
        data[1] = 1;
        data[2] = 2;
        data[3] = 3;

        foreach(map(&arr, sizeof(double), (mapper)&next), (acceptor)&print_double);

        free(arr.data);
    }

Output

    1.0
    2.0
    3.0
    4.0

This function returns `arr` filtered according to if `f` is true.
Hint(s)
A `predicate` is a function that takes a pointer to an element of the array, and returns a value:
- equal to 0 if the predicate is false
- different from 0 if the predicate is true
Danger(s)
Be careful, only the content of `arr` must change, you MUST return `arr`.
Prototype(s)

    struct array *filter(struct array *arr, predicate f);

Code example(s)

    #include <stdio.h>
    #include <stdlib.h>

    int odd(int *n)
    {
        return *n % 2;
    }

    void print_int(int *n)
    {
        printf("%d\n", *n);
    }

    int main(void)
    {
        struct array arr = {
            .data = calloc(4, sizeof(int)),
            .len = 4,
            .elem_size = sizeof(int),
        };

        int *data = arr.data;
        data[0] = 0;
        data[1] = 1;
        data[2] = 2;
        data[3] = 3;

        foreach(filter(&arr, (predicate)&odd), (acceptor)&print_int);

        free(arr.data);
    }

Output

    1
    3

This function returns the result of `arr` reduced by `f`.
Hint(s)
A `reducer` is a function that takes two pointers.
The first is the destination, and the second is the source.
It also returns the destination.
Prototype(s)

    void *reduce(struct array *arr, void *start_value, reducer f);

Code example(s)

    #include <stdio.h>
    #include <stdlib.h>

    int *add(int *res, int *n)
    {
        *res += *n;
        return res;
    }

    void print_int(int *n)
    {
        printf("%d\n", *n);
    }

    int main(void)
    {
        struct array arr = {
            .data = calloc(4, sizeof(int)),
            .len = 4,
            .elem_size = sizeof(int),
        };

        int *data = arr.data;
        data[0] = 0;
        data[1] = 1;
        data[2] = 2;
        data[3] = 3;

        int res = 0;
        reduce(&arr, &res, (reducer)&add);
        printf("%d\n", res);

        free(arr.data);
    }

Output

    6

### `fundamentals/crepe_stream.c`

Lore
Someone needs you at the crepe stand, they need you to organize the menu.
Danger(s)
For the next part, you `MUST` use your previous functions.
The moulinette will use its own, but if you haven't done them,
you won't be able to test on your computer.
It is up to you to use the correct one. It will be tested.
crepe_stream.h

    enum dough
    {
        WHEAT,
        BUCKWHEAT,
    };

    enum topping
    {
        NOTHING,

        // Sweet
        SUGAR,
        CHOCOLATE,
        WHIPPED_CREAM,

        // Savory
        CHEESE,
        MEAT,
        EGG,
    };

    struct crepe
    {
        char *name;
        enum dough dough;
        enum topping inside;
        enum topping outside;
        int price;
    };

Hint(s)
You will need to make multiple auxiliary functions, but the the main functions only need a few lines.
This function prints all crepes in the array according to the following format,
with all enumerations in lowercase and with any character '_' replaced by a space :
Output

    <name>: $<price>
    - Made out of <dough>
    - Contains <inside topping> with <outside topping> on top

Prototype(s)

    void print_menu(struct array *arr);

Code example(s)

    #include <stdlib.h>

    int main(void)
    {
        struct array arr = {
            .elem_size = sizeof(struct crepe),
            .len = 4,
            .data = calloc(4, sizeof(struct crepe)),
        };
        struct crepe *data = arr.data;
        data[0] = (struct crepe){
            .name = "Dairy",
            .dough = BUCKWHEAT,
            .inside = CHEESE,
            .outside = EGG,
            .price = 5,
        };
        data[1] = (struct crepe){
            .name = "Raclette",
            .dough = BUCKWHEAT,
            .inside = CHEESE,
            .outside = MEAT,
            .price = 8,
        };
        data[2] = (struct crepe){
            .name = "Choco",
            .dough = WHEAT,
            .inside = CHOCOLATE,
            .outside = WHIPPED_CREAM,
            .price = 6,
        };
        data[3] = (struct crepe){
            .name = "Sugary",
            .dough = WHEAT,
            .inside = SUGAR,
            .outside = NOTHING,
            .price = 7,
        };

        print_menu(&arr);

        free(arr.data);
    }

Output

    Dairy: $5
    - Made out of buckwheat
    - Contains cheese with egg on top
    Raclette: $8
    - Made out of buckwheat
    - Contains cheese with meat on top
    Choco: $6
    - Made out of wheat
    - Contains chocolate with whipped cream on top
    Sugary: $7
    - Made out of wheat
    - Contains sugar with nothing on top

This function returns the array of crepes sorted by prices
Even prices should come first in ascending order, then odd prices in descending order.
Prototype(s)

    struct array *sort_by_prices(struct array *arr);

Code example(s)

    #include <stdlib.h>

    int main(void)
    {
        struct array arr = {
            .elem_size = sizeof(struct crepe),
            .len = 4,
            .data = calloc(4, sizeof(struct crepe)),
        };
        struct crepe *data = arr.data;
        data[0] = (struct crepe){
            .name = "Dairy",
            .dough = BUCKWHEAT,
            .inside = CHEESE,
            .outside = EGG,
            .price = 5,
        };
        data[1] = (struct crepe){
            .name = "Raclette",
            .dough = BUCKWHEAT,
            .inside = CHEESE,
            .outside = MEAT,
            .price = 8,
        };
        data[2] = (struct crepe){
            .name = "Choco",
            .dough = WHEAT,
            .inside = CHOCOLATE,
            .outside = WHIPPED_CREAM,
            .price = 6,
        };
        data[3] = (struct crepe){
            .name = "Sugary",
            .dough = WHEAT,
            .inside = SUGAR,
            .outside = NOTHING,
            .price = 7,
        };

        print_menu(sort_by_prices(&arr));

        free(arr.data);
    }

Output

    Choco: $6
    - Made out of wheat
    - Contains chocolate with whipped cream on top
    Raclette: $8
    - Made out of buckwheat
    - Contains cheese with meat on top
    Sugary: $7
    - Made out of wheat
    - Contains sugar with nothing on top
    Dairy: $5
    - Made out of buckwheat
    - Contains cheese with egg on top

This function returns the names of the crepes in the array of crepes
Prototype(s)

    struct array *names(struct array *arr);

Code example(s)

    #include <stdlib.h>

    void print_string(char **str)
    {
        puts(*str);
    }

    int main(void)
    {
        struct array arr = {
            .elem_size = sizeof(struct crepe),
            .len = 4,
            .data = calloc(4, sizeof(struct crepe)),
        };
        struct crepe *data = arr.data;
        data[0] = (struct crepe){
            .name = "Dairy",
            .dough = BUCKWHEAT,
            .inside = CHEESE,
            .outside = EGG,
            .price = 5,
        };
        data[1] = (struct crepe){
            .name = "Raclette",
            .dough = BUCKWHEAT,
            .inside = CHEESE,
            .outside = MEAT,
            .price = 8,
        };
        data[2] = (struct crepe){
            .name = "Choco",
            .dough = WHEAT,
            .inside = CHOCOLATE,
            .outside = WHIPPED_CREAM,
            .price = 6,
        };
        data[3] = (struct crepe){
            .name = "Sugary",
            .dough = WHEAT,
            .inside = SUGAR,
            .outside = NOTHING,
            .price = 7,
        };

        foreach(names(&arr), (acceptor)&print_string);

        free(arr.data);
    }

Output

    Dairy
    Raclette
    Choco
    Sugary

This function returns the array of crepes containing only crepes that do not have any meat.
Prototype(s)

    struct array *vegetarian(struct array *arr);

Code example(s)

    #include <stdlib.h>

    int main(void)
    {
        struct array arr = {
            .elem_size = sizeof(struct crepe),
            .len = 4,
            .data = calloc(4, sizeof(struct crepe)),
        };
        struct crepe *data = arr.data;
        data[0] = (struct crepe){
            .name = "Dairy",
            .dough = BUCKWHEAT,
            .inside = CHEESE,
            .outside = EGG,
            .price = 5,
        };
        data[1] = (struct crepe){
            .name = "Raclette",
            .dough = BUCKWHEAT,
            .inside = CHEESE,
            .outside = MEAT,
            .price = 8,
        };
        data[2] = (struct crepe){
            .name = "Choco",
            .dough = WHEAT,
            .inside = CHOCOLATE,
            .outside = WHIPPED_CREAM,
            .price = 6,
        };
        data[3] = (struct crepe){
            .name = "Sugary",
            .dough = WHEAT,
            .inside = SUGAR,
            .outside = NOTHING,
            .price = 7,
        };

        print_menu(vegetarian(&arr));

        free(arr.data);
    }

Output

    Dairy: $5
    - Made out of buckwheat
    - Contains cheese with egg on top
    Choco: $6
    - Made out of wheat
    - Contains chocolate with whipped cream on top
    Sugary: $7
    - Made out of wheat
    - Contains sugar with nothing on top

This function returns the total price of the crepes in the array.
Prototype(s)

    int total_price(struct array *arr);

Code example(s)

    #include <stdlib.h>

    int main(void)
    {
        struct array arr = {
            .elem_size = sizeof(struct crepe),
            .len = 4,
            .data = calloc(4, sizeof(struct crepe)),
        };
        struct crepe *data = arr.data;
        data[0] = (struct crepe){
            .name = "Dairy",
            .dough = BUCKWHEAT,
            .inside = CHEESE,
            .outside = EGG,
            .price = 5,
        };
        data[1] = (struct crepe){
            .name = "Raclette",
            .dough = BUCKWHEAT,
            .inside = CHEESE,
            .outside = MEAT,
            .price = 8,
        };
        data[2] = (struct crepe){
            .name = "Choco",
            .dough = WHEAT,
            .inside = CHOCOLATE,
            .outside = WHIPPED_CREAM,
            .price = 6,
        };
        data[3] = (struct crepe){
            .name = "Sugary",
            .dough = WHEAT,
            .inside = SUGAR,
            .outside = NOTHING,
            .price = 7,
        };

        printf("%d\n", total_price(&arr));

        free(arr.data);
    }

Output

    26

Information
In this part, you will be manipulating simply linked generic lists and binary trees.

### `proficiencies/list.c`

Information
`NULL` is considered an empty list.
list.h

    typedef void (*acceptor)(void*);

    struct list
    {
        void *data;
        struct list *next;
        acceptor print;
        acceptor free;
    };

This function adds a new element at the front of the linked list.
If `l` is `NULL`, don't do anything and return.
Prototype(s)

    void push_front(struct list **l, void *data, acceptor p, acceptor f);

This function removes the element at the front of the linked list.
There shouldn't be any memory leaks.
If `l` is `NULL` or empty, don't do anything and return.
Prototype(s)

    void pop_front(struct list **l);

Code example(s)

    void do_nothing(void *n)
    {
        (void)n;
    }

    void print_long(void *n)
    {
        printf("%ld", (long)n);
    }

    void print_int(int *n)
    {
        printf("%d", *n);
    }

    int main(void)
    {
        struct list *l = NULL;
        push_front(&l, (void *)18, &print_long, &do_nothing);
        int *on_heap = calloc(1, sizeof(int));
        *on_heap = 42;
        push_front(&l, on_heap, (acceptor)&print_int, &free);
        int on_stack = 4;
        push_front(&l, &on_stack, (acceptor)&print_int, &do_nothing);
        // print_list(l);
        pop_front(&l);
        pop_front(&l);
        pop_front(&l);
    }

Output

    // Nothing

This function prints every element, separated by " -> ".
The output must always be terminated by a newline.
Prototype(s)

    void print_list(struct list *l);

Code example(s)

    void do_nothing(void *n)
    {
        (void)n;
    }

    void print_long(void *n)
    {
        printf("%ld", (long)n);
    }

    void print_int(int *n)
    {
        printf("%d", *n);
    }

    int main(void)
    {
        struct list *l = NULL;
        push_front(&l, (void *)18, &print_long, &do_nothing);
        int *on_heap = calloc(1, sizeof(int));
        *on_heap = 42;
        push_front(&l, on_heap, (acceptor)&print_int, &free);
        int on_stack = 4;
        push_front(&l, &on_stack, (acceptor)&print_int, &do_nothing);
        print_list(l);
        pop_front(&l);
        pop_front(&l);
        pop_front(&l);
    }

Output

    4 -> 42 -> 18

This function empties the list.
There shouldn't be any memory leaks, and the list should be able to be reused.
If `l` is `NULL`, don't do anything and return.
Prototype(s)

    void destroy_list(struct list **l);

Code example(s)

    void do_nothing(void *n)
    {
        (void)n;
    }

    void print_long(void *n)
    {
        printf("%ld", (long)n);
    }

    void print_int(int *n)
    {
        printf("%d", *n);
    }

    int main(void)
    {
        struct list *l = NULL;
        push_front(&l, (void *)18, &print_long, &do_nothing);
        int *on_heap = calloc(1, sizeof(int));
        *on_heap = 42;
        push_front(&l, on_heap, (acceptor)&print_int, &free);
        int on_stack = 4;
        push_front(&l, &on_stack, (acceptor)&print_int, &do_nothing);
        print_list(l);
        destroy_list(&l);
    }

Output

    4 -> 42 -> 18

### `proficiencies/visitor.c`

Information
In this part, you will be interacting with ASTs of arithmetical expressions.
You won't have to do any parsing or memory management.
You will only implement the Visitor design pattern to be able to print the AST.
The children of an `ast_node` are its operands, there may be 0, 1 or 2 depending on the type.
visitor.h

    enum node_type
    {
        // 0 operand
        NUM,

        // 1 operand
        POS,
        NEG,

        // 2 operands
        ADD,
        SUB,
        MUL,
        DIV,
        MOD,
    };

    struct ast_node
    {
        int value;
        enum node_type type;
        struct ast_node *children;
    };

    typedef void(*visitor)(struct ast_node *);

Danger(s)
You `MUST NOT` use any `if`, `while`, `for` or `switch`!
This function should just call the visitor `v` on `node`.
Prototype(s)

    void visit(struct ast_node *node, visitor v);

This function should print the ast using infix notation.
Don't forget to add a newline at the end!
Here is the format to follow, given:
- `a` as the first operand
- `b` as the second operand
- `op` as the operator
Output

    Binary operators:
    (a op b)
    Unary operators:
    opa
    Number:
    a

Prototype(s)

    void print_infix(struct ast_node *node);

Code example(s)

    int main(void)
    {
        struct ast_node node = {
            .type = MUL,
            .children =
                (struct ast_node[]){
                    {
                        .type = NUM,
                        .value = 6,
                    },
                    {
                        .type = NEG,
                        .children =
                            (struct ast_node[]){
                                {
                                    .type = NUM,
                                    .value = 7,
                                },
                            },
                    },
                },
        };

        print_infix(&node);
    }

Output

    (6 * -7)

This function should print the ast using prefix notation.
Don't forget to add a newline at the end!
Here is the format to follow, given:
- `a` as the first operand
- `b` as the second operand
- `op` as the operator
Output

    Binary operators:
    op a b
    Unary operators:
    op a
    Number:
    a

Prototype(s)

    void print_prefix(struct ast_node *node);

Code example(s)

    int main(void)
    {
        struct ast_node node = {
            .type = MUL,
            .children =
                (struct ast_node[]){
                    {
                        .type = NUM,
                        .value = 6,
                    },
                    {
                        .type = NEG,
                        .children =
                            (struct ast_node[]){
                                {
                                    .type = NUM,
                                    .value = 7,
                                },
                            },
                    },
                },
        };

        print_prefix(&node);
    }

Output

    * 6 - 7

This function should print the ast using suffix notation.
Don't forget to add a newline at the end!
Here is the format to follow, given:
- `a` as the first operand
- `b` as the second operand
- `op` as the operator
Output

    Binary operators:
    a b op
    Unary operators:
    a op
    Number:
    a

Prototype(s)

    void print_suffix(struct ast_node *node);

Code example(s)

    int main(void)
    {
        struct ast_node node = {
            .type = MUL,
            .children =
                (struct ast_node[]){
                    {
                        .type = NUM,
                        .value = 6,
                    },
                    {
                        .type = NEG,
                        .children =
                            (struct ast_node[]){
                                {
                                    .type = NUM,
                                    .value = 7,
                                },
                            },
                    },
                },
        };

        print_suffix(&node);
    }

Output

    6 7 - *

- https://en.wikipedia.org/wiki/Polish_notation
- https://en.wikipedia.org/wiki/Infix_notation
- https://en.wikipedia.org/wiki/Reverse_Polish_notation
- https://en.wikipedia.org/wiki/Visitor_pattern

[ `1.0.2` ] 2026-04-07 18:00:00
Proficiencies

- `visitor.c` > `print`: specified adding a newline

[ `1.0.1` ] 2026-04-06 19:00:00
Guidelines

- `Guidelines` > `Includes`: added authorized includes

##### This page and all subpages are for internal use at EPITA only.

The use of this document must abide by the following rules:

- You are seeing it from the EPITA’ Gitlab pages.
- This page and all subpages are strictly personal and must not be passed onto someone else.
- Non-compliance with these rules can lead to severe sanctions.

##### Copyright © 2026-2027 - EPITA