fn has_abba(s: &str) -> bool {
    s.as_bytes()
        .array_windows()
        .any(|[a1, b1, b2, a2]| (a1 != b1) && (a1 == a2) && (b1 == b2))
}

# array of paths
include = [
    "frodo.toml",
    "samwise.toml",
]
 
# inline tables for more control
include = [
    { path = "required.toml" },
    { path = "optional.toml", optional = true },
]

serde = {
    version = "1.0",
    features = ["derive"],
}

asm!( // or global_asm! or naked_asm!
    "nop",
    #[cfg(target_feature = "sse2")]
    "nop",
    // ...
    #[cfg(target_feature = "sse2")]
    a = const 123, // only used on sse2
);

 
use core::convert::Infallible;
fn can_never_fail() -> Result<(), Infallible> {
    // ...
    Ok(())
}
 
fn main() {
    can_never_fail();
}

 
trait UsesAssocErrorType {
    type Error;
    fn method(&self) -> Result<(), Self::Error>;
}
 
struct CannotFail;
impl UsesAssocErrorType for CannotFail {
    type Error = core::convert::Infallible;
    fn method(&self) -> Result<(), Self::Error> {
        Ok(())
    }
}
 
struct CanFail;
impl UsesAssocErrorType for CanFail {
    type Error = std::io::Error;
    fn method(&self) -> Result<(), Self::Error> {
        Err(std::io::Error::other("something went wrong"))
    }
}
 
fn main() {
    CannotFail.method(); // No warning
    CanFail.method(); // Warning: unused `Result` that must be used
}

 
let connection = establish_connection();
let mut connection_handle = connection.unwrap();
let arc_connection = Arc::new(Mutex::new(&mut connection_handle));
 
let threadscope = thread::scope
(
	|thescope|
	{
		'connexion: loop
		{
			for stream in Listener.incoming()
			{
				match stream
				{
					Ok(saloperie) =>
						{
							let arc_stream = Arc::new(Mutex::new(saloperie));
							println!("[{:?}] Connection granted !!", Local::now());
							let rc = thescope.spawn(|| client_handler(arc_stream,&arc_connection));
							let value = rc.join().unwrap();
							if value.is_negative()
							{
								break 'connexion;
							}
						}
					Err(erreur) =>
						{
							eprintln!("Error: {}", erreur);
						}
				} // end match
				} // end for
			sleep(Duration::from_millis(80));
		} // end loop
	}
);

 
 
pub fn client_handler(arc_stream :Arc<Mutex<TcpStream>>, arc_connect :&Arc<Mutex<&mut PooledConn>> ) -> i32
{
  ...
  let res_connection = arc_connect.lock();
  ...
}

let result = player_fromDB.getIDbyName(&mut res_connection.unwrap(), onePlayer.getString());
if result > 0
{
  println!("[DB] {} found !!",onePlayer.getString());
  // In this case some computing must be done... later.
}
else
{
  println!("[DB] {} not found !!",onePlayer.getString());
 // In this case the player must be inserted to the DB... later.
}

if player_fromDB.getID() > 0
{
  // update
  player_fromDB.setScore(onePlayer.getScoreP(),onePlayer.getScoreO());
  GEN_updateDB(player_fromDB,&mut res_connection.unwrap());
}

// commun à Players et Matches
fn getColor(&self) -> u8;
fn getScoreP(&self) -> u128;
fn getScoreO(&self) -> u128;

/// commun à Players et Matches
fn getColor(&self) -> u8;
fn getScoreP(&self) -> u128;
fn getScoreO(&self) -> u128;

/// commun à Players et Matches
fn getColor(&self) -> u8;
/// commun à Players et Matches
fn getScoreP(&self) -> u128;
/// commun à Players et Matches
fn getScoreO(&self) -> u128;

fn f() -> *const u8 {
    let x = 0;
    &x
}

warning: a dangling pointer will be produced because the local variable `x` will be dropped
 --> src/lib.rs:3:5
  |
