It's a force multiplier when you have a small team of strong developers.

So some Kubernetes experts migrated to AWS for $1k in credits. This is madness. That's weeks of migration work to save the equivalent of a day of contracting.

This is not what they meant by inspection.

What they mean is that you can write a function, in Haskell, that given a value in the DSL, it returns the list of all requests it will perform on execution.

This can be useful for tests, security, caching, performance, debugging...

> For an intuition why this is true, consider that the constant functor Const r has an Applicative instance whenever r is a monoid, because pure stores a mempty value and (<*>) combines the held values with (<>). For a fun exercise, implement runAp_ in terms of runAp and Const.

Really?

Comments URL: https://news.ycombinator.com/item?id=45578040

Points: 3

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=45526042

Points: 63

# Comments: 15

2. There is a run-time overhead to wrapping

IMO a design goal of programming langauges should be for the most readable code to also be the most performant.

Language features tend to be controversial until they are mainstream.

> You can still make it work by adding it to the prototype

This is exactly what we want to avoid!

Sequences are a common example.

So this:

    xs.map(x => x * 2).filter(x => x > 4).sorted().take(5)

    xs |> map(x => x * 2) |> filter(x => x > 4) |> sorted() |> take(5)

    xs 
    |> map(x => x * 2) 
    |> filter(x => x > 4) 
    |> sorted() 
    |> take(5)

But why is this better?

Well, suppose the operation you want is not implemented as a method on `xs`. For a long time JavaScript did not offer `flatMap` on arrays.

You'll need to add it somehow, such as on the prototype (nasty) or by wrapping `xs` in another type (overhead, verbose).

With the pipe operator, each operation is just a plain-ol function.

This:

    xs |> f

    f(xs)

The F# version of the proposal was probably the simplest choice.

Comments URL: https://news.ycombinator.com/item?id=44810310

Points: 2

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=44222594

Points: 1

# Comments: 0

Personally, I think that FP could be a great fit, but we first need to come up with architectures that solve real game development problems. We have to do this with small scale experiments first (game jams are perfect for this) and then scale up only if they succeed.

This project is exactly that - kudos to the author.

Comments URL: https://news.ycombinator.com/item?id=41096187

Points: 141

# Comments: 10

Comments URL: https://news.ycombinator.com/item?id=40760527

Points: 2

# Comments: 0