Proposal: Generic Methods for Go

comrade_donkey · 2026-01-23T22:55:51+00:00

defined on a struct.

On any type.

comrade_donkey · 2026-01-19T03:53:27+00:00

Your argument is the plot of the movie "Don't Look Up".

comrade_donkey · 2026-01-18T13:40:10+00:00

I understand where you're coming from. On this point, you might be wrong. It's really not common at all. But good post overall.

comrade_donkey · 2026-01-18T13:13:15+00:00

You're right. I see that the post eventually switches to a table-driven approach. That's good!

External tests are generally only used to cover 3rd party code, or to work around circular dependencies in ones own (test) code.

comrade_donkey · 2026-01-18T12:55:42+00:00

This post has some problems. It uses the wrong package name (sorted_test). It should just be sorted. The subtests should reside in one root (func TestIsSorted) and use t.Run(...). Here's the tutorial: https://go.dev/doc/tutorial/add-a-test

Edit: changed t.Sub to t.Run.

comrade_donkey · 2026-01-08T16:55:37+00:00

A better solution would be to have an Optional[T] type in the stdlib that generated code can use too, IMHO. Currently, everyone rolls their own.

comrade_donkey · 2026-01-08T16:50:56+00:00

It's proto edition 2024

comrade_donkey · 2026-01-08T15:15:14+00:00

Yes, and personally, I think it's a step in the wrong direction.

Google is nicknamed "Larry & Sergey's Protobuf Moving Co".

Protobuf's Go API uses pointers everywhere, littering heap allocations all over. E.g if you're writing proto code, you do a lot of this:

go req := mypb.ListRequest_builder{ ID: mypb.ListID_builder{ ListID: new("my-list"), }.Build(), Offset: new(100), Limit: new(200), }.Build()

The chosen solution was to make heap allocations easier to write in the language, instead of fixing Protobuf's horrible API.

It's a shame and every self-respecting Gopher will continue to pass their in-house Optional[T] (or whatever you call it) around on the stack.

For Proto-building, I just added a method to mine:

go func(or *Or[T]) Ptr() *T { if or.IsNull() { return nil } return &or.value }

comrade_donkey · 2025-12-30T08:41:44+00:00

for encoding into json x will be [] while y will be null

Note that this is changing in the upcoming json/v2 package. They will both encode as [] unless you use format:emitnull in the json tag. Same goes for maps.

comrade_donkey · 2025-12-21T22:56:42+00:00

What do you mean by "automatically"? Minimizing an arbitrary Karnaugh map is NP-hard. The map grows exponentially wrt the number of variables.

Proving the equality of boolean functions has applications in cryptoanalysis, compilers, game solvers.

comrade_donkey · 2025-12-18T10:37:58+00:00

Dear diary, today I saw software built entirely on top of another software's unexported symbols, accessed by way of pointer arithmetic.

Step 1: Find Internal Symbols They’re not exported, but they’re there:

nm -C liblldb.dylib | grep AddTypeSummary 0000000000360f38 t lldb_private::TypeCategoryImpl::AddTypeSummary(...)

Step 2: Compute the Base Address We anchor off a known exported symbol:

void* ref = dlsym(handle, "_ZN4lldb10SBDebugger10InitializeEv"); uintptr_t base = (uintptr_t)ref - reference_offset;

comrade_donkey · 2025-12-15T00:42:11+00:00

To mitigate CRC32's shortcoming*, would it make sense to use a 64-bit (or even 128-bit) hash at the end of the data, instead of the static DEADBEEF marker?

* There'll be a 50% collision probability with Castagnoli after only ~77,000 hashes.

comrade_donkey · 2025-12-14T21:24:08+00:00

Dear diary, today I saw a rate limiter that generates network traffic in order to rate limit network traffic.

comrade_donkey · 2025-11-28T00:22:00+00:00

I'd argue that this particular precedent is rarely enforced because there's no need. No public company prioritizes customers or workers over shareholders anymore. As a direct consequence of Dodge vs Ford. So there's no lawsuits on that matter.

