@benrob0329 oohh - it’s amazing that Typst is powerful enough for it to even be possible to create the pipeline operator in it!

in the past I’ve played with the idea of reversing the order of a function and its arguments:

(args)someCall

so that my “functional language” example would look like this instead:

( ( (args)someCall )anotherCall )aThirdCall

that way, for a simple example like this you can read the order of the operations from left-to-right. although this is very unintuitive to me. I think a much better solution would just be to make it so that function composition is left-to-right instead of right-to-left:

someCall . anotherCall . aThirdCall $ args

but even then, things get trickier once you have functions which need multiple arguments:

let foo = someCall(args);
foo = anotherCall(moreArgs, foo);
foo = aThirdCall(foo, yetMoreArgs);

so you really need proper pipeline syntax for that:

let foo = someCall(args)
    |> anotherCall(moreArgs, %)
    |> aThirdCall(%, yetMoreArgs);

(~> (someCall args)
  (anotherCall moreArgs _)
  (aThirdCall _ yetMoreArgs))

IMO it should be way more common for a programming language to let you express a series of data-transformations as a left-to-right pipeline

like instead of doing this:

let foo = someCall(args);
foo = anotherCall(foo);
foo = aThirdCall(foo);

let me do this:

let foo = someCall(args)
    |> anotherCall
    |> aThirdCall;

a lot of functional languages do this even worse than in my first example, because you have to write it like this instead:

let foo = aThirdCall( anotherCall( someCall(args) ) );

or in Haskell syntax it would be more like this, I think:

foo = aThirdCall . anotherCall . someCall $ args

in both cases, the functions go in right-to-left order instead of left-to-right which IMO is pretty counterintuitive

(Lisps do this really well though, thanks to threading macros 💙)

@mitsunee that is so fucking real. the universal Dark Souls experience

@CenTdemeern1 oohh that makes sense! and these drawings help a lot too

No, Signal has not been hacked. However, we do recommend turning off showing Signal content in notifications because the content is stored in memory on device. Apparently, this memory can be retrieved if an attacker has physical access to an unlocked device and has the right tool.

https://activistchecklist.org/signal/#signal-disable-notifications

@rowan extremely good point lol

@rowan it’s amazing how such a popular and well-loved ecosystem can be such an unmanageable clusterfuck for daily use (I’m also stuck on Neovim)

@Nundrum thank you for all of this info! this is all super helpful to have

I’ve actually watched that specific Rich Hickey talk before (it’s the only one of his that I’ve watched) and I think I understand at least somewhat the concepts that he’s talking about, and I think they’re pretty interesting too. I definitely want to experiment with writing code how he’s suggesting and see if I like that style

also, it’s great to know that there’s a Slack! I might join if I can work up the courage lol, since I’m pretty shy. but it’d be great to talk to folks who really know the language and can answer my questions about the {best / most idiomatic} ways to do things in Clojure

@Nox ohh that makes sense! I get so overwhelmed in FFXIV that I don’t really pay attention at all to a boss’s tells lol, but that does sound like it’d fit right in with FFXIV’s heavily stylized combat

@rowan oh - true! it is terrifying and awe-inspiring, as a cryptid should be~

@rowan yess! I can’t wait to see what it’s like when you race with the full setup 💙

I ask because one of my partners told me that it’s actually a video game trope for slamming attacks to deal an AoE, but that’s not something that happens in video games that I play so I was taken by surprise by that (just like how I was taken by surprise, and assumed it was a glitch, that slamming attacks in Dark Souls 1 deal a moderate-to-large AoE)

if you had never played a Soulslike game before and you saw a boss slam their weapon heavily into the ground, how big would you expect the hitbox to be?

question for #Lisp users out there: what’s your workflow for changing the signature or return type of a function?

like let’s say I’m making a poker game and I have a (score hand) function, but then I want to have bonuses for different players, so I change it to (score hand player)

let’s say that there are a lot of calls to (score), because not only does the game itself use it in several places, but so does the AI to check hypothetical situations. that means that other functions’ signatures will have to change too, to incorporate player

what would your workflow be for doing this refactor?

I ask because I heavily rely on static analysis from my LSP for this type of refactor, but a lot of Lisp LSPs don’t seem to have the types of static analysis that I rely on (checking function arity, argument types, and return types), and I have a lot of trouble with the stack traces from languages like Racket (I think that might have something to do with tail call optimization and/or macros)

@mdallastella ooh that’s incredible! that’s honestly ideal for me, and I never would’ve guessed that clj-kondo would have integration for a third-party library like this