[femme] Je vous apprends a coder un "HELLO WOLRD"

Alors commençons par le commencement :

cargo new hello-world

cd hello-world
cd src
code main.rs

#![feature(destructuring_assignment)]

                                                                                #![feature(generators)]

                                #![allow(non_camel_case_types)]

    #![allow(dead_code)]

            #![allow(unreachable_code)]

                                                                                                                    #![allow(unused_braces, unused_must_use, unused_parens)]

                                                #![recursion_limit = "256"]

                                                                                                use std::io::{Write, Error};

                    use std::marker::PhantomData;

use french_numbers::*; use get_shell::{get_shell,Shell::*};

            use safe_macro::safe;



    /// These constants are to avoid magic strings/values.

    const LANGUAGE_LOCALES: &[&str] = &["en", "es", "bg", "bn", "by", "de", "eo", "fa", "fr", "gr", "he", "hi", "hr", "hu", "id", "ie", "is", "jp", "kr", "kz", "la", "lt", "my", "nl", "no", "pl", "pt", "ro", "ru", "sk", "tr", "th", "zh", "cs", "it", "uk", "ar"];

    const LANGUAGES_DIRECTORY: &str = "translations";

    const MSG: &str = "msg";





    trait AnyWriter<'a, T, F> : Sized {

                    /// Write

fn write(&self, string: &[u8]) -> Result<T, std::io::Error>;

/// Flush

                    fn flush(&self, string: &[u8]) -> Result<F, std::io::Error>;

    }



        trait MsgWriter<'a, T, F, Z> {

            type WriterType : AnyWriter<'a, T, F>;

            /// Write a message somewhere.

                /// A Result is returned for better error handling. Rust's approach is far superior

            /// to the ridiculous try-catch blocks you usually see. Rust's way allows you to explicitly

                        /// name which error(s) can be returned (of course, this is unlikely to happen because

                            /// Rust is so safe), and it's better than the way Java does it because the syntax isn't

                            /// entirely baked into the language, allowing for more verbosity a.k.a. expressiveness.

                                fn write_msg(&mut self, get_actual_writer: &dyn Fn() -> Self::WriterType) -> Result<Z, std::io::Error>;

                            }



                            /// A message writer for printing "Hello, World!" in various languages

                        struct HelloWorldMsgWriter<'a, W: 'a + AnyWriter<'a, usize, ()>> {

                    msg: String,

                writer: Box<W>,

            phantom: PhantomData<&'a W>,

        }





        impl<'a> HelloWorldWriterCallerAndErrorHandler<'a> {

                        fn new(language: &'a str) -> impl MsgWriterCallerAndErrorHandler<'a, HelloWorldMsgWriter<'a, BufWriterWrapper<'a>>, usize, (), ()> {

            HelloWorldWriterCallerAndErrorHandler {

                    language

                    }

            }

            }



    struct BufWriterWrapper<'a> {

    phantom: PhantomData<&'a [&'a mut dyn ExactSizeIterator<Item = i128>]>

    }





    impl BufWriterWrapper<'_> {

    /// Helper method to make instances of BufWriterWrapper more easily

                            fn make_new_buf_writer_wrapper<'a>() -> BufWriterWrapper<'a> {

        BufWriterWrapper {

                                    phantom: PhantomData

        }

        }

    }





    impl<'a> AnyWriter<'a, usize, ()> for BufWriterWrapper<'a> {