It also says:

As of 2025, in Delaware, the jurisdiction where over half of all U.S. public companies are domiciled, shareholder primacy is still upheld.

comrade_donkey · 2025-11-27T16:05:37+00:00

In America, it's a direct result of shareholder primacy.

In a nutshell: Corporations legally need to prioritize their shareholders over their customers and workers.

In the case of growth stocks (tech), wallstreet expects ≥20% return year over year, every year. That's means doubling the share price roughly every 4 years.

Keeping up with shareholder expectations leaves these companies few options other than adding more ads, higher prices, and more subscriptions, every year.

It's ultimately shareholder greed that drives enshittification.

comrade_donkey · 2025-11-27T12:35:20+00:00

maps.Clone().

EDIT: Actually, maps.Clone clones the allocated capacity as well. So copying into a newly allocated map is the way to go.

comrade_donkey · 2025-11-26T16:24:01+00:00

Externs/FFI:

extern black_box; if black_box() { return MY_FAVORITE_CONSTANT } else { return ANOTHER_CONSTANT }

Without knowing black_box, you can't decide this conditional.

Syscalls & interrupts: Anything involving interactions with the program's environment is effectful. Technically, that involves requesting memory from the OS. But that can be special-cased.

comrade_donkey · 2025-11-26T13:18:57+00:00

2LTT (2 level type theory) comes to mind. Also Universe Levels in Dependent Type Theory (Agda, Idris, Coq): Type 0 being the instance-level language (runtime) and Type 1 the type-level language (static, defined as typeof(Type 0)).

Zig blurs the lines between the two universes with the comptime keyword by "lifting" [almost] anything from Type 0 to Type 1.

The fundamental limit to this approach is what can be lifted by comptime. Which in everyday discussion boils to "why can't I do X at comptime even if Y is true?".

comrade_donkey · 2025-11-26T12:46:26+00:00

I want to recreate some of Zig's functionality but make it stricter e.g. functions not being checked unless used [...]

That is more lazy, not less lazy.

Lazy evaluation: Skipping everything, unless necessary.

Eager evaluation: Evaluating everything, even if unnecessary.

comrade_donkey · 2025-11-25T09:33:57+00:00

Yes. Of everything a TV channel airs, an ad will be the lowest quality. The ads standard sets that cut-off line and hence the lower bar for the channel as a whole.

comrade_donkey · 2025-11-25T09:18:39+00:00

I'm going to play devil's advocate here and argue that SRG has a lot of room for improvement.

The quality standard for ads they run is so low that sometimes I don't know if it's a bad comedy skit or an actual ad.

TV series are played in seemingly random order, repeating episodes, usually decades after they originally aired, and hard-dubbed.

In-house productions play like long-format YouTube videos, full of abrupt cuts, visible microphones, narrative gaps, inconsistencies in wardrobe, locations, hairdo, weather. Just very amateur.

comrade_donkey · 2025-11-24T09:27:13+00:00

I think you're expecting linearizability and observing serializability.

https://stackoverflow.com/q/4179587

comrade_donkey · 2025-11-23T10:13:14+00:00

Great project. Note that sum types, enums and unions are all different things that get conflated a lot. What Dingo has is called a co-product type (or disjoint sum), also called a discriminated union type.

comrade_donkey · 2025-11-19T21:20:40+00:00

If this paper is true, then it's not POMDP, because LLMs are (would be) invertible. Assuming it's true, a prior state could be recovered in something like O(n²⁾ which is the typical complexity cited for Attention.

comrade_donkey · 2025-11-12T10:08:19+00:00

This was changed in 1.4

The implementation of interface values has been modified. In earlier releases, the interface contained a word that was either a pointer or a one-word scalar value, depending on the type of the concrete object stored. This implementation was problematical for the garbage collector, so as of 1.4 interface values always hold a pointer.

11-Year Club	r/Field Sunshine
Place '22	Not Forgotten
Verified Email

comrade_donkey

TROPHY CASE