hepta

Doesn't seem like valid JS, you wouldn't need mark.js if that were the case.

Maybe we have to dig into the specifics: there's a lot of things that can be done with Name, regardless of where the name belongs, is that what you mean? If so, most typed languages let you say that Person can be a thing with a Name. I don't have Clojure experience so we might be talking past each other here.

I do agree that there are problems where the "maps of facts" approach is better suited than ADTs. I'm not sure if those are the majority of problems we're solving. You can still do all that in a typed language, using dictionaries. You can be as precise as you want. In some sense you lose that without a type-checker.

I only have my experience (which is about 1/4 of his) to lean on. And I've only had problems when protocols are not well understood by all parties, never the opposite. Talking in the level of ADTs (or some representation that is equally precise) tends to either clear things up, or uncover problems that were not obvious in informal discussion.

There is code that doesn't `constantly cast ti and from Object`, most code won't need to, anyway. Generic information is kept during type-checking and then is discarded, this can be considered an optimization. There are some warts that appear because of erasure, but I believe you're wrong in implying that most developers care (most java developers, maybe scala peole have more issues because of erasure).

The only down side is removed compatibility with other languages like C and C++ and C#, locking in the app to a specific language more.

Using a Stream instead of a for loop does very little to make your code incompatible with C. It is already pretty much incompatible (modulo JNI).

What I mean is: if you want something that looks like C just use that, there is no gain in not learning new constructs just because older languages did not have them.

I imagine there is a way to raise a cow for beef that I find ethical. I don't know if you can do so for dairy cows. As far as I know, the cow has to have young to lactate, meaning it must be impregnated frequently. Am I wrong?

This is in constrast with chicken eggs, which I believe can be ethically produced (even though they aren't in the large majority of the industry).

Yeah, I'd like to know what the experience is for people who use it regularly.

I already use vavr, sadly such pattern matching is not exhaustive, which is the most important feature for me.

I think both are not exhaustive (or don't have exhaustiveness enforced by the compiler).

This seems like nitpicking as well. If the intention is that everything is an expression (that seems to be it, to me) then you have to have a Unit, no mater what you call it. I'd rather have a name that 3 academics know than override a distinct concept (Void) or make something entirely new.

What are your problems with spring boot? What bloat are you referring to?

Maybe passing around a random generator explicitly is not what we want.

That's fair. What I often want is to pull a function out of my program and test it without a lot of work. This is easy if the function is pure.

My point is that hidden state is not bad when the explicit simulation of state is cumbersome to use.

That depends on your goal. If your intention is to make state explicit, then by definition there has to be more code to make it so. Again, a preferable abstraction for this makes the boilerplate go away, while keeping everything pure. That added effort gives you testability but I know there are instances where that effort is not worth it.

You use a generator that receives a state and returns a random number and the modified state. You'd want some additional abstractions to make that work well.

That's the risk of reading articles like the OP, where they show you a couple functional tricks in an imperative language that inherently can't give you the whole picture.

The other risk is that people (like me, a few years ago) are sufficiently convinced by these simple loop examples that they decide to apply them. This might (or might not) lead to greater functional aspirations which make "whole picture" much more interesting. You might get to free monads, but not before you've used a fold on a list.

If you're already proficient in Java/JVM I personally don't see a lot of reasons to use Go. Maybe for extremely small services or if you can't take the higher memory requirements.

It relates to typing as a method of encoding invariants, yes. I was trying to say that it is unrelated to which "type" of typing. That is, I can perfectly imagine a statically typed language where you could encode such restrictions as easily as you do with Elixir and you would get the same result, a runtime error.

Regarding your rating example, you could encode that restriction in a type (or class in OO) and have a guarantee that once you have an instance of that type you no longer need to check for it's validity. Rendering a Rating would never fail at runtime, you'd get a type error first.

Even though that may be factually correct, it doesn't seem to be related to static typing. Haskell has guards but they are slightly different.

Depends on your goals, Java isn't the best if your aim is to learn FP.

I see now, probably just something to do with formatting/escaping, the <> are being swallowed.

Yes, it's strange. I'd prefer to map a null in a DTO to an empty optional. I'd like even more to never have nulls in the dto in the first place.

I assumed the omission was for brevity, but there are annotations and 'final' in a lot of places.

Similarly, methods for mutation (compulsory, no less!) are red flag in FP.

Interop with Java seems unlikely unless they keep a JVM tucked away somewhere.

It's a difficult line to place, for instance is pain avoidance plus memory enough? If I imagine a fish thinking "I can't do that again" that certainly looks like sentience, but the resulting behavior (avoidance) can occur without sentience, it seems.

Is something like that been demonstrated in other animals?

You don't need to be a good chef to know a meal is awful. A lot of people use the language (me included) and make it work, doesn't mean it's without fault.

In what ways is this different from ECS? It's strange to me that you can do the same thing in slightly different ways.

My god, I feel much better with my puny abuse.

The point (or the reason why I use it) is to express the possibility of absent values, same as Rust, Haskell, etc. That the language let's you have null references is another (bigger) problem.

That's not what I meant. My reply to you needs the context of the parent comment.

To "miss the known universe" was the explicit purpose of the designers. It was supposed to be simple (whether their definition is good or not is debatable). The number of users is irrelevant.

What if lodash itself was unpublished? I'm having a hard time drawing a line here, obviously a 10 line function is too far on the bad side of lazy, but I can't tell what is an acceptable dependency.

It might be that the designers chose to focus on specific problems they found at Google, universe be damned. Maybe Go is just a good Google language.

Wait a minute, is this a troll post? Interfaces? I get the tooling, maybe, and CSP out of the box, I don't understand what's great about Go's interfaces (compared to plain old boring Java, for instance).