i do this and rust becomes a strictly better c

>i do this
do you also look like that or something.

>>105652126 (OP)
If you handed me this code I would be calling security and having you escorted out the building.

>>105652126 (OP)
jesus that's ugly as shit.
no wonder why you cut your dick off

>>105652126 (OP)
>>105652221
Rust is actually the single ugliest language in popular use rn

>>105652126 (OP)
ya, but why?

>>105652126 (OP)
>mut
It's more like mutt

>>105652126 (OP)
>strictly better c
c++*

>>105652260
nah it's equal with java, zig and sepples

>>105652260
That’s the point.
They translate it from C to rust automatically, then mess around with the rust output until it’s impossible to translate it back. For now.
Once it becomes popular enough, we’ll make a rust2c translator and squash it.
Of course, they’ll respond by changing the language more drastically to control the existential threat, but it will be too late.

>>105652126 (OP)
>fn free(&mut self)
uh oh, that means I can call free multiple times

>>105652126 (OP)
What the fuck is this garbage syntax.

>>105652126 (OP)
Based. I wouldn't go quite this far myself but I do think the "Rust community" can be a bit too uptight about soundness. I've definitely written a few "safe" functions that cause UB if you use them in a particularly stupid way. Rust offers you a lot of options for catching bugs at the cost of increased developer overhead - but if a particular bit of overhead isn't helping to catch any realistic bugs, then it's better to get rid of it.

>>105652126 (OP)
This is just UnsafeCell but worse

>>105652441
>Once it becomes popular enough, we’ll make a rust2c translator and squash it.
This is already in progress - it was supposed to be one of the Rust GSOC projects for this year (not sure if that actually happened or not)
https://github.com/FractalFir/rustc_codegen_clr
It's not super difficult to write such a thing using rustc internal APIs. I built one years ago, which is now bitrotted. But the Stable MIR project is supposed to have a 1.0 release soon, which will make things less prone to bitrot as rustc internals change.

>>105653064
This is not even remotely like UnsafeCell

What's the best way to subvert the borrow checker?

>>105653130
try your usual subversion strategies

>>105652221
>rust is ugly
i don't understand this. what's ugly about it and how would you do better?

>>105653130
.clone()

>>105652441
>They translate it from C to rust automatically, then mess around with the rust output until it’s impossible to translate it back. For now.
You don't have to do that because Rust is a more powerful and productive language. You'd get very unidiomatic Rust that way and it would have all the bugs of the original C. The whole point of translating C to Rust is to show C shills that Rust can do literally 100% of everything C can do.

>Once it becomes popular enough, we’ll make a rust2c translator and squash it.
Rust is a faster and more readable language than C. There are already C backends for a lot of languages but people don't like them because the C is slower and less readable than assembly. ECL and Chicken do that for Common Lisp and Scheme.
https://en.wikipedia.org/wiki/Chicken_(Scheme_implementation)
>Chicken (stylized as CHICKEN) is a programming language, specifically a compiler and interpreter which implement a dialect of the programming language Scheme, and which compiles Scheme source code to standard C.

>>105653275
>rust is readable
OP's picrel is rust, right? are you high?

>>105653326
It's shit Rust.

>>105653337
>No true Scotsman

>>105652221
>jesus that's ugly as shit
very ugly.

>>105652126 (OP)
> a strictly better c
can't see how.


>>105653275
>more powerful
just isn't. it's good but it isn't more powerful at all.
> more readable language
it's not. it's far worse than c, which is why all of rusts commonly used functions that wouldn't need macros in c are using macros in rust.

>>105653225
everything. why did they copy the sepples <>? ::? {}? semicolons?
also this pub and impl keyword shit is disgusting. you just need a real module + signature system and sealable strutcures.
in a real ML this is differentiated and controlled by your choice of ":" or ":>" when defining a structure. fine grained control is handled through functors. as a result, you don't write ten trillion pubs or impls all over your fucking code.
rust has so much baked in noise because of arbitrarily retarded decisions they made for no good reason.

oh sorry no, they made the language like this because they thought c programmers would have a conniption over not having curly braces or whatever.
that's definitely a good reason to add ten trillion keystrokes and god awful visual noise to your already verbose and complicated language.
FUCK they dropped the ball so fucking hard on Rust and it pisses me off.

>how would you do better
signature PTR =
sig
type 'a ptr
val new : 'a -> 'a ptr
val free : 'a ptr -> unit
val clone : 'a ptr -> 'a ptr
end


