.

>>105905538 (OP)
I will use D once they unify their minds on which compiler and which standard library is "the default"

>reinventing pipes

>>105905538 (OP)
>completely arbitrary example that no one ever will encounter in the wild
Smells like common CS degree bs.

>>105905538 (OP)
D would be good if it stopped trying to be Java and remained marketing itself to C++ users.

>>105905538 (OP)
Cniles don't have to answer to that because many imperative programming languages copied syntax from C. That includes Java, C#, and C++.

That is not a very good system because it turns out to be inflexible. Let's say I have add(a,b) and now I come from math and would like to do add(4) which would return another function where the first argument is always 4 and the other whatever I want. Can I do that with such syntax? No. It doesn't even make sense. The arguments are a tuple and all have to exist.

Now take something like Haskell. The signature is add -> a -> b (it's missing the return type but whatever). You can do what I mentioned because every single function in Haskell only has one argument.

Universal is not always the best.

>>105905538 (OP)
D is actually pretty based, full of good idea. I'm surprised it never really caught on.

>>105905651
even if your particular currying add(4) which arbitrarily assumes commutativity were part of a C-like standard, it would not be overridden by 2.add(4) because of the 2.

by the way, very cool that you stan haskell in 2025, I thought you trannys had all kys

>>105905625
D only really created a workaround to have currying. It's not flexible either. Scala did the same thing.

>>105905718
You can flip it like you do with D. There's no real order of argumenta in Haskell. I understand the logic of D but it's not the most flexible approach. It's still better than inflexible C though but I think Scala did this slightly better. Not by much granted.

>>105905651
Wtf are you talking about retard, you can just define another function add4

>>105905538 (OP)
Haskell $ composition is better

>>105905538 (OP)
>a.b.c.d(3).e.f.g
is not clear. c.d(3) makes sense but for the rest of them it looks like you're accessing fields instead of calling functions
>a().b().c().d(3).e().f().g()
would be more clear

>>105905538 (OP)
That is not a dramatic improvement in clarity.

>>105907228
This is why Rust is better.
:: for accessing namespace
. for method call.

>>105905538 (OP)
It's actually not that bad, I think scripting languages could benefit from this
Consider this random example I made up with real function names (not a real language, just a fictitious made up example):
>log(clamp(1, 10, tonumber(assert(input()))))
Rewritten with the proposed syntax:
>input.assert.tostring.clamp(1, 10).log()
It's very intuitive

>>105905538 (OP)
it seems like a nice addition but i don't think it needs an answer

>>105905538 (OP)
padleft("urmom, "-", 6)
"urmom".padleft("-", 6)
ok that is pretty neat
don't need it tho

>>105905538 (OP)
(+ 1 2)
(1 + 2)

at long last! we have solved lisp
thank you walter

>>105907243
longer UFCS chains work a lot better with the right formatting
a
.b
.c
.d(3)
.e

With that you can now freely comment out/extend/iterate, etc.
But a lot of programmers often struggle to see the value in less-popular styles.

>>105907264
broken bot

>>105908150
done

>>105907264
C++ did that first

>>105905651
>Let's say I have add(a,b) and now I come from math and would like to do add(4) which would return another function where the first argument is always 4 and the other whatever I want
then you are just fucking wrong, are you a fucking LLM or something?
>let's say I have no relevant knowledge how to do this and just hallucinated how it should work when I do something, am I right?
Probably fucking not. You are presupposing not knowing the language. Do understand that save for including a mind reading device, there's literally nothing that can be designed into a language that can fix your problem of not knowing it? Because whatever solution is in the language would require you to know the language to make use of it, making it a catch-22

Languages are not designed for randoms off the fucking street and whatever they came up that they'd "like to" do. They are designed for people that use it, which is a subset of people that know it.

>>105907228
youi can do both

>>105905612
I get frustrated by not having this all the time. Ever tried using itertools python? It sucks because it doesn't have this (and only single line lambdas).
C would especially benefit since it you can't associate functions with structs.
>>105907228
most of the time, it's clear from context if it's a function call or not. Otherwise, using parenthesis makes sense, yeah.

>invents situation that never happens
>"solves" it

>>105908364
C++ has no UFCS.

>>105905538 (OP)
any time your code looks like
>g(f(e(d(c(b(a))),3))))
i can say with complete confidence you are doing something that breaks fundamental code principles.

>>105908845
java people do that shit all the time, only with much longer function / method names.

>>105908866
doesn't mean it's right. java has so much boiler plate that java devs try to avoid adding any more with horrible code. but it's still horrible

>>105908845
>i can say with complete confidence you are doing something that breaks fundamental code principles.
factual

>>105908866
>java
that language is a mess.

>>105908845
did you never do a shell pipeline with more than 3 steps?
Once the syntax facilitates doing this easily, it's not bad anymore and you tend to use it more. No need to introduce unnecessary throwaway variables anymore.

>>105905538 (OP)
I like D but Nim has the same feature.

>>105908866
It isn't "Java people" who do this. It is wagies, and wagies do this because they are shitty programmers.

>>105905538 (OP)
Just use rainbow brackets in your ide.

>>105905538 (OP)
In what fucking universe are you going to nest 6 functions like that?

>>105905538 (OP)
No shit it's hard to figure out what's going on you have mismatched parens. He has 6 ( parentheses and 7 ) parentheses.

>>105909246
>>105909305
https://github.com/openjdk/jdk/blob/master/src/jdk.jlink/share/classes/jdk/tools/jlink/internal/ModuleSorter.java#L72

>>105905538 (OP)
who the fuck writes code like that? i would fire any of my reports that pulled that shit

>>105905538 (OP)
what happens if one of those returns null

>>105908527
nigger what? you can put a function pointer in a struct. look at python's c source

>>105909445
a tranny gets its wings

>>105909445
In D you'd use native contract programming features, so you could either catch the null getting returned out, or passed in, or turn it into an Optional

>>105905538 (OP)
hey look. python classes.

>>105905538 (OP)
c.u.rr.y is as unreadable as n(i(gg(e(r)))). Why not just assign a few results from those functions to variables in the first place?

you should never call more than 2 functions deep to start with

>>105909305
rust universe

>>105905538 (OP)
g . f . e . flip d 3 . c . b $ a
haskell!

>>105905538 (OP)
Please tell me this is a troll.

>>105905538 (OP)
>>105907264
>>105909982
How do you feel about the proposal for Rust with infix pattern matching?
https://github.com/rust-lang/rust/issues/121618
https://github.com/rust-lang/rfcs/pull/3295
https://github.com/conradludgate/rfcs/blob/postfix-match/text/0000-postfix-match.md

foo.bar().baz.match {
_ => {}
}


(Yes, they misnamed it as postfix when it is actually infix).

>>105905538 (OP)
>>105908273
>>105907405
>>105909393
>>105910145

>>105911523
C++ wanted something similar, but backwards compatibility and unanswered questions caused problems.
One difficulty is that "a.b" in some languages imply namespacing, as per usual OOP. As in, "b" is not global, but specific to whatever the type or runtime object that the expression "a" has.

In Haskell, there are sometimes various annoyances in practical code with not having this kind of OOP namespacing of functions.

Different trade-offs.

>>105911698
>C++ wanted something similar, but backwards compatibility and unanswered questions caused problems.
Thank fuck. C saves the day again.

>>105905538 (OP)
Forth doesn't have this problem.

>>105911682
ehh, kinda ok...

>>105905538 (OP)
> a.f(x) same as f(a,x)
Is this where Python got that self insanity from?
>def f(self,x):

How about
a
|> b()
|> c()
|> d()
|> e(3)
|> f()
|> g()

>>105909393
That's a lambda. That isn't even the same language construct the OP is talking about.

>But what about this c cniles
What about it? This is terrible code and would be called out if anyone with a brain was reviewing this code. Its a cool bike shed, but considering the computer is doing the same thing either way spreading this out to make it more clear, is the correct call. Doing fifty things in one line is just code golf bullshit that just makes reviewing code harder for no real benefit.

>>105912413
c++ has a implicit "this" as the first argument of any method.
implicit anything in programming is retarded. we learned this 70 years ago with fortran.

Why do tech trannies spend their whole lives arguing about HOW something should be written? Is it because they write nothing of interest? It would be like shitty fanfic writers arguing about Oxford commas to no end.

>>105911682
Give me for else

>>105913469
Explain what "for else" means.

>>105913105
Your brain is small and ill, and your penis is crooked and tiny. Sperging at people online won't change these things.

>>105913484
A for loop can finish by either reaching the end of the iterator or breaking
For else lets you add an else clause to the for loop, to be executed if you reaxhed the end without breaking
This allows for loops to evaluate to a value, either by breaking from the main loop body or evaluating to a guard in else. "loop" loops in rust can already do this, since you have to break out of them, so there's no path where they exit with no value
Basically, if you've ever used
>found = false; for { ... }; if !found
Or a method chain that went collection -> option -> or_else/default
That's where for else would be used

>>105905538 (OP)
Stop being a clean code modulating anti dry fucking retard and write ONE function that does a() b() c() d() e() f() g() instead.

>>105912450
based elixirchad

>>105909455
in what world is obj->f(obj) better than just obj.f()?

>>105905538 (OP)
Nim does it better, but it's nothing more than a syntax nicety.
Howeverthoughbeit, method chaining niggers should be culled for their disgusting mockery of piping.

>>105905538 (OP)
this will get very confusing very fast if you have more than one argument
also, stop golfing in production, fucking black gorilla niggers

>>105905538 (OP)
How about you just stop nesting 50 function calls?

>>105905538 (OP)
There is never any practical reason to nest that many calls on a single line. I add in local variables just to make the code more readable so that this never happens in the first place.

>>105905651
>Math faggot
>Useless programmer
A tale as old as time.

>>105905538 (OP)
That is a really bad idea and it can only lead to more irregular code.

>>105914120
hmm no I don't think I will

>>105905538 (OP)
Parenthesis version is clearer. But either way it's retarded code.

for me it's
#define E_COEFF 3
result_type tmp = a;
tmp = b(a);
tmp = c(tmp);
tmp = d(tmp);
tmp = e(tmp, E_COEFF);
tmp = f(tmp);
tmp = g(tmp);

Because that looks like the kind of code you want to print intermediate values to verify that it's working and maybe return early once you actually see the code in action.

That looks even more cancerous than a normal function chaining.

>>105913585
Isn't that just a snippet at the end of the loop saying if(value==lastvalue){}

>>105915043
No.

>>105905538 (OP)
What kind of a retard would write this code? If you are writing this no programming language will save you from rope.

>>105907405
i want to kiss this child on the lips beautiful baby please have sex with me and we can cuddle afterwards

>>105905538 (OP)
ufcs should use a different operator than dot otherwise the lsp spergs out and spams the autocompletion window for all matching function which sucks. Idk maybe > or some other pipe operator.

>>105913585
lisp has this

>>105914876
>tmp
pick better names

>>105915118
yes. so does python. it is a useful construct.

>>105914876
What if the functions all return different types?

>>105914876
based

>>105915357
I'd use ret

>>105905538 (OP)
No idea why you bring up C when that is the last language where you would even see this example. C programmers are overwhelmingly religious 80 char small function zealots. This is more applicable to J(eet)ava.

>>105905538 (OP)
g ( f ( e ( d ( c ( b (a
) ) ) ) ) ) )<-

