Cool things you've seen in other languages/frameworks

Chat / Discussions
,
1

Inspired by @dogweather’s thread about Active Record Doctor, have you seen any impressive or cool things in other non-BEAM languages or frameworks? If so please share!

When taking part please note…

  • This is not a “I’d like to see X in Elixir or Phoenix" type thread.
  • It is not even a thread about things that may or may not be a good fit for functional programming.
  • It is just a thread to share cool things you’ve seen in other languages or frameworks :icon_biggrin:

Why?

Who knows, it might spark someone’s imagination to do something cool in Elixir themselves :003:

Please do not use this thread to criticise other languages or frameworks - let’s keep it focused on the positives.

5 Likes
2

Perfect spot to come to get nerd sniped.

Watching this space :laughing:

7 Likes
3

Rust has a relational db library that connects to the db while you’re coding and uses the metadata to verify your code at compile-time.

10 Likes
4

A bit off-topic since this isn’t about a specific language feature, but I recently discovered Campfire Write and I’m genuinely impressed by how they’ve tackled the worldbuilding/writing workflow problem for fiction authors.

What makes it stand out is the seamless integration between different creative phases: you can build your world (characters, locations, timeline, magic systems, etc.) and then jump straight into writing with all that context readily available. The UI manages to be both comprehensive and intuitive - no small feat given how complex worldbuilding can get.

The real clever bit is how they handle relationships between elements. Characters can be linked to locations, events to timelines, and it all feels organic rather than database-like. Plus the writing environment itself adapts to show relevant worldbuilding info contextually.

I know it’s probably not built with Elixir, but it’s got me thinking about how Phoenix LiveView could handle this kind of rich, interconnected content management. The real-time updates and stateful components seem like a natural fit for this domain.

Anyway, fascinating to see how they’ve solved the “creative chaos management” problem. Definitely sparking some weekend project ideas! :grinning_face_with_smiling_eyes:

2 Likes
5

The ‘backward’ pipe operator in F# (<|).

1 Like
6

Nothing. All cool things I have found in Elixir.

5 Likes
7

I really love zod in typescript land that bridges the dynamic and static world:

What you do is you declare a schema and it auto-generates a parser that coerces untrusted json data to a type safe object.

The dream later would be that you have an Ecto-like DSL that generates a typesafe cast(...) function similar to the parse function in zod (Basic usage | Zod). This might be worth exploring once types in Elixir land :slight_smile:

4 Likes
8

Elm’s time traveling debugger.

Step backwards or forwards through the state of your program.

7 Likes
9

Clojure’s Ifn and qualified keywords…
ifn:

> (:a {:a "A"])
"A"
>({:a, "A"} :a)
"A"

basically any data type can “behave” as a function.

and qualified keywords:

(ns this.is.my.module
  (:require
    [another.name.space :as ans]
    [this.is.name.space :as tin]))

(defn this []
  ({::a 1 ::ans/a 5 ::tin/a 6 :a 25}))

when you call this it gonna return:

{::this.is.my.module/a 1 ::another.name.space/a 5 ::this.is.name.space/a 6 :a 25}
1 Like
10

Now that you mentioned Elm… I really like elm-ui it’s like “tailwind” but with functions and that compose as any other function, that tied with currying that Elm support is really awesome.

this is a talk by Richard Feldman on style-elements(first iteration of elm-ui)

2 Likes
11

I think we can do better :wink:

1 Like
12

The Python “PRegEx - Programmable Regular Expressions” is a cool way of thinking about the problem. I haven’t tried it yet.

Here’s a regex for parsing a .com or .org URL:

from pregex.core.classes import AnyLetter, AnyDigit, AnyFrom
from pregex.core.quantifiers import Optional, AtLeastAtMost
from pregex.core.operators import Either
from pregex.core.groups import Capture
from pregex.core.pre import Pregex

http_protocol = Optional('http' + Optional('s') + '://')

www = Optional('www.')

alphanum = AnyLetter() | AnyDigit()

domain_name = \
  alphanum + \
  AtLeastAtMost(alphanum | AnyFrom('-', '.'), n=1, m=61) + \
  alphanum

tld = '.' + Either('com', 'org')

ip_octet = AnyDigit().at_least_at_most(n=1, m=3)

port_number = (AnyDigit() - '0') + 3 * AnyDigit()

# Combine sub-patterns together.
pre: Pregex = \
    http_protocol + \
    Either(
        www + Capture(domain_name) + tld,
        3 * (ip_octet + '.') + ip_octet + ':' + port_number
    )

Fetching the resulting Pregex instance’s underlying RegEx pattern.

regex = pre.get_pattern()

This is the RegEx pattern that the above method returns.

(?:https?\:\/\/)?(?:www\.)?(?:[0-9\.]+\:[0-9]{4}|([^\r\:\n\x0c\\ \t\x0b]+)(?:\.com|\.org))
2 Likes
13

NimbleParsec for Regexes? Cool!

1 Like
14

I love it. But i also feel fighting the basic tools (html and css), is a fight that you cannot win.
If you just want functions as abstractions for html elements you might want to check

and

2 Likes
15

But why use regex then? We have NimbleParsec that gives you “proper” parser instead.

1 Like
16

I’ve seen Elm being mentioned twice already, so i want to add to that as well: I’ve seriously rekindled my love for small pet projects with Lamdera, a very nice hosting solution / framework for Elm not only in the frontend but also in the backend and with “free” persistence and real time updates. It’s all just Elm commands and messages, no matter where the messages go.

Of course you have to like working in Elm, which is not everyone’s thing.

But if you do like Elm, it makes it so damn fun and easy to get started with some small idea you always wanted to work on. For me the biggest thing was much i was able to focus on my actual application and how little i have to worry about everything around (like networking, storage, migrations, hosting). It’s absolutly a “me problem”, because i’m sure more experienced people do not have any troubles setting this stuff up, but before when i worked on some toy projects like once every year it would always be a a pain to get going before i even wrote one line of code that was related to the actual idea.

I don’t have experience in scale with lamdera, but for two simple projects in the last month and a half it was an absolute dream to work with and i can highly recommend to try it out!

1 Like
17

Oh yes, function currying.

18

I like Ocaml’s labelled parameters ~argname that lets you label args and pass them positionally or with the label.

3 Likes
19

watching :slight_smile:

20

I’d be super curious how you can do better than sqlx. It’s a very solid piece of software. I used it and became an admirer. If we can have the same via Ecto or Ash, I’d be absolutely delighted.