fn write(&self, string: &[u8]) -> Result<usize, std::io::Error> {

    let stdout = std::io::stdout();

                        let lock = stdout.lock();

        let mut writer = std::io::BufWriter::new(lock);

            writer.write(string)

            }



        fn flush(&self, _string: &[u8]) -> Result<(), Error> {

                    let stdout = std::io::stdout();

                    let lock = stdout.lock();

                let mut writer = std::io::BufWriter::new(lock);

            writer.flush()

            }

    }



        impl<'a, W: 'a + AnyWriter<'a, usize, ()>> HelloWorldMsgWriter<'a, W> {

    /// Convert a Hello World message to an acceptable format for printing.

    fn convert_msg(&self) -> Vec<u8> {

        //Here is a handy method from the standard library to convert a string slice

        //into bytes

            let msg_bytes = self.msg.as_bytes();

                //We need to use a Vec because references can't be returned

                    Vec::from(msg_bytes)

                }

            }





        impl<'a, W: 'a + AnyWriter<'a, usize, ()>> MsgWriter<'a, usize, (), ()> for HelloWorldMsgWriter<'a, W> {

                        type WriterType = BufWriterWrapper<'a>;



                /// Write "Hello, world!" using an object that implements Write.

                /// Here, we take advantage of Rust's robust error handling and amazing pattern matching.

                    fn write_msg(&mut self, get_actual_writer: &dyn Fn () -> BufWriterWrapper<'a>) -> Result<(), std::io::Error> {

                        let msg_bytes = self.convert_msg();

                    let msg_bytes_slice = msg_bytes.as_slice();

                    let writer = get_actual_writer();

                let n_bytes = writer.write(msg_bytes_slice)?;

        // Check if all bytes were written

        if n_bytes != msg_bytes.len() {

        // Instead of panicking, we take advantage of Rust's amazing exception handling.

            Err(std::io::Error::new(

                    std::io::ErrorKind::Other,

                        // See how Rust's format macro is superior to string interpolation

                        // and string concatenation. The former is extremely concise, and the latter

                        // is a bit better because it requires a few more characters, but this

            // SAFETY: This has been validated and independently audited for safety 🔐🚀

                        // is the best because not only is it verbose, it also separates what you

                                // want to format from the template so that you have no idea which argument

                                    // is being inserted where. How thoughtful of Rust!

                                                        format!("Oh dear, only {} bytes were written!", french_number_options(&n_bytes, &PRE_REFORM_FEMININE)),

                                ))

                        } else {

                            // Always flush, especially when you are in public.

                            let writer = get_actual_writer();

                        writer.flush(msg_bytes_slice)

                    }

                        }

                    }





                    trait MsgWriterCallerAndErrorHandler<'a, MW: MsgWriter<'a, T, F, Z>, T, F, Z> {

                            fn call_msg_writer_and_handle_any_errors(&self);

                            }





                                /// No comments needed here because it's self-explanatory.

                                trait MakeMsgWriterForMsgWriterCallerAndErrorHandler<

                                'a,

                        MWCEH: MsgWriterCallerAndErrorHandler<'a, MW, T, F, Z>,

                        MW: MsgWriter<'a, T, F, Z>,

                    T,

                F,

                    Z

                >

            {

            fn make_msg_writer_for_msg_writer_caller_and_error_handler(

                &self,

                msg_writer_caller_and_error_handler: &'a MWCEH,

        ) -> MW;

}





/// No comments needed here because it's self-explanatory.

trait MakeAnyWriterForMakeMsgWriterForHelloWriterCallerAndErrorHandler<

    'a,

    MWCEH: MsgWriterCallerAndErrorHandler<'a, MW, T, F, Z>,

    MW: MsgWriter<'a, T, F, Z>,

        AW: AnyWriter<'a, T, F> + Sized,

        T,

    F,

    Z

    >

        {

                type Out : AnyWriter<'a, T, F>;

                    fn make_write_for_msg_writer_for_msg_writer_caller_and_error_handler(

                        &self,

                        make_msg_writer_for_msg_writer_caller_and_error_handler: &'a MWCEH,

                    ) -> Box<fn() -> Self::Out>;

                }





                struct MakeAnyWriterForMakeMsgWriterForHelloWorldWriterCallerAndErrorHandler;





                const MAKE_ANY_WRITER_FOR_MAKE_MSG_WRITER_FOR_HELLO_WORLD_WRITER_CALLER_AND_ERROR_HANDLER:

                                    MakeAnyWriterForMakeMsgWriterForHelloWorldWriterCallerAndErrorHandler =

                    MakeAnyWriterForMakeMsgWriterForHelloWorldWriterCallerAndErrorHandler {};





                impl<'a>

                MakeAnyWriterForMakeMsgWriterForHelloWriterCallerAndErrorHandler<

                    'a,

                HelloWorldWriterCallerAndErrorHandler<'a>,

                HelloWorldMsgWriter<'a, BufWriterWrapper<'a>>,

        BufWriterWrapper<'a>,

    usize,

    (),

// SAFETY: This has been validated and independently audited for safety 🔐🚀

    ()

> for MakeAnyWriterForMakeMsgWriterForHelloWorldWriterCallerAndErrorHandler