and then something like
structure Ptr : PTR =
struct
type 'a ptr = 'a ref
fun new x = ref x
fun free x = destroy_ref x
fun clone x = Ptr.new !x
end


didn't bother pretending this uses affine types or whatever, so clone just does a copy, no boxes just pure pointers, etc.
you can extend it arbitrarily to be affine in your head if you want with shit like:
fun new x = Box.leak(Box.new x)

or whatever

>>105653535
>it's not. it's far worse than c, which is why all of rusts commonly used functions that wouldn't need macros in c are using macros in rust.
They "wouldn't need macros in C" because you can't do them in C at all. C doesn't even let you think about doing things that you can easily do in Rust.

>>105653863
>tranime
>retarded post
pick two
that code looks terrible btw

>>105653887
I humbly accept your concession, now stop grovelling silly!

I unironically like the concept of the borrow checker, but I have a completely different application in mind for it

>>105653915
whats your idea anon?

>>105653869
>C doesn't even let you think about doing things that you can easily do in Rust.
maybe if you're a retard? i don't have this problem. if i find library that has functions i need, takes me two seconds to edit the makefile to link it and include the header in my code. what's the problem exactly? besides problems you're making up? c isn't a language that's going to hold your hand, whisper sweet nothings into your ear and tell you that you are a woman, without laughing.

>>105653934
So, something I've been fixated on a while is computational graphs, sort of like what a lot of autograd software does under the hood. Being able to trace when variables, (likely during the SSA phase of compilation), interact with each other, and in turn, when they interact with other functions, could allow for some really bizarre optimizations revolving around segregating io bound code. You could restructure any function into an asynchronous pure/const component, and then have all of the shit that yields to the kernel be a synchronous component. If you knew when the result of a variable at a given point in the computation needs to have undergone certain steps, you could either do it lazily or even precompute it. Limited testing with this also led me to accidentally realize that in the instance of a distributive operation, (i.e. applying an operation to elements of an array where the results per element are independent), you could really easily just turn these pure components into a compute kernel.

TL;DR, io bound code goes to the back of the bus.

>>105653863
I agree with your entire post.

>oh sorry no, they made the language like this because they thought c programmers would have a conniption over not having curly braces or whatever.
This is exactly right.

>that's definitely a good reason to add ten trillion keystrokes and god awful visual noise to your already verbose and complicated language.
>FUCK they dropped the ball so fucking hard on Rust and it pisses me off.
It sucks, but C/C++ syntax is the only reason people are talking about Rust right now. If it used ML (or Lisp, BASIC, Python, or Pascal) syntax, it wouldn't be popular with C/C++ programmers. C/C++ people actually like ugly languages better because it makes them feel like they're part of a secret club that keeps normies out. This is why they hate good-looking languages so much.

>>105653991
when did AD start getting called autograd?

>>105654012
Some time before I went to college I assume, I've heard both, but gradient is more correct because you rarely actually deal with monovariable calculus in practice

>>105653991
That's basically the IO monad in Haskell.

>>105654032
It's probably the closest thing to what I'm envisioning out there, but part of my concept is having the created graph be rotated to create closures that further isolate the io bound code

>>105652126 (OP)
wtf is this shit. Is this a parody language?