>>105915357
nig

nesting function calls is like having transitive dependencies

>>105905651
>would like to do add(4) which would return another function where the first argument is always 4 and the other whatever I want
Not the first argument, but def add(a, b=4)?

>>105905553
We don't do that, anymore. We can't even agree on a standard Wayland compositor

>>105908527
>I get frustrated by not having this all the time. Ever tried using itertools python? It sucks because it doesn't have this (and only single line lambdas).
you know understand why Perl's syntax makes sense
sort { ... } grep { ... } map { ... }

*now

>>105921753
>perl
>make sense
what

>>105907228
>>105909577
excel formula chad here
g(f(e(d(c(b(a))),3)))) is the only correct way
anyone who says or thinks otherwise must chop his cock off
>>105905952
langType <- "toy lang"

>>105905538 (OP)
https://godbolt.org/z/8nTbro4aj
#define λx(...) [](const auto& x) { return __VA_ARGS__; }

auto operator * (auto a, auto b) {
return [=](auto x){ return b(a(x));};
};

int main() {
auto a = λx(x + 1);
auto b = λx(x + 2);
auto c = λx(x + 4);
auto d = λx(λx(x * 3));
auto e = λx(x + 8);
auto f = λx(x + 16);
auto g = λx(x + 32);
auto h = a * b * c * d(3) * e * f * g;
return h(0);
}

