Arbitary Lifetime Transmutation via Rust Unsoundness

Do you believe that one can write a function in safe Rust which can arbitrarily change the lifetime of a reference? For clarity, try to implement the following function without using `unsafe`:

`fn transmute_lifetime<'a, 'b>(x: &'a u64) -> &'b u64 { todo!() }`

Such intention seems to violate the fundamental principle of Rust’s lifetime system, which is to prevent dangling references and data. However, it is possible to write such a function in safe Rust, and it is not even that hard:

`trait Trait {    type Output;}impl<T: ?Sized> Trait for T {    type Output = &'static u64;}fn foo<'a, T: ?Sized>(x: <T as Trait>::Output) -> &'a u64 { x }fn transmute_lifetime<'a, 'b>(x: &'a u64) -> &'b u64 {    foo::<dyn Trait<Output=&'a u64>>(x)}`

Dijkstra 算法的延伸

Manacher 回文计数算法

\$\$s[i-(p-1)..i+(p-1)],\ldots, s[i-1..i+1], s[i..i]\$\$

Go Fact: Zero-sized Field at the Rear of a Struct Has Non-zero Size

There’s a concept in Golang called zero-sized type (or ZST), namely, a type whose variables take up zero bit of memory. One of them is the famous `struct{}`. People often use `map[string]struct{}` to efficiently emulate a set structure. Others include zero-length arrays such as `[0]int`, albeit not very common, are adopted to enforce some properties of a customized type.

Display *big.Rat Losslessly and Smartly in Golang

Floating-point numbers, as we know, are notorious for losing precision when their values become too large or too small. They are also bad at representing decimals accurately, yielding confusions like `0.1 + 0.2 != 0.3` for every beginner in their programming 101.

Albeit being imprecise, floats are good enough for most daily scenarios. For those not, however, Golang provides `*big.Rat` to the rescue. Rats are designed to represent rational numbers with arbitary precision, addressing most flaws of floats, yet at a cost of much slower computation speed and bigger memory footprint. For example, we are confident to compare `0.1 + 0.2` to `0.3` using Rats without caring about tolerance:

In the Trac Main Features page https://trac.edgewall.org/wiki/TracFeatures, Trac is said to emphasize “ease of use and low ceremony”. Can someone please explain what “ceremony” means in the context of software usage?

low ceremony 与 ease of use 作并列短语，可见在程序开发的语境下，代码的仪式不是一个褒义词——过多的仪式并没有好处。用户 Rowan Freeman 则作此回答：

Low ceremony means a small amount of code to achieve something. It means you don’t need to set up a lot of things in order to get going.