3 ms·
The F# syntax looks/acts a lot better here (especially paired with lodash). I also feel your code example wasn't done in the way people would actually use pipes
by hajile 4y ago
The F# syntax looks/acts a lot better here (especially paired with lodash). I also feel your code example wasn't done in the way people would actually use pipes.
import {map, join} from 'lodash/fp' //iterators have better performance
envars
|> Object.entries
|> map(([key, val]) => `${key}=${val}`)
|> join(' ')
|> x => chalk.dim('$ ' + x, 'node', join(' ', args))
|> console.log
Even without lodash, it's still easy to read.
envars
|> Object.entries
|> x => x.map(([key, val]) => `${key}=${val}`)
|> x => x.join(' ')
|> x => chalk.dim('$ ' + x, 'node', join(' ', args))
|> console.log
For sake of completeness, here's the hack-based variant
envars
|> Object.entries(%)
|> %.map(([key, val]) => `${key}=${val}`)
|> %.join(' ')
|> chalk.dim('$ ' + %, 'node', join(' ', args))
|> console.log(%)
- captainmuon 4y agoThe F# syntax would endlessly confuse me though. I'd always wonder whether |> join(' ') means join(x, ' ') or join(' ', x).
- hannasanarion 4y agoin F# syntax the right side is always a unary expression, so `|> join(' ')` means `|> join(' ')(x)` (the requirement being that join(' ') returns a function that takes one arg)
- hajile 4y agoThe top example relies on Lodash/fp having curried functions you can use. The middle example would be using native stuff which is why you have the wrapper function (kinda like you'd have a function wrapping a callback)
- de_keyboard 4y agoThe F# syntax is an incredibly simple bit of syntactic sugar. Just replace this: x |> f With this: f(x) For the join example, you must do this: xs |> (x => x.join(' ')) It de-sugars to: (x => x.join(' '))(xs) ... which of course is simply: xs.join(' ')
- captainmuon 4y agoSure, I know. What I actually mean is that I don't grok curried functions. Does join(a)(b) mean join(a, b) or join(b, a)? Does it mean a.join(b) or b.join(a)? And is a or b the delimiter? I don't really feel confident without looking it up or trying it out. I have a similar problem with Haskell's function syntax a -> a -> a. If the function was called makeJoinerBy(sep)(array), it would be somewhat clearer: join = makeJoinerBy(' ') result = join(array)
- epolanski 4y agoYour example wouldn't work as the function would need to be unary.
- coffeebeqn 4y agoI mean it’s still not very readable. Reading through the code I can tell that it does.. some strong things with envars.
- trekkie1024 4y agoHaving done some personal projects in F#, I'm a huge fan of the syntax. However we would need most standard functions in JS to be curried to take advantage of it.
- wruza 4y agoit's still easy to read That’s highly subjective I’m afraid. “Take entries of envvars, turn that into k=v, join that by a space, make dim $, previous that, and args, log that”. Personally I have no clue what’s going on at first glance with all these %%% “thats”. It’s meant to be declarative, but reads imperatively instead. console.log(chalk.dim( '$', ...Object.keys(envars) .map(k => `${k}=${envars[k]}`), 'node', ...args, )) “Log dimmed $, k=v pairs of envvars, node, then args”.
- hajile 4y agoThat's why I prefer the F# version where it's just the names of functions or anonymous arrow functions. Nothing magical about them. It just calls the functions in order from top to bottom.