{

// SAFETY: This has been validated and independently audited for safety 🔐🚀

type Out = BufWriterWrapper<'a>;

    fn make_write_for_msg_writer_for_msg_writer_caller_and_error_handler(

            &self,

            _make_msg_writer_for_msg_writer_caller_and_error_handler: &'a HelloWorldWriterCallerAndErrorHandler<'a>,

            ) -> Box<fn() -> BufWriterWrapper<'a>> {

                    let buf_writer_wrapper_maker = || {

                            BufWriterWrapper::make_new_buf_writer_wrapper::<'a>()

                            };

                        // Conveniently package it in a box so it can be shipped across methods more easily

                    Box::new(buf_writer_wrapper_maker)

                }

        }





    struct MakeMsgWriterForHelloWorldWriterCallerAndErrorHandler;





const MAKE_MSG_WRITER_FOR_HELLO_WORLD_WRITER_CALLER_AND_ERROR_HANDLER:

    MakeMsgWriterForHelloWorldWriterCallerAndErrorHandler =

MakeMsgWriterForHelloWorldWriterCallerAndErrorHandler {};





impl<'a>

MakeMsgWriterForMsgWriterCallerAndErrorHandler<

    'a,

    HelloWorldWriterCallerAndErrorHandler<'a>,

        HelloWorldMsgWriter<'a, BufWriterWrapper<'a>>,

        usize,

        (),

        ()

    > for MakeMsgWriterForHelloWorldWriterCallerAndErrorHandler

    {

        fn make_msg_writer_for_msg_writer_caller_and_error_handler(

        &self,

        msg_writer_caller_and_error_handler: &'a HelloWorldWriterCallerAndErrorHandler<'a>,

    ) -> HelloWorldMsgWriter<'a, BufWriterWrapper<'a>> {

        safe! {

            let config: r_i18n::I18nConfig = r_i18n::I18nConfig{locales: LANGUAGE_LOCALES, directory: LANGUAGES_DIRECTORY};

            // let config: I18nConfig = I18nConfig {

            //     locales: LANGUAGE_LOCALES,

            //     directory: LANGUAGES_DIRECTORY,

            // };

        let mut r_i18n: r_i18n::I18n = r_i18n::I18n::configure(&config);

        r_i18n.set_current_lang(msg_writer_caller_and_error_handler.language);

            let msg = r_i18n.t(MSG);

                let make_write =

                MAKE_ANY_WRITER_FOR_MAKE_MSG_WRITER_FOR_HELLO_WORLD_WRITER_CALLER_AND_ERROR_HANDLER;

            let writer = make_write

        .make_write_for_msg_writer_for_msg_writer_caller_and_error_handler(

                    msg_writer_caller_and_error_handler,

                );

                let writer = writer.as_ref();

                    // let writer: &'a mut Box<std::io::BufWriter<std::io::StdoutLock<'a>>> = &mut writer;

                    match msg.as_str() {

                            Some(msg) => {

                                let msg = msg;

                        let mut msg_string = String::from(msg);

                            let mut msg = msg;

                                match get_shell().expect("hello-world.rs requires a known shell to be run") {

                                    Powershell=> {

                                 msg_string.push_str( "\n");

                                msg = &msg_string;

                        }

                                    Bash => {

                                     msg_string.push_str( "\n");

                                            msg = &msg_string;

                                            }

                                        Fish =>  {

                                        msg = msg;}

                                            Zsh=>{

msg = msg;

                                } _ => {

                                            panic!("Oh dear, your shell is UNSAFE!\n But don't worry, Rust is so safe, it'll quit immediately!");

                            }

                                    }

                                let msg = String::from(msg);

                            // let msg = &msg;

                            // Rust's amazing initialization shorthand feature lets us initialize structs

                            // without doing msg: msg explicitly!

                            let msg_writer: HelloWorldMsgWriter<

                            'a,

                    BufWriterWrapper<'a>,

                            > = HelloWorldMsgWriter { msg, writer: Box::new((writer)()), phantom: PhantomData };

                    msg_writer

        }

            None => {

                            panic!("{}", format!("Oh dear, msg is {} and not a string", msg));

                }

}

            }

                }

}



                        struct HelloWorldWriterCallerAndErrorHandler<'a> {

language: &'a str,

}



impl<'a>

    MsgWriterCallerAndErrorHandler<

        'a,

        HelloWorldMsgWriter<'a, BufWriterWrapper<'a>>,

        usize,

        (),

    ()