1 | fn f() -> *const u8 {
  |           --------- return type of the function is `*const u8`
2 |     let x = 0;
  |         - `x` is part the function and will be dropped at the end of the function
3 |     &x
  |     ^^
  |
  = note: pointers do not have a lifetime; after returning, the `u8` will be deallocated
    at the end of the function because nothing is referencing it as far as the type system is
    concerned
  = note: `#[warn(dangling_pointers_from_locals)]` on by default

commit 39c72e5edc1f05ae4c04929eda4e4d125f86c5ce
Author: Lee Holloway <q@t60.(none)>
Date:   Wed Jan 6 09:57:55 2010 -0800
 
    nginx-fl initial configuration

commit bedf6e7080391683e46ab698aacdfa9b3126a75f
Author: Dane Knecht
Date:   Thu Sep 19 19:31:15 2013 -0700
 
    remove PHP.

commit a72698fc7404a353a09a3b20ab92797ab4744ea8
Author: Maciej Lechowski
Date:   Wed Jul 10 15:19:28 2024 +0100
 
    Create fl2 project

Phase {
    name: phases::SERVE_ERROR_PAGE,
    request_types_enabled: PHASE_ENABLED_FOR_REQUEST_TYPE,
    inputs: vec![
        InputKind::IPInfo,
        InputKind::ModuleValue(
            MODULE_VALUE_CUSTOM_ERRORS_FETCH_WORKER_RESPONSE.as_str(),
        ),
        InputKind::ModuleValue(MODULE_VALUE_ORIGINAL_SERVE_RESPONSE.as_str()),
        InputKind::ModuleValue(MODULE_VALUE_RULESETS_CUSTOM_ERRORS_OUTPUT.as_str()),
        InputKind::ModuleValue(MODULE_VALUE_RULESETS_UPSTREAM_ERROR_DETAILS.as_str()),
        InputKind::RayId,
        InputKind::StatusCode,
        InputKind::Visitor,
    ],
    outputs: vec![OutputValue::ServeResponse],
    filters: vec![],
    func: phase_serve_error_page::callback,
}

pub(crate) fn callback(_services: &mut Services, input: &Input<'_>) -> Output {
    // Rulesets produced a response to serve - this can either come from a special
    // Cloudflare worker for serving custom errors, or be directly embedded in the rule.
    if let Some(rulesets_params) = input
        .get_module_value(MODULE_VALUE_RULESETS_CUSTOM_ERRORS_OUTPUT)
        .cloned()
    {
        // Select either the result from the special worker, or the parameters embedded
        // in the rule.
        let body = input
            .get_module_value(MODULE_VALUE_CUSTOM_ERRORS_FETCH_WORKER_RESPONSE)
            .and_then(|response| {
                handle_custom_errors_fetch_response("rulesets", response.to_owned())
            })
            .or(rulesets_params.body);
 
        // If we were able to load a body, serve it, otherwise let the next bit of logic
        // handle the response
        if let Some(body) = body {
            let final_body = replace_custom_error_tokens(input, &body);
 
            // Increment a metric recording number of custom error pages served
            custom_pages::pages_served("rulesets").inc();
 
            // Return a phase output with one final action, causing an HTTP response to be served.
            return Output::from(TerminalAction::ServeResponse(ResponseAction::OriginError {
                rulesets_params.status,
                source: "rulesets http_custom_errors",
                headers: rulesets_params.headers,
                body: Some(Bytes::from(final_body)),
            }));
        }
    }
}

[target.x86_64-unknown-linux-gnu]
rustflags = ["-Clinker-features=-lld"]

pub fn all_false<const LEN: usize>() -> [bool; LEN] {
  [false; _]
}

// This is not allowed
pub const fn all_false<const LEN: usize>() -> [bool; _] {
  [false; LEN]
}
 
// Neither is this
pub const ALL_FALSE: [bool; _] = all_false::<10>();

// The returned type `std::slice::Iter` has a lifetime, 
// but there's no visual indication of that.
//
// Lifetime elision infers the lifetime of the return 
// type to be the same as that of `scores`.
fn items(scores: &[u8]) -> std::slice::Iter<u8> {
   scores.iter()
}

warning: hiding a lifetime that's elided elsewhere is confusing
 --> src/lib.rs:1:18
  |
1 | fn items(scores: &[u8]) -> std::slice::Iter<u8> {
  |                  ^^^^^     -------------------- the same lifetime is hidden here
  |                  |
  |                  the lifetime is elided here
  |
  = help: the same lifetime is referred to in inconsistent ways, making the signature confusing
  = note: `#[warn(mismatched_lifetime_syntaxes)]` on by default
help: use `'_` for type paths
  |
1 | fn items(scores: &[u8]) -> std::slice::Iter<'_, u8> {
  |                                             +++

use std::fmt;
 
struct Greeting;
 
impl fmt::Display for Greeting {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        //                -----^^^^^^^^^ expected lifetime parameter
        // Knowing that `Formatter` has a lifetime does not help the programmer
        "howdy".fmt(f)
    }
}

#[target_feature(enable = "avx512bw")]
pub fn cool_simd_code(/* .. */) -> /* ... */ {
    /* ... */
}

/// ```ignore-x86_64
/// panic!("something")
/// ```
pub fn my_function() { }