| ; (group-by f list): call f on each item in list. The return value becomes a key | |
| ; of the resulting map, whose keys map to the list of items for which f returned | |
| ; that key. | |
| ; (vals map): returns a list of the values of the map. | |
| (defn anagram [words] (vals (group-by sort words))) | |
| (= (anagram ["star" "rats" "car" "arc" "stars"]) | |
| [["star" "rats"] ["car" "arc"] ["stars"]]) ; true |
With the release of Node 6.0.0, the surface of code that needs transpilation to use ES6 features has been reduced very dramatically.
This is what my current workflow looks like to set up a minimalistic and fast microservice using micro and async + await.
tldr: Flow is built to find a lot more kinds of bugs than what TypeScript is built for.
Flow avoids as much gratuitous unsoundness as possible in order to find more bugs: It never infers any, it models variance for objects/functions/type parameters soundly (this is critical), it minimizes type precision loss, it has sound support for various dynamic features with inference (Function.prototype.bind()/Function.prototype.call()/Object.assign()/etc), etc.
Flow infers and understands more kinds of types with fewer annotations. Extensive inference was important to us for easing the process of converting untyped code without missing errors as much as possible. It also helps reduce boilerplate when writing new, typed code. You get to decide if and when you want to express types in your code (with type annotations), but Flow will pick things up from there without much worry of losing type info.
Flow is built on top of a more general level of code understandi
I really liked @tjvantoll article Handling Failed HTTP Responses With fetch(). The one thing I found annoying with it, though, is that response.statusText always returns the generic error message associated with the error code. Most APIs, however, will generally return some kind of useful, more human friendly message in the body.
Here's a modification that will capture this message. The key is that rather than throwing an error, you just throw the response and then process it in the catch block to extract the message in the body:
fetch("/api/foo")
.then( response => {
if (!response.ok) { throw response }
return response.json() //we only get here if there is no error
})