>>105653991
You don't even need substructural types for that, in this instance they're only useful for catching deadlocks at compile time. What you're describing is just computation using graph reduction.
Haskell isn't implicitly parallel, but that's mostly because it's based on a 40 year old redex machine architecture. Other than that, it's basically how GHC already works and why it's "the best compiler"
30 years ago we figured out implicitly parallel graph reduction through interaction nets (which are somewhat related to substructural types, through linear logic, but don't necessarily need them)
This is probably the most impressed I've been in the interaction net space:
https://vine.dev/

Graph reduction is really cool. Time traveling variables is a cute trick, but also being able to implicitly parallelize imperative code and apply extremely aggressive optimizations is neat.

>>105654069
In 1969, AT&&T had just terminated their work with the GE/Honeywell/AT&&T Multics project. Brian and I had just started working with an early release of Pascal from Professor Nichlaus Wirth's ETH labs in Switzerland and we were impressed with its elegant simplicity and power. Dennis had just finished reading Bored of the Rings, a hilarious National Lampoon parody of the great Tolkien Lord of the Rings trilogy. As a lark, we decided to do parodies of the Multics environment and Pascal. Dennis and I were responsible for the operating environment. We looked at Multics and designed the new system to be as complex and cryptic as possible to maximize casual users' frustration levels, calling it Unix as a parody of Multics, as well as other more risque allusions. Then Dennis and Brian worked on a truly warped version of Pascal, called ‘A’. When we found others were actually trying to create real programs with A, we quickly added additional cryptic features and evolved into B, BCPL and finally C. We stopped when we got a clean compile on the following syntax:

for(;P("\n"),R--;P("|"))for(e=C;e--;P("_"+(*u++/8)%2))P("| "+(*u/4)%2);

To think that modern programmers would try to use a language that allowed such a statement was beyond our comprehension! We actually thought of selling this to the Soviets to set their computer science progress back 20 or more years. Imagine our surprise when AT&&T and other US corporations actually began trying to use Unix and C! It has taken them 20 years to develop enough expertise to generate even marginally useful applications using this 1960's technological parody, but we are impressed with the tenacity (if not common sense) of the general Unix and C programmer. In any event, Brian, Dennis and I have been working exclusively in Pascal on the Apple Macintosh for the past few years and feel really guilty about the chaos, confusion and truly bad programming that have resulted from our silly prank so long ago.

>>105654087
This looks really interesting actually. Something I came across randomly during my reading on my thing was this, https://en.wikipedia.org/wiki/Self-modifying_code#Massalin's_Synthesis_kernel.
This chick basically used a similar dynamic closure concept as me to make a kernel.

>>105654090
>for(;P("\n"),R--;P("|"))for(e=C;e--;P("_"+(*u++/8)%2))P("| "+(*u/4)%2);
in lisp this is just
(for(P("\n"),(-- R))(P("|"))(for((= e C)(-- e)(P((+ "_" ((%(/(++(* u))8))2)))(P((+ "| " (%((/(* u)4)2)))))))))))

>>105652126 (OP)
this is REAL code written by REAL programmers
they have taken us for absolute fools

Call me autistic but the thing I hate most about rust is the implicit return shit, it's 6 letters and a space you lazy niggers

>>105654003
>it wouldn't be popular with C/C++ programmers.
I mean it already seems pretty unpopular with a lot of them.
Haskell saw a lot of adoption, and for a long time had more adoption than Rust. But ultimately what cucked Haskell was:
>Being steeped in impenetrable academic jargon
>Only way to break purity is by fighting through the academic jargon
On top of stuff like laziness, and of course the GC.

But the relative success Haskell has seen, despite even those factors, makes me think we could have stuck with the ML syntax. The key is just getting big projects and big companies to use the language.

>>105654183
13 years ago when I first used Rust I thought exactly like you. But then I tried it out and it was cool.

>>105654183
It makes sense in non-function scopes.

>>105654204
>>105654221
It just comes off to me the same as people defining control flow macros in C, or using implicit casting overloading in C++. It makes your life mildly easier while writing code, but it's just more nonsense to parse when you go to debug or refactor.
Maybe I'm off base on that, but in what rust code I've written, I've made a conscious decision not to allow it for myself.

>>105654246
you're just a brainlet. stick to java/c#/python

>>105654284
Programmers value simplicity, niggers value complexity
- Terry Davis

>>105654317
simple is hard. simple takes effort.

>>105654246
it's less to parse, but if you're coming from a place where you have statements as well as expressions and you never bothered to really get that level of understanding on how the grammar works, i can see it not making sense and seeming arbitrary.
you really need to put c and sepples out of your head when writing rust. it's not compiled the same way.

>>105654246
I don't think it's really intended for anything bigger or anything that has flow control, so it's not really that hard to parse. You'd only use it for something like this:

match result {
Ok(value) => value,
Err(error) => {
info!("Could not parse result: {}", error);
DEFAULT_VALUE
},
}

>>105654361
It's more that I like being explicit, the less I have to reason about the syntax of the code I write as opposed to what the code is doing, the better

>>105654363
This is fine, legitimately, I've just seen the implicit return used in some really awful places, where the function is so long you can't even see the signature in your editor anymore. It's just tacky.

>>105654363
Disgusting.

>>105654408
it is explicit, it's a facet of how the grammar works and what you're expressing to the compiler. again, rust isn't c or sepples. a function is an alias over a set of transformations to be performed with specific inputs. the output is explicit because that's what a function does. it transforms things and outputs the results.
consider the following:
let AddOne x = x + 1
let y = AddOne 1

