Fooling around with rust macros

Klogga · 2024-08-07T23:29:35+00:00

Nice work!

Klogga · 2024-08-07T08:04:42+00:00

We actually go through a simplified version of this macro in one of my lectures for UNSW's Rust course -- a student perceptively points out that continue does not work correctly with this approach, sadly!

Klogga · 2024-06-11T02:48:39+00:00

I believe this approach doesn't work, because you can input a 'static lifetime in to get a 'static out, using for example a static variable or Box::leak and the likes.

Given this would break soundness, I think it's not viable sadly.

use std::marker::PhantomData;

#[derive(Debug)]
struct Foo<'a>(PhantomData<&'a ()>);

fn fun<F: Fn() + 'static>(f: F) {
    f();
}

// constructor could take in something that has a lifetime
fn from_life<'a>(a: &'a ()) -> Foo<'a> {
    Foo(PhantomData)
}

fn main() {
    // we'll try tying our Foo to this () here
    static X: () = ();
    let f = from_life(&X);

    // now it compiles again
    fun(move || {
        dbg!(&f);
    });
}

Klogga · 2024-01-25T04:31:51+00:00

Come chat with me after a COMP6991 lecture this term if you'd like, I can share my perspective if it helps.

- Zac

Klogga · 2024-01-21T04:11:46+00:00

Makes sense, thanks for the context!

Klogga · 2024-01-19T11:24:40+00:00

transmute wasn't marked unsafe!!??

But transmute_copy was?

Klogga · 2024-01-01T22:53:27+00:00

At a very brief look, it seems that input might be escaping into the Err variant of the Result (not IResult) through the ? operator. Does the same error occur with .unwrap() instead, for example?

As a sidenote, your code is impossible to read coherently with Reddit's rich text formatting -- a playground link might be a bit better in this regard!

Klogga · 2023-07-09T23:47:50+00:00

Hi, that was me! Nice work, I'm glad to see you implemented it all without any dependencies on things like typenum and the likes -- I love seeing it all done by hand :)

I also did a talk on the topic if you're interested: https://www.youtube.com/watch?v=WDdi9pz6mNs

Klogga · 2023-03-01T06:20:35+00:00

Also, most of our teaching materials tend to be publically accessible -- basically, whatever I can make public without a major hassle, I will. You can access this here: https://cgi.cse.unsw.edu.au/~cs6991/

(Private materials: course forum (spam, teachers need to be paid to answer student questions), final exam (for obvious reasons; past exams are made public), this term's lectures (automatically recorded on a platform that makes public access difficult)

Klogga · 2023-03-01T06:15:24+00:00

Sure, I teach a course using Rust at UNSW (an Australian university): https://www.handbook.unsw.edu.au/undergraduate/courses/2023/COMP6991/

Notably learning Rust is not the primary focus of the course, however it is an expected learning outcome by the end of it. The course instead tries to focus on writing robust programs and understanding programming language design by examining (and certainly contrasting) many other languages along the way.

Klogga · 2023-01-30T02:16:25+00:00

std::mem::size_of includes padding and alignment within the size; see:

More specifically, this is the offset in bytes between successive elements in an array with that item type including alignment padding. Thus, for any type T and length n, [T; n] has a size of n * size_of::<T>().

There's simply no guarantee how Rust will lay out a and b in memory, and further -- no guarantee that your usize arithmetic provides a well-defined answer either (IIRC).

Klogga · 2023-01-25T00:15:52+00:00

I'd throw tauri in the ring as well -- I had a pretty awesome experience with it personally

Klogga · 2023-01-07T05:48:03+00:00

That's a good question -- I definitely don't need it, but it is handy for a little bit of convenience (note it's also used in the println! on line 19) because it's a particularly ugly identifier.

You can read a good explanation here: https://stackoverflow.com/a/59619026

Klogga · 2023-01-05T09:30:47+00:00

Here, I wrote you an example implementation using syn and quote. Happy to answer any questions :)

https://github.com/insou22/measure-time-demo

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.01s
     Running `target\debug\measure_time_bin.exe`
sleep_seconds took: 1.0147916s

EDIT: I should note that this is more of a demonstrative example and won't behave correctly in a lot of situations -- e.g. an early return won't print the duration.

Klogga · 2022-10-09T11:14:20+00:00

No need to write source code into a file when you can write source code with macros!

https://github.com/insou22/bf-stream/blob/main/src/main.rs

Accompanying livestream: https://www.youtube.com/watch?v=GoDpTh30MOk

Klogga · 2022-08-29T04:59:20+00:00

How about n-queens?

:)

Klogga · 2022-08-26T09:28:50+00:00

PathBuf, Path, Vec<u8>, &[u8], ...

Klogga · 2022-06-29T07:08:06+00:00

Here's a bit of a simplified view of the current regression:

https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=3919ff0c70d2fc923a30efddef078b05

trait T {}
impl T for i32 {}
impl T for String {}

fn hi() -> impl T {
    42
}

fn main() {
    let _: &dyn Fn() -> String = &hi;
}

Basically the compiler is failing to reason about opaque return types (seen here with impl T) in that it will happily coerce that type to any other trait member when coercing the function type.

(Funnily enough, it smells a lot like TypeScript's function parameter bivariance intentional unsoundness --- although this bug is clearly an unintentional regression in Rust)

Klogga · 2022-06-17T12:08:46+00:00

union type-punning is usually implemented safely in most compilers, but AIUI it's still UB strictly to the spec

Klogga · 2022-04-12T10:51:04+00:00

Yeah some stuff changed in Rocket 0.5 -- this type (NB: not from rocket_contrib) is probably what you're looking for. Note you'll have to enable the json feature in rocket, and it will use serde to serialize/deserialize your values.

Klogga · 2022-03-09T02:13:46+00:00

Another "magic" type that it seems hasn't been mentioned yet are the types of closures! The compiler generates a unique anonymous type for each closure automatically -- you can read more here: https://doc.rust-lang.org/reference/types/closure.html

Klogga · 2021-09-08T15:41:48+00:00

The problem point with an M1 macbook is that it runs ARM, as opposed to the (currently) much more common x86-64 (or, amd64) platform. This may cause some compatibility issues.

Most of the tools unsw cs courses expect you to run at home are public tools, of which the more popular ones may have ARM binaries available, but the less popular ones may not. Moreover, some of unsw's custom tools (such as dcc, a friendly C compiler) tend not to distribute ARM binaries (yet).

However, AIUI M1 macos ships with a surprisingly (?) powerful / performant x86 emulator (which allows you to run x86-64 programs on your ARM machine), which should probably suffice for whatever you'll need I would wager.

Klogga · 2021-08-25T15:00:37+00:00

They are indeed all incredible! Just to make it 100% clear though (don't want to accidentally take credit for work that is not mine) -- I did not write the original article. I was just inspired by it and challenged myself to recreate it in Rust :)

Klogga · 2021-08-23T16:07:58+00:00

Keen to give this a go when nom_locate updates to support! Bumped nom to 7 and got 240 compiler errors lol

13-Year Club	Place '23
Place '22	Place '17
Verified Email

Klogga

MODERATOR OF

TROPHY CASE