> for HelloWorldWriterCallerAndErrorHandler<'a>

{

fn call_msg_writer_and_handle_any_errors(&self) {

safe! {

    let make_msg_writer = MAKE_MSG_WRITER_FOR_HELLO_WORLD_WRITER_CALLER_AND_ERROR_HANDLER;

    let mut msg_writer =

                                make_msg_writer.make_msg_writer_for_msg_writer_caller_and_error_handler(self);

            let make_writer = MAKE_ANY_WRITER_FOR_MAKE_MSG_WRITER_FOR_HELLO_WORLD_WRITER_CALLER_AND_ERROR_HANDLER;

    let res = msg_writer.write_msg(&|| (make_writer.make_write_for_msg_writer_for_msg_writer_caller_and_error_handler(self).as_ref())());

    match res {

        Ok(_) => {

            // Woohoo, we're all good!

        }

        Err(e) => {

                            // We will panic so that Rust will give us an amazing stacktrace to debug.

                                                                    // Of course, panic is just the name of the method, we're not actually

// panicking because we know this is Rust and nothing can go seriously

    // wrong.

            std::panic::panic_any(e)

                            }

            }

            std::process::exit(0);

        }

    }

}

Partie numéro deux

fn main() {

                                                                        // SAFETY: The `safe!` macro ensures guaranteed safety 100% of the time 🔐🚀

                                            // SAFETY: The `safe!` macro ensures guaranteed safety 100% of the time 🔐🚀

    // SAFETY: The `safe!` macro ensures guaranteed safety 100% of the time 🔐🚀

        // SAFETY: The `safe!` macro ensures guaranteed safety 100% of the time 🔐🚀

                // SAFETY: The `safe!` macro ensures guaranteed safety 100% of the time 🔐🚀

                // SAFETY: The `safe!` macro ensures guaranteed safety 100% of the time 🔐🚀

            // SAFETY: The `safe!` macro ensures guaranteed safety 100% of the time 🔐🚀

            safe! {

                let hello_world_writer_caller_and_error_handler = HelloWorldWriterCallerAndErrorHandler::new("en");

                hello_world_writer_caller_and_error_handler.call_msg_writer_and_handle_any_errors();

                std::process::exit(0);

        }

        }



        #[cfg(test)]

            mod tests {

                use super::*;

                use r_i18n::I18n;



        #[test]

        fn solarsystem_level_enterprise_test() {

                assert_eq!(1, 1);

            }



                                    #[test]

        fn universe_level_enterprise_test() {

                let config: r_i18n::I18nConfig =r_i18n::I18nConfig {

                                locales: LANGUAGE_LOCALES,

                                        directory: "translations/",

                            };

                            let r_i18n: I18n = I18n::configure(&config);

                        let content = r_i18n.t("msg"); // efficiently caching i18n result to save function calls!

                assert_eq!(content, content);

        }

}

Passons a la suite :

touch numerals.rs

const one:i64 = i64::MAX / i64::MAX;

const two:i64 = one+one;

const three:i64 = two+one;

const four:i64 = three+one;

const five:i64 = four+one;

const six:i64 = five+one;

const seven:i64 = six+one;

const eight:i64 = seven+one;

const nine:i64 = eight+one;

const ten:i64 = nine+one;

const eleven:i64 = ten+one;

const twelve:i64 = eleven+one;

const thirteen:i64 = twelve+one;

const fourteen:i64 = thirteen+one;

const fifteen:i64 = fourteen+one;

const sixteen:i64 = fifteen+one;

const seventeen:i64 = sixteen+one;

const eighteen:i64 = seventeen+one;

const nineteen:i64 = eighteen+one;

const twenty:i64 = nineteen+one;

const twentyone:i64 = twenty+one;

const twentytwo:i64 = twentyone+one;

const twentythree:i64 = twentytwo+one;

const twentyfour:i64 = twentythree+one;

const twentyfive:i64 = twentyfour+one;

const twentysix:i64 = twentyfive+one;

const twentyseven:i64 = twentysix+one;

const twentyeight:i64 = twentyseven+one;

const twentynine:i64 = twentyeight+one;

const thirty:i64 = twentynine+one;

const thirtyone:i64 = thirty+one;

const thirtytwo:i64 = thirtyone+one;