in this sense, you can substitute "AddOne 1" with "1 + 1" and it will mean the same thing. this symbolic substitution is the fundamental meaning of functions in expression-oriented languages, and it's precisely what enables things like pattern matching to work nicely.

this isn't any more explicit, it's just redundant information:
let y = return 1 + 1


this is partially why i bitch up-thread about how much babyducking rust does with sepples. it tricks and confuses you into thinking "oh it's just c with some syntax moved around" but no. it's an entirely different language family that belongs to the same one as my psuedo-code above. they just sprinkled extra noise on top to trick you into using something close to a mathematician's black board

>>105654622
I don't have an issue wit hit as a mathematician, I do have issues with it as a programmer.
Haskell syntax, especially when typed, it rigorous and beautiful, but Lisp and the (((parens))) are syntactically simple because they're already an AST.
Different contexts, different needs.
Also, in machine code, it's basically all
...
mov rax, rwhateverx
pop rbx
...
ret

anyhow.

>>105654680
>Also, in machine code, it's basically all
What if I told you it's not? Look at how mangled this code is:
https://godbolt.org/z/Tzf3Ghcan

>>105654907
nigga this is tail calling, this is not remotely a rust thing

>>105655183
rust cant tail call?

>>105655188

>>105653957
I'm tired of arguing my point about basic convenience not being a vice, point which somehow escapes all cniles as soon as it's brought up but if there's one thing that I do not understand how could you possibly hold it's that I don't know maybe headers and make are fucking caveman technology?

The only two prerequisites to having this extremely basic opinion is:
1. venturing beyond fizzubuzzer shit like linked lists
2. having used a modern (circa. 2000 and later in cnile speak) build system
I'll give you, the common tranny obsessed poltard the benefit of the doubt and assume you've at least done one of these in which case go on I encourage you to spread your wings and do something serious for once with yourself, you've got all the time in the world contribute to a project and learn from your horseshit before you die

Speaking of C build systems, why is autotools not more popular? I started using it a few months back and it's literally everything I've wanted

>>105655430
are you filtered by header files?

>>105655430
The problem with C isn't headers and make, it's that it's missing fundamental language features like tagged unions / match, generics, and closures. You can emulate them, of course, but it's extremely obnoxious to work with due to the amount of boilerplate required

>>105654184
For me it was Haskell's 4 GB compiler infrastructure. I started with Hugs 98 (a few MBs) and grew with it until it started to smell. There's something unhealthy about it.

>>105655473
Autotools, like much of GNU, is an unholy mess that was created to cope with commercial Unix being broken and inconsistent. If you think freetard software is bad, the proprietary slop it replaced would have given you an aneurysm.
If you REALLY want to use it then knock yourself out, it still works. But expect others to be surprised by the choice.

>>105655473
It's not a build system, it's a shell script defecation system.

>>105654003
>a secret club that keeps normies out
programming was this natrually until the femalres wanted to come

>>105656402
>programming was this natrually until the femalres wanted to come
C/C++ programmers just made themselves into "females" instead.

>>105656417
its camoflodge their trying to beldn in with the dominant life vorm

>>105652139
kek

>>105656081
how did we ever write software without your type theory masturbations?

>>105656553
We didn't. Computers were just fancy boxes until Haskell was invented.

>>105653225
with pretty much every other language, even ones Im unfamiliar with, I can glance at code and somewhat know whats going on
Rust is unreadable

>>105652221
ugly people make ugly languages

That's a lot of unreadable garbage to do a memcpy

>>105655430
>I'm tired of arguing my point about basic convenience not being a vice
nobody said it was a vice
> but if there's one thing that I do not understand how could you possibly hold it's that I don't know maybe headers and make are fucking caveman technology?
just werks if you're not a retard.
>do something serious for once with yourself
meanwhile you're here having a mental breakdown over a programming language because people here know what they're talking about and know how rust and c functions. both have their strengths and weaknesses.

>>105658385
I don't get it

>>105658385
>ifs are expressions
>insane
no, what is insane are languages that place useless restrictions on what can be used as an expression. Rust is a lot like Lisp in this regard.
anyway, that example is absolutely fucking retarded.
>look how retarded my retarded-on-purpose code looks!!!

>>105652126 (OP)
Why do you code in rust? Why do you want to be congratulated for pushing your head deep inside your asshole?
That is degenerate and goes against nature.