Amateur Programmer Thread

General
41

@Vanilla_Town if you and culturedurbanite were married which one would be the wife and which one would be eaten?

1 Like
42

I like to picture Jones as a powerbottom

43

Hit a compiler bug.

44

IMG_7871
IMG_7871828×431 117 KB

45

So we have this:

#![feature(adt_const_params)]

#[derive(Debug, Default)]
struct Foo<const F: f32> {}

impl<const F: f32> Foo<F> {
    fn foo() -> f32 {
        F
    }
}

this compiles, and works: Rust Playground

pub fn main() {
    const f: f32 = 0.75f32;
    println!("{}", Foo::<f>::foo())
}

this does not:

pub fn main() {
    println!("{}", Foo::<0.75f32>::foo());
}

???

46

Probably a formatting problem right

47

the compiler isn't lowering the floating point literal "0.75f32" to a constant (which it should be considered afaik, this should be able to be evaluated at compile time: Tracking issue for `#![feature(const_fn_floating_point_arithmetic)]` · Issue #57241 · rust-lang/rust · GitHub)

error: internal compiler error: no errors encountered even though `delay_span_bug` issued

error: internal compiler error: Const::from_anon_const: couldn't lit_to_const TypeError
  --> src/main.rs:15:26
   |
15 |     println!("{}", Foo::<0.75f32>::foo());
   |                          ^^^^^^^
   |
   = note: delayed at compiler/rustc_middle/src/ty/consts.rs:128:30

thread 'rustc' panicked at 'Box<dyn Any>', compiler/rustc_errors/src/lib.rs:1425:13
...

unless I'm missing something about floating point/language semantics.

48

What are you doing right now? Like, what's the end goal?

49

The general idea is to have a bloom filter that requires a buffer of M bits dependent on N number of items in the set with P probability of a false positive.

So we have a structure that looks something like:

struct Foo {
uint8_t buf[M]
}

So with metaprogramming, you could define something like Foo{5, .05} or something that is expanded to

struct Foo {
  uint8_t buf[A * B]
}

where M ends up being A * B or whatever it is.

In rust, you can use const generics to offload this to the type system, rather than doing it via metaprogramming.

The regular primitives (usize, i8, boolean) are stable, floating point is not.

50

While amateur programming I have stumbled upon some case where apparently float literals (which should be constants and evaluated at compile-time) are not the same as const f: f32 = float literal within the type system.

looking at this, it seems the exact same thing is being produced assembly wise.

1 Like
51

Can't you just write this in hlsl?

52

Here is some code i've written the past few days inspired by jones and nmagane.

2 Likes
53

i have to spend 6 hours tomorrow weed eating a massive property in 105 degree heat

im not some fat tranny like you subsidized by the state

if im going to do something, it's going to be fun and interesting to me.

54

sorry bro I'm not a gay ■■■■■■ libtard i actually have to do hard work

55

There are plenty of those that work hard

56

the mexicans who vote democrat illegally aren't "libtards" dude sorry

57

where did you find this guy lmao

2 Likes
58

this is why I like rust so much: It's a foray into the abyss of highly competent, radicalized tranny libtards and their army of people concerned with "code of conduct" alongside mega-autistic type theory

59

I've got so much to weed to smoke unless like the libtards

2 Likes
60

Sorry jones, i didn't mean to grief your thread. I'm sorry.

1 Like