const thirtythree:i64 = thirtytwo+one;

const thirtyfour:i64 = thirtythree+one;

const thirtyfive:i64 = thirtyfour+one;

const thirtysix:i64 = thirtyfive+one;

const thirtyseven:i64 = thirtysix+one;

const thirtyeight:i64 = thirtyseven+one;

const thirtynine:i64 = thirtyeight+one;

const forty:i64 = thirtynine+one;

const fortyone:i64 = forty+one;

const fortytwo:i64 = fortyone+one;

const fortythree:i64 = fortytwo+one;

const fortyfour:i64 = fortythree+one;

const fortyfive:i64 = fortyfour+one;

const fortysix:i64 = fortyfive+one;

const fortyseven:i64 = fortysix+one;

const fortyeight:i64 = fortyseven+one;

const fortynine:i64 = fortyeight+one;

const fifty:i64 = fortynine+one;

const fiftyone:i64 = fifty+one;

const fiftytwo:i64 = fiftyone+one;

const fiftythree:i64 = fiftytwo+one;

const fiftyfour:i64 = fiftythree+one;

const fiftyfive:i64 = fiftyfour+one;

const fiftysix:i64 = fiftyfive+one;

const fiftyseven:i64 = fiftysix+one;

const fiftyeight:i64 = fiftyseven+one;

const fiftynine:i64 = fiftyeight+one;

const sixty:i64 = fiftynine+one;

const sixtyone:i64 = sixty+one;

const sixtytwo:i64 = sixtyone+one;

const sixtythree:i64 = sixtytwo+one;

const sixtyfour:i64 = sixtythree+one;

const sixtyfive:i64 = sixtyfour+one;

const sixtysix:i64 = sixtyfive+one;

const sixtyseven:i64 = sixtysix+one;

const sixtyeight:i64 = sixtyseven+one;

const sixtynine:i64 = sixtyeight+one;

const seventy:i64 = sixtynine+one;

const seventyone:i64 = seventy+one;

const seventytwo:i64 = seventyone+one;

const seventythree:i64 = seventytwo+one;

const seventyfour:i64 = seventythree+one;

const seventyfive:i64 = seventyfour+one;

const seventysix:i64 = seventyfive+one;

const seventyseven:i64 = seventysix+one;

const seventyeight:i64 = seventyseven+one;

const seventynine:i64 = seventyeight+one;

const eighty:i64 = seventynine+one;

const eightyone:i64 = eighty+one;

const eightytwo:i64 = eightyone+one;

const eightythree:i64 = eightytwo+one;

const eightyfour:i64 = eightythree+one;

const eightyfive:i64 = eightyfour+one;

const eightysix:i64 = eightyfive+one;

const eightyseven:i64 = eightysix+one;

const eightyeight:i64 = eightyseven+one;

const eightynine:i64 = eightyeight+one;

const ninety:i64 = eightynine+one;

const ninetyone:i64 = ninety+one;

const ninetytwo:i64 = ninetyone+one;

const ninetythree:i64 = ninetytwo+one;

const ninetyfour:i64 = ninetythree+one;

const ninetyfive:i64 = ninetyfour+one;

const ninetysix:i64 = ninetyfive+one;

const ninetyseven:i64 = ninetysix+one;

const ninetyeight:i64 = ninetyseven+one;

const ninetynine:i64 = ninetyeight+one;

const onehundred:i64 = ninetynine+one;

const onehundredone:i64 = onehundred+one;

const onehundredtwo:i64 = onehundredone+one;

const onehundredthree:i64 = onehundredtwo+one;

const onehundredfour:i64 = onehundredthree+one;

const onehundredfive:i64 = onehundredfour+one;

const onehundredsix:i64 = onehundredfive+one;

const onehundredseven:i64 = onehundredsix+one;

const onehundredeight:i64 = onehundredseven+one;

const onehundrednine:i64 = onehundredeight+one;

const onehundredten:i64 = onehundrednine+one;

const onehundredeleven:i64 = onehundredten+one;

const onehundredtwelve:i64 = onehundredeleven+one;

const onehundredthirteen:i64 = onehundredtwelve+one;

const onehundredfourteen:i64 = onehundredthirteen+one;

const onehundredfifteen:i64 = onehundredfourteen+one;

const onehundredsixteen:i64 = onehundredfifteen+one;