Simple as.

>>105908527
>most of the time, it's clear from context if it's a function call or not.
What if your have polymorphic function or the function itself has methods?
print(value.method.hash)

Are you printing hash of a return of that function or maybe hash of the function, or maybe the method hash of method or maybe the method hash of the return of method.

>>105921965
Or even worse
value.method.hash.print

>>105921804
generic troll post #1231432345245

are you paid enough to eat what you want?

>>105905538 (OP)
https://godbolt.org/z/P8dEjf3Ev
#define λ(x, ...) [=](auto x) { return __VA_ARGS__; }

auto operator * (auto a, auto b) {
return [=]{ return b(a());};
};

int main() {
auto a = []{return 1;};
auto b = λ(x, x + 2);
auto c = λ(x, x + 4);
auto d = λ(x, λ(y, x * y));
auto e = λ(x, x + 10);
auto f = λ(x, x + 20);
auto g = λ(x, x + 40);
auto h = a * b * c * d(3) * e * f * g;
return h();
}

>>105909467
Redbull sisters… our response ?

>>105922056
What did he mean by this? Kek

>>105922076
https://godbolt.org/z/Wz77WY4PW

>>105905538 (OP)
I disagree with the premise that it is unclear. Noisy maybe, but clear if you read it slowly. What it actually is is a painfully contrived example. If you have code that calls 7 functions in a row like that you are either retarded or should use a functional language where that is the point. FP syntax is much more elegant than that abuse of the dot operator.

