Rudxain

type numeric = number | bigint

const num_guard = (x: unknown): x is numeric =>
	typeof x == 'number' || typeof x == 'bigint'

const num_cond = <T,>(x: T) => (
	typeof x == 'number' || typeof x == 'bigint'
) as T extends numeric ? true : false

// this example is incomplete,

Rudxain

pub fn trampoline<F, A, C, T>(f: F, args: A) -> T
where
    F: FnOnce(A) -> Result<C, T>,
    C: FnOnce() -> Result<C, T>,
{
    let mut out = f(args);
    // `while let` would require an awkward
    // `if let Err(x) return x; unreachable!()` at the end.
    // https://users.rust-lang.org/t/is-there-any-way-to-express-while-let-some-true/72527/2
    loop {

Rudxain

// boilerplate
class BigUint {
    /** Zero */
    static N0() {
        return new BigUint(0n)
    }
    /** One */
    static N1() {
        return new BigUint(1n)
    }

Rudxain

#![no_std]

/// if `cond` is `true`, then `identity(x)`
///
/// if `cond` is `false` then `drop(x)`
pub fn cond_ident<T>(cond: bool, x: T) -> Option<T> {
    if cond {
        Some(x)
    } else {
        None

Rudxain

#![warn(clippy::pedantic, clippy::nursery)]

use core::iter::successors;
use num_integer::{Integer, Roots}; //0.1

pub fn divisors_fast<T: Integer + Roots + Clone>(x: &T) -> Vec<T> {
    let sq = x.sqrt();
    let mut divs = Vec::new();

    let n1 = T::one();

Rudxain

use num_integer::Integer; // 0.1

#[derive(Copy, Clone, Eq, PartialEq, Debug)]
enum S {
    F,
    B,
    FB,
}

fn fb<T: Integer>(n: &T) -> Option<S> {

Rudxain

How does &str have len()?

If str is unsized, then how does a ref magically have a len method? let alone an actual return value?

One could argue "unsized types cannot exist in (safe) Rust. Therefore, an str is just an &str stripped of its size data".

But that explanation doesn't satisfy me

Rudxain

fn main(){let mut n=7usize;while n!=0{print!("{n} ");n=[n*3+1,n/2][n%2]}}

Rudxain

def fn(x, n):
	return (x/n + x*n) / 2

Rudxain

#!/bin/sh
set -f
[ -n "$(dumpsys deviceidle | grep mScreenOn=false)" ]