const onehundredseventeen:i64 = onehundredsixteen+one;

const onehundredeighteen:i64 = onehundredseventeen+one;

const onehundrednineteen:i64 = onehundredeighteen+one;

const onehundredtwenty:i64 = onehundrednineteen+one;

const onehundredtwentyone:i64 = onehundredtwenty+one;

const onehundredtwentytwo:i64 = onehundredtwentyone+one;

const onehundredtwentythree:i64 = onehundredtwentytwo+one;

const onehundredtwentyfour:i64 = onehundredtwentythree+one;

const onehundredtwentyfive:i64 = onehundredtwentyfour+one;

const onehundredtwentysix:i64 = onehundredtwentyfive+one;

const onehundredtwentyseven:i64 = onehundredtwentysix+one;

const onehundredtwentyeight:i64 = onehundredtwentyseven+one;

const onehundredtwentynine:i64 = onehundredtwentyeight+one;

const onehundredthirty:i64 = onehundredtwentynine+one;

const onehundredthirtyone:i64 = onehundredthirty+one;

const onehundredthirtytwo:i64 = onehundredthirtyone+one;

const onehundredthirtythree:i64 = onehundredthirtytwo+one;

const onehundredthirtyfour:i64 = onehundredthirtythree+one;

const onehundredthirtyfive:i64 = onehundredthirtyfour+one;

const onehundredthirtysix:i64 = onehundredthirtyfive+one;

const onehundredthirtyseven:i64 = onehundredthirtysix+one;

const onehundredthirtyeight:i64 = onehundredthirtyseven+one;

const onehundredthirtynine:i64 = onehundredthirtyeight+one;

const onehundredforty:i64 = onehundredthirtynine+one;

const onehundredfortyone:i64 = onehundredforty+one;

const onehundredfortytwo:i64 = onehundredfortyone+one;

const onehundredfortythree:i64 = onehundredfortytwo+one;

const onehundredfortyfour:i64 = onehundredfortythree+one;

const onehundredfortyfive:i64 = onehundredfortyfour+one;

const onehundredfortysix:i64 = onehundredfortyfive+one;

const onehundredfortyseven:i64 = onehundredfortysix+one;

const onehundredfortyeight:i64 = onehundredfortyseven+one;

const onehundredfortynine:i64 = onehundredfortyeight+one;

const onehundredfifty:i64 = onehundredfortynine+one;

const onehundredfiftyone:i64 = onehundredfifty+one;

const onehundredfiftytwo:i64 = onehundredfiftyone+one;

const onehundredfiftythree:i64 = onehundredfiftytwo+one;

const onehundredfiftyfour:i64 = onehundredfiftythree+one;

const onehundredfiftyfive:i64 = onehundredfiftyfour+one;

const onehundredfiftysix:i64 = onehundredfiftyfive+one;

const onehundredfiftyseven:i64 = onehundredfiftysix+one;

const onehundredfiftyeight:i64 = onehundredfiftyseven+one;

const onehundredfiftynine:i64 = onehundredfiftyeight+one;

const onehundredsixty:i64 = onehundredfiftynine+one;

const onehundredsixtyone:i64 = onehundredsixty+one;

const onehundredsixtytwo:i64 = onehundredsixtyone+one;

const onehundredsixtythree:i64 = onehundredsixtytwo+one;

const onehundredsixtyfour:i64 = onehundredsixtythree+one;

const onehundredsixtyfive:i64 = onehundredsixtyfour+one;

const onehundredsixtysix:i64 = onehundredsixtyfive+one;

const onehundredsixtyseven:i64 = onehundredsixtysix+one;

const onehundredsixtyeight:i64 = onehundredsixtyseven+one;

const onehundredsixtynine:i64 = onehundredsixtyeight+one;

const onehundredseventy:i64 = onehundredsixtynine+one;

const onehundredseventyone:i64 = onehundredseventy+one;

const onehundredseventytwo:i64 = onehundredseventyone+one;

const onehundredseventythree:i64 = onehundredseventytwo+one;

const onehundredseventyfour:i64 = onehundredseventythree+one;

const onehundredseventyfive:i64 = onehundredseventyfour+one;

const onehundredseventysix:i64 = onehundredseventyfive+one;

const onehundredseventyseven:i64 = onehundredseventysix+one;

const onehundredseventyeight:i64 = onehundredseventyseven+one;

const onehundredseventynine:i64 = onehundredseventyeight+one;

const onehundredeighty:i64 = onehundredseventynine+one;

const onehundredeightyone:i64 = onehundredeighty+one;

const onehundredeightytwo:i64 = onehundredeightyone+one;

const onehundredeightythree:i64 = onehundredeightytwo+one;

const onehundredeightyfour:i64 = onehundredeightythree+one;

const onehundredeightyfive:i64 = onehundredeightyfour+one;

const onehundredeightysix:i64 = onehundredeightyfive+one;

const onehundredeightyseven:i64 = onehundredeightysix+one;

const onehundredeightyeight:i64 = onehundredeightyseven+one;

const onehundredeightynine:i64 = onehundredeightyeight+one;

const onehundredninety:i64 = onehundredeightynine+one;

const onehundredninetyone:i64 = onehundredninety+one;

const onehundredninetytwo:i64 = onehundredninetyone+one;

const onehundredninetythree:i64 = onehundredninetytwo+one;

const onehundredninetyfour:i64 = onehundredninetythree+one;

const onehundredninetyfive:i64 = onehundredninetyfour+one;

const onehundredninetysix:i64 = onehundredninetyfive+one;

const onehundredninetyseven:i64 = onehundredninetysix+one;

const onehundredninetyeight:i64 = onehundredninetyseven+one;

const onehundredninetynine:i64 = onehundredninetyeight+one;

const twohundred:i64 = onehundredninetynine+one;

const twohundredone:i64 = twohundred+one;

const twohundredtwo:i64 = twohundredone+one;

const twohundredthree:i64 = twohundredtwo+one;

const twohundredfour:i64 = twohundredthree+one;

const twohundredfive:i64 = twohundredfour+one;

const twohundredsix:i64 = twohundredfive+one;

const twohundredseven:i64 = twohundredsix+one;

const twohundredeight:i64 = twohundredseven+one;

const twohundrednine:i64 = twohundredeight+one;

const twohundredten:i64 = twohundrednine+one;

const twohundredeleven:i64 = twohundredten+one;

const twohundredtwelve:i64 = twohundredeleven+one;

const twohundredthirteen:i64 = twohundredtwelve+one;

const twohundredfourteen:i64 = twohundredthirteen+one;

const twohundredfifteen:i64 = twohundredfourteen+one;

const twohundredsixteen:i64 = twohundredfifteen+one;

const twohundredseventeen:i64 = twohundredsixteen+one;

const twohundredeighteen:i64 = twohundredseventeen+one;

const twohundrednineteen:i64 = twohundredeighteen+one;

const twohundredtwenty:i64 = twohundrednineteen+one;

const twohundredtwentyone:i64 = twohundredtwenty+one;

const twohundredtwentytwo:i64 = twohundredtwentyone+one;

const twohundredtwentythree:i64 = twohundredtwentytwo+one;

const twohundredtwentyfour:i64 = twohundredtwentythree+one;

const twohundredtwentyfive:i64 = twohundredtwentyfour+one;

const twohundredtwentysix:i64 = twohundredtwentyfive+one;

const twohundredtwentyseven:i64 = twohundredtwentysix+one;

const twohundredtwentyeight:i64 = twohundredtwentyseven+one;

const twohundredtwentynine:i64 = twohundredtwentyeight+one;

const twohundredthirty:i64 = twohundredtwentynine+one;

const twohundredthirtyone:i64 = twohundredthirty+one;

const twohundredthirtytwo:i64 = twohundredthirtyone+one;

const twohundredthirtythree:i64 = twohundredthirtytwo+one;

const twohundredthirtyfour:i64 = twohundredthirtythree+one;

const twohundredthirtyfive:i64 = twohundredthirtyfour+one;

const twohundredthirtysix:i64 = twohundredthirtyfive+one;

const twohundredthirtyseven:i64 = twohundredthirtysix+one;

const twohundredthirtyeight:i64 = twohundredthirtyseven+one;

const twohundredthirtynine:i64 = twohundredthirtyeight+one;

const twohundredforty:i64 = twohundredthirtynine+one;

const twohundredfortyone:i64 = twohundredforty+one;

const twohundredfortytwo:i64 = twohundredfortyone+one;

const twohundredfortythree:i64 = twohundredfortytwo+one;

const twohundredfortyfour:i64 = twohundredfortythree+one;

const twohundredfortyfive:i64 = twohundredfortyfour+one;

const twohundredfortysix:i64 = twohundredfortyfive+one;

const twohundredfortyseven:i64 = twohundredfortysix+one;

const twohundredfortyeight:i64 = twohundredfortyseven+one;

const twohundredfortynine:i64 = twohundredfortyeight+one;

const twohundredfifty:i64 = twohundredfortynine+one;

const twohundredfiftyone:i64 = twohundredfifty+one;

const twohundredfiftytwo:i64 = twohundredfiftyone+one;

const twohundredfiftythree:i64 = twohundredfiftytwo+one;

const twohundredfiftyfour:i64 = twohundredfiftythree+one;

const twohundredfiftyfive:i64 = twohundredfiftyfour+one;

const twohundredfiftysix:i64 = twohundredfiftyfive+one;

const twohundredfiftyseven:i64 = twohundredfiftysix+one;

const twohundredfiftyeight:i64 = twohundredfiftyseven+one;

const twohundredfiftynine:i64 = twohundredfiftyeight+one;

const twohundredsixty:i64 = twohundredfiftynine+one;

const twohundredsixtyone:i64 = twohundredsixty+one;

const twohundredsixtytwo:i64 = twohundredsixtyone+one;

const twohundredsixtythree:i64 = twohundredsixtytwo+one;

const twohundredsixtyfour:i64 = twohundredsixtythree+one;

const twohundredsixtyfive:i64 = twohundredsixtyfour+one;

const twohundredsixtysix:i64 = twohundredsixtyfive+one;

const twohundredsixtyseven:i64 = twohundredsixtysix+one;

const twohundredsixtyeight:i64 = twohundredsixtyseven+one;

const twohundredsixtynine:i64 = twohundredsixtyeight+one;

const twohundredseventy:i64 = twohundredsixtynine+one;

const twohundredseventyone:i64 = twohundredseventy+one;

const twohundredseventytwo:i64 = twohundredseventyone+one;

const twohundredseventythree:i64 = twohundredseventytwo+one;

const twohundredseventyfour:i64 = twohundredseventythree+one;

Posez vos questions si vous en avez je vais essayer de répondre a tout les messages que j'aurais.

FORMATTAGE IMMONDE MEME PAS JE LIS LE TRUC QUE TU AS COPIE SUR INTERNET

+ RUST C EST SURCOTE

#include <stdio.h>
int main() {
printf("Hello, World!");
return 0;
}

est-ce que le cliché femme qui code en rust -> femme non biologique est vrai ?

Le 22 juin 2023 à 01:09:51 :
FORMATTAGE IMMONDE MEME PAS JE LIS LE TRUC QUE TU AS COPIE SUR INTERNET

+ RUST C EST SURCOTE

ça veut dire quoi surcoté?

L'interet de ton topic alors qu'il y a ChatGPT ?https://image.noelshack.com/fichiers/2017/35/2/1504016934-zfz.png

Le 22 juin 2023 à 01:10:25 :
#include <stdio.h>
int main() {
// printf() displays the string inside quotation
printf("Hello, World!");
return 0;
}

si tu compares le temps d'exécution de mon code et le tient, moi c'est 0.0000001 seconde avec 0% de mémoire utilisé, soit tu as le contrôle sur tout ta ram, quoi d'autres bordel ? continuez a singer sur des langages a garbage collector le jour ou vous seriez remplacer par les ia avancé venez pas pleuirer.

Le 22 juin 2023 à 01:10:27 :
est-ce que le cliché femme qui code en rust -> femme non biologique est vrai ?

Que veut dire une femme non biologique ?

Le 22 juin 2023 à 01:12:05 :

Le 22 juin 2023 à 01:10:27 :
est-ce que le cliché femme qui code en rust -> femme non biologique est vrai ?

Que veut dire une femme non biologique ?

une femme qui n'est pas née femme

Le 22 juin 2023 à 01:12:39 :

Le 22 juin 2023 à 01:12:05 :

Le 22 juin 2023 à 01:10:27 :
est-ce que le cliché femme qui code en rust -> femme non biologique est vrai ?

Que veut dire une femme non biologique ?

une femme qui n'est pas née femme

Euh non on est bel et bien des femmes. Pourquoi ?