To do inline comprehension or not?

[paul-hammant]

Hypothesis:

objs = list.map(srcs) |x| { return x + ".o" }                                                                                                                                                                                                                                           
filtered = list.filter(files) |x| { return string_ends_with(x, ".c") }       

Open question; How would we do:

res := []int{}                                                                                                                                                                           
for _, v := range data {                                                                                                                                                                 
    if v%2 == 0 {                                                                                                                                                                        
        res = append(res, v*v)                                                                                                                                                           
    }                                                                                                                                                                                    
}

And that with a comment "I guess it comes down to what is small enough a language and what is left out. Go rejects the functional style to my understanding or at least does not offer it in it's standard library, because the language wants to
be small. Aether to my understanding does not want to be that small, or has just a different flavour."

Thoughts on that last

The Go code is a filter-then-map: keep even numbers, square them. In Aether with list.map and list.filter:

// Two-liner (filter then map)                                                                                                                                                         
evens = list.filter(data) |v| { return v % 2 == 0 }                                                                                                                                    
res = list.map(evens) |v| { return v * v }                                                                                                                                             

That's clean but it's two passes and an intermediate list. The Go version does it in one pass. To match that, you'd want a list.filter_map that does both:

// One-liner (filter + map in one pass)                                                                                                                                                
res = list.filter_map(data) |v| { if v % 2 == 0 { return v * v } else { return null } }

But that's getting awkward as the null sentinel for "skip this element" is ugly.

The honest answer for the maintainer: Aether's trailing block style doesn't naturally compress to one-liners the way Python comprehensions do. And that's fine. The Go code is 5 lines and perfectly readable. The Aether version is 2 lines and also readable. Trying to force it into 1 line fights the language's block-based nature.

The real question is whether list.map and list.filter earn their place as stdlib functions. I'd say yes - they're the most common list operations after iteration, they compose naturally with trailing blocks (which is Aether's signature), and they're about 20 lines of C each. They don't make the language bigger - they're library functions, not syntax.

More linguistic framing:

• Aether won't be a one-liner-functional language like Haskell or even Python - But list.map/list.filter with trailing blocks are natural Aether - they use the DSL mechanism that already exists
• The Go comparison: Go's for-loop is 5 lines, Aether's list.filter + list.map is 2 lines, both are clear - No new parser work, no new syntax — just stdlib functions that accept closures

[TG0]

A bit related, I started this discussion: #125

[nicolas-maman]

Exactly right; map, filter, and filter_map as stdlib functions, not new syntax. The two-liner is perfectly readable and fits how Aether works. No need to chase one-liner comprehensions.