>>105922383
holy shit finally a reasonable and logical reply in this shitsmear of a thread.
You can't just imagine a problem and come up with a ''solution'' that only promotes bad code

>>105905651
Why would I want to do any of that?

>>105905538 (OP)
It's hard to figure out what's happening because there are seven functions with non-obvious return values being called in one line of code. It's absolutely ludicrous.

This only makes any sense as a workaround for a language that wants to have objects and methods but hasn't made them a language feature. As soon as you have them, you no longer need this nonsense.

Just imagine how impossible it is to read the equivalent of this where b, c, e, f, and g all have multiple arguments, some of which derive from their own functions. a.b(true).c(1, "Test").d(3).e(a.h(x), a.i(y)).f.g GOOD FUCKING LUCK

>>105922426
My coworker literally does that all day

>>105905538 (OP)
>g(f(e(d(c(b(a))),3))))
>It's a little hard to figure out what is happening
Only if your mom drank when you were a fetus.

*POTENTIALLY* saving an extra second reading the code carefully is not worth the massive extra bloat with any of the more "readable" languages and the readability issue is not even an issue if you have/follow good code style formats.

>>105922447
>massive extra bloat
it's mostly just a change in the syntax, retard

>it's another "clojure wins" episode

>>105905538 (OP)
static int a() {return 1;}
static int b(int x) {return x + 2;}
static int c(int x) {return x + 4;}
static int d(int x, int y) {return x * y;}
static int e(int x) {return x + 10;}
static int f(int x) {return x + 20;}
static int g(int x) {return x + 40;}
#define ٠(o) ;x = o(x)
#define ٠2(o, c) ;x = o(x, c)
int main() {
int x = a()٠(b)٠(c)٠2(d, 3)٠(e)٠(f)٠(g);
return x;
}

https://godbolt.org/z/8a71xx9Kd
Are you happy now?

>>105922183
What are you trying to say?

>>105922702
Anon, this stuff is not for you.

>>105922437
smear shit?

>>105922710
Why is it so difficult for you to express your efforts into English words?

>>105923271
everything is assembly and everyone in this thread and on this board that argues over languages is retarded

>>105905538 (OP)
That's not even valid, there are 6 opening parens and 7 closing.

g(f(e(d(c(b(a))),3))))

expands to
g(
f(
e(
d(
c(
b(a)) # <-- ?
),
3
)
)
)
)

so it should be
g(f(e(d(c(b(a)), 3))))

I think C# can do this with type extension.

>>105923310
based

>>105923600
Thought it'd be cool but it's actually kinda meh.
Writing the templates wasn't fun.
I guess F# is more appropriate for something like this.
class Program
{

static void Main()
{
int n = 5;
n.Inc().Mul(6).ConvertTo<double...>().Sum(10, 20, 5, 10.5).Div(5).Print();
}

static int Inc(this int a)
{
return a + 1;
}

static T Mul<T>(this T a, T b) where T : operator T * T
{
return a * b;
}

static T ConvertTo<T, TFrom>(this TFrom a) where T : operator explicit TFrom
{
return (T)a;
}

static T Div<T>(this T a, T b) where T : operator T / T
{
return a / b;
}

static T Sum<T>(this T a, params T[] nums) where T : operator T + T
{
T sum = a;
for (let n in nums)
{
sum += n;
}
return sum;
}

static void Print<T>(this T a)
{
Console.WriteLine("{}", a);
}
}

>>105905538 (OP)
it's just a (bad) version of diagrammatic order. We use it in category theory all the time.

In non functional programming languages (but also in pure functional one) it doesn't happen to have a chain of more than 3 functions
If it does happen, there's something wrong with your code
Still the problem should be solve something else, like with a pipe operator instead of this retardation

So this is basically
> What about this scenario that basically never happen? We solved that
This is a clear example on why D never took off really. There's no amount of competence that will